Personaliza una plantilla de aplicación

En Desarrolla la aplicación, usamos una plantilla compilada previamente (es decir, reasoning_engines.LangchainAgent) para desarrollar una aplicación. En esta sección, explicaremos los pasos para personalizar tu propia plantilla de aplicación. Esto puede ser útil si tienes necesidades que van más allá de lo que proporciona la plantilla compilada previamente.

Una plantilla de aplicación en Reasoning Engine se define como una clase de Python. Para dar un ejemplo, el siguiente código de Python es un ejemplo de una aplicación LangChain que se puede implementar en Vertex AI (puedes asignar a la variable CLASS_NAME un valor como 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})

Cuando escribes tu clase de Python, los siguientes tres métodos son importantes para el motor de razonamiento:

1. __init__():
   • Usa este método solo para los parámetros de configuración de la aplicación. Por ejemplo, puedes usar este método para recopilar los parámetros del modelo y los atributos de seguridad como argumentos de entrada de tus usuarios. También puedes usar este método para recopilar parámetros, como el ID del proyecto, la región, las credenciales de la aplicación y las claves de API.
   • El constructor muestra un objeto que debe ser "pickle" para que se pueda implementar en el motor de razonamiento. Por lo tanto, debes inicializar los clientes de servicio y establecer conexiones con las bases de datos en el método .set_up, en lugar de hacerlo en el método __init__.
   • Este método es opcional. Si no se especifica, Vertex AI usa el constructor de Python predeterminado para la clase.
2. set_up():
   • Debes usar este método para definir la lógica de inicialización de la aplicación. Por ejemplo, usa este método para establecer conexiones con bases de datos o servicios dependientes, importar paquetes dependientes o datos de procesamiento previo que se usan para entregar consultas.
   • Este método es opcional. Si no se especifica, Vertex AI supone que la aplicación no necesita llamar a un método .set_up antes de entregar consultas de los usuarios.
3. query():
   • Debes usar este método para definir la lógica del entorno de ejecución que entrega las consultas de los usuarios. Por ejemplo, puedes usar este método para generar contenido con modelos de IA generativa o recuperar datos en tiempo real de APIs externas.
   • Este método es obligatorio. Si no se especifica, el servicio ReasoningEngine muestra un error cuando intentas crear una instancia remota de la aplicación.
   • Debes proporcionar a este método una docstring clara que defina lo que hace, documenta sus atributos y proporciona anotaciones de tipo para sus entradas. Evita los argumentos variables en el método query.

Prueba la aplicación de forma local

Crea una instancia de la aplicación en la memoria local con el siguiente código:

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

Puedes probar la aplicación si envías consultas de prueba a la instancia local:

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

La respuesta es un diccionario similar al siguiente:

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

¿Qué sigue?

• Implementa la aplicación