Personalizar um modelo de aplicativo

Em Desenvolver o aplicativo, usamos um modelo pré-criado (por exemplo, reasoning_engines.LangchainAgent) para desenvolver um aplicativo. Nesta seção, você verá as etapas para personalizar seu próprio modelo de aplicativo. Isso poderá ser útil se você precisar ir além do que o modelo pré-criado oferece.

Um modelo de aplicativo no Reasoning Engine é definido como uma classe Python. Para dar um exemplo, o código Python a seguir é um exemplo de um aplicativo LangChain que pode ser implantado na Vertex AI (é possível atribuir um valor como MyAgent à variável CLASS_NAME):

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})

Ao escrever a classe Python, os três métodos a seguir são importantes para o Reasoning Engine:

  1. __init__():
    • Use esse método apenas para parâmetros de configuração do aplicativo. Por exemplo, é possível usar esse método para coletar os parâmetros do modelo e os atributos de segurança como argumentos de entrada dos usuários. Também é possível usar esse método para coletar parâmetros como o ID do projeto, a região, as credenciais de aplicativo e as chaves de API.
    • O construtor retorna um objeto que precisa ser "serializável" para que possa ser implantado no Reasoning Engine. Portanto, inicialize clientes de serviço e estabeleça conexões com bancos de dados no método .set_up no lugar do método __init__.
    • Esse método é opcional. Se não for especificado, a Vertex AI usará o construtor padrão do Python para a classe.
  2. set_up():
    • Use esse método para definir a lógica de inicialização do aplicativo. Por exemplo, esse método é usado para estabelecer conexões com bancos de dados ou serviços dependentes, importar pacotes dependentes ou pré-computar dados usados para atender a consultas.
    • Esse método é opcional. Se não for especificado, a Vertex AI vai presumir que o aplicativo não precisa chamar um método .set_up antes de atender às consultas do usuário.
  3. query():
    • Use esse método para definir a lógica do ambiente de execução que exibe as consultas do usuário. Por exemplo, é possível usar esse método para gerar conteúdo com modelos de IA generativa ou recuperar dados em tempo real de APIs externas.
    • Esse método é obrigatório. Se não for especificado, o serviço ReasoningEngine retornará um erro quando você tentar criar uma instância remota do aplicativo.
    • Forneça a esse método uma docstring clara que defina o que ele faz, documente os atributos e forneça anotações de tipo para as entradas. Evite argumentos variáveis no método query.

Testar o aplicativo localmente

Instancie o aplicativo na memória local usando o seguinte código:

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

Teste o aplicativo enviando consultas de teste para a instância local:

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

A resposta é um dicionário semelhante a este:

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

A seguir