Personalizzare un modello di applicazione

Durante lo sviluppo di sviluppa l'applicazione, abbiamo usato un modello predefinito (ovvero reasoning_engines.LangchainAgent) per sviluppare un'applicazione. In questa sezione esamineremo i passaggi per personalizzare il tuo modello di applicazione. Ciò può essere utile se hai esigenze che vanno oltre a quanto fornito dal modello predefinito.

Un modello di applicazione in Reasoning Engine è definito come classe Python. Per fare un esempio, il seguente codice Python è un esempio di applicazione LangChain di cui è possibile eseguire il deployment su Vertex AI (puoi assegnare alla variabile 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, i tre metodi seguenti 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 gli attributi di sicurezza come argomenti di input degli utenti. Puoi utilizzare questo metodo anche per raccogliere parametri come l'ID progetto, la regione, le credenziali dell'applicazione e le chiavi API.
    • Il costruttore restituisce un oggetto che deve essere "riconoscibile" affinché sia possibile eseguire il deployment nel motore di ragionamento. Di conseguenza, devi inizializzare i client di servizio e stabilire le connessioni ai database nel metodo .set_up anziché nel metodo __init__.
    • Questo metodo è facoltativo. Se non è specificato, Vertex AI usa il costruttore Python predefinito per la classe.
  2. set_up():
    • Devi utilizzare questo metodo per definire la logica di inizializzazione dell'applicazione. Ad esempio, utilizzi questo metodo per stabilire connessioni ai database o ai servizi dipendenti, importare pacchetti dipendenti o dati precalcolati da utilizzare per la gestione delle query.
    • Questo metodo è facoltativo. Se non è specificato, Vertex AI presuppone che l'applicazione non debba chiamare un metodo .set_up prima di gestire le query degli utenti.
  3. query():
    • Devi utilizzare questo metodo per definire la logica di runtime che gestisca le query degli utenti. Ad esempio, puoi utilizzare questo metodo per generare contenuti con i modelli di IA generativa o recuperare dati in tempo reale da API esterne.
    • Questo metodo è obbligatorio. Se non è specificato, il servizio ReasoningEngine restituisce un errore quando cerchi di creare un'istanza remota dell'applicazione.
    • Devi fornire a questo metodo una docstring chiara che ne definisca la funzione, documenti i relativi attributi e fornisca annotazioni di tipo per gli input. Evita argomenti variabili nel metodo query.

Testa l'applicazione in locale

Crea l'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