Personnaliser un modèle d'application

Dans la section Développer l'application, nous avons utilisé un modèle prédéfini (reasoning_engines.LangchainAgent) pour développer une application. Dans cette section, nous passons en revue les étapes permettant de personnaliser votre propre modèle d'application. Cela peut être utile si vous avez des besoins autres que ceux fournis par le modèle prédéfini.

Dans Reasoning Engine, un modèle d'application est défini comme une classe Python. Pour vous donner un exemple, le code Python suivant est un exemple d'application LangChain déployable sur Vertex AI (vous pouvez attribuer à la variable CLASS_NAME une valeur telle que 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})

Lors de l'écriture de votre classe Python, les trois méthodes suivantes sont importantes pour le moteur de raisonnement:

1. __init__() :
   • N'utilisez cette méthode que pour les paramètres de configuration de l'application. Par exemple, vous pouvez utiliser cette méthode pour collecter les paramètres du modèle et les attributs de sécurité en tant qu'arguments d'entrée de vos utilisateurs. Vous pouvez également utiliser cette méthode pour collecter des paramètres tels que l'ID de projet, la région, les identifiants d'application et les clés API.
   • Le constructeur renvoie un objet qui doit pouvoir être "picklé" pour qu'il puisse être déployé sur le moteur de raisonnement. Par conséquent, vous devez initialiser les clients de service et établir des connexions aux bases de données dans la méthode .set_up plutôt que dans la méthode __init__.
   • Cette méthode est facultative. Si elle n'est pas spécifiée, Vertex AI utilise le constructeur Python par défaut de la classe.
2. set_up() :
   • Vous devez utiliser cette méthode pour définir la logique d'initialisation de l'application. Par exemple, cette méthode vous permet d'établir des connexions à des bases de données ou de services dépendants, d'importer des packages dépendants ou de précalculer des données utilisées pour diffuser des requêtes.
   • Cette méthode est facultative. Si elle n'est pas spécifiée, Vertex AI suppose que l'application n'a pas besoin d'appeler une méthode .set_up avant de diffuser les requêtes utilisateur.
3. query() :
   • Vous devez utiliser cette méthode pour définir une logique d'exécution qui diffuse les requêtes utilisateur. Par exemple, vous utilisez cette méthode pour générer du contenu avec des modèles d'IA générative ou pour récupérer des données en temps réel à partir d'API externes.
   • Cette méthode est obligatoire. Si elle n'est pas spécifiée, le service ReasoningEngine renvoie une erreur lorsque vous essayez de créer une instance distante de l'application.
   • Vous devez fournir à cette méthode un docstring clair qui définit ce qu'elle fait, documente ses attributs et fournit des annotations de type pour ses entrées. Évitez les arguments de variables dans la méthode query.

Tester l'application en local

Instanciez l'application dans la mémoire locale à l'aide du code suivant :

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

Vous pouvez tester l'application en envoyant des requêtes de test à l'instance locale :

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

La réponse est un dictionnaire semblable à celui-ci:

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

Étapes suivantes

• Déployez l'application.