Personalizzare un modello di applicazione

In Sviluppare l'applicazione, abbiamo utilizzato un modello predefinito (ad es. reasoning_engines.LangchainAgent) per lo sviluppo di un'applicazione. In questa sezione, esamineremo i passaggi per personalizzare il tuo modello di applicazione. Questo potrebbe essere utile se hai esigenze che vanno oltre quello che viene fornito dal modello predefinito.

Un modello di applicazione in Reasoning Engine è definito come classe Python. A ad esempio, il seguente codice Python è un esempio di una tabella LangChain di cui è possibile eseguire il deployment su Vertex AI (puoi fornire CLASS_NAME un valore come MyAgent):

from typing import Callable, Sequence

class CLASS_NAME:
    def __init__(
            self,
            model: str,
            tools: Sequence[Callable],
            project: str,
            location: str,
        ):
        self.model_name = model
        self.tools = tools
        self.project = project
        self.location = location

    def set_up(self):
        """All unpickle-able logic should go here.

        The .set_up() method should not be called for an object that is being
        prepared for deployment.
        """
        import vertexai
        from langchain_google_vertexai import ChatVertexAI
        from langchain.agents import AgentExecutor
        from langchain.agents.format_scratchpad.tools import format_to_tool_messages
        from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
        from langchain.tools.base import StructuredTool
        from langchain_core import prompts

        vertexai.init(project=self.project, location=self.location)

        prompt = {
            "input": lambda x: x["input"],
            "agent_scratchpad": (
                lambda x: format_to_tool_messages(x["intermediate_steps"])
            ),
        } | prompts.ChatPromptTemplate.from_messages([
            ("user", "{input}"),
            prompts.MessagesPlaceholder(variable_name="agent_scratchpad"),
        ])

        llm = ChatVertexAI(model_name=self.model_name)
        if self.tools:
            llm = llm.bind_tools(tools=self.tools)

        self.agent_executor = AgentExecutor(
            agent=prompt | llm | ToolsAgentOutputParser(),
            tools=[StructuredTool.from_function(tool) for tool in self.tools],
        )

    def query(self, input: str):
        """Query the application.

        Args:
            input: The user prompt.

        Returns:
            The output of querying the application with the given input.
        """
        return self.agent_executor.invoke(input={"input": input})

Quando scrivi la classe Python, puoi utilizzare i seguenti tre metodi: sono importanti per il motore di ragionamento:

  1. __init__():
    • Utilizza questo metodo solo per i parametri di configurazione dell'applicazione. Ad esempio, puoi utilizzare questo metodo per raccogliere i parametri del modello e attributi relativi alla sicurezza come argomenti di input degli utenti. Puoi usare questo metodo anche per raccogliere come l'ID progetto, la regione, le credenziali dell'applicazione chiavi API.
    • Il costruttore restituisce un oggetto che deve essere selezionabile della per il deployment nel motore di ragionamento. Pertanto, è consigliabile inizializzare i client di servizio e stabilire connessioni ai database nel metodo .set_up anziché nella Metodo __init__.
    • Questo metodo è facoltativo. Se non è specificato, Vertex AI utilizza il costruttore Python predefinito per la classe.
  2. set_up():
    • Devi utilizzare questo metodo per definire la logica di inizializzazione dell'applicazione. Per Ad esempio, puoi utilizzare questo metodo per stabilire connessioni ai database o servizi dipendenti, importare pacchetti dipendenti o precalcolare i dati utilizzati per la pubblicazione di query.
    • Questo metodo è facoltativo. Se non è specificato, Vertex AI presuppone che l'applicazione non debba chiamare un metodo .set_up prima di essere gestita le query degli utenti.
  3. query():
    • Devi utilizzare questo metodo per definire la logica di runtime che gestisce le query utente. Ad esempio, usi questo metodo per generare contenuti con l'IA generativa. o recuperare dati in tempo reale da API esterne.
    • Questo metodo è obbligatorio. Se non è specificato, ReasoningEngine restituisce un errore quando tenti di creare un'istanza remota un'applicazione.
    • Devi fornire a questo metodo una docstring chiara che ne definisca la funzione, ne documenta gli attributi e fornisce annotazioni di tipo per i suoi input. Evita gli argomenti delle variabili nel metodo query.

testa l'applicazione in locale

Crea un'istanza dell'applicazione nella memoria locale utilizzando il seguente codice:

agent = CLASS_NAME(
    model=model,  # Required.
    tools=[get_exchange_rate],  # Optional.
    project=PROJECT_ID,
    location=LOCATION,
)
agent.set_up()

Puoi testare l'applicazione inviando query di prova all'istanza locale:

response = agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?"
)

La risposta è un dizionario simile al seguente:

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 # ...
 "output": "For 1 US dollar you will get 10.7345 Swedish Krona."}

Passaggi successivi