Anwendungsvorlage anpassen

Unter Anwendung entwickeln haben wir eine vordefinierte Vorlage (reasoning_engines.LangchainAgent) zum Entwickeln einer Anwendung verwendet. In diesem Abschnitt werden die Schritte beschrieben, mit denen Sie Ihre eigene Anwendungsvorlage anpassen können. Dies kann hilfreich sein, wenn Sie Anforderungen haben, die über die vordefinierten Vorlagen hinausgehen.

Eine Anwendungsvorlage in der Reasoning Engine wird als Python-Klasse definiert. Der folgende Python-Code ist beispielsweise eine LangChain-Anwendung, die auf Vertex AI bereitgestellt werden kann (Sie können der Variable CLASS_NAME einen Wert wie MyAgent zuweisen):

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

Beim Schreiben Ihrer Python-Klasse sind die folgenden drei Methoden für die Reasoning-Engine wichtig:

1. __init__():
   • Verwenden Sie diese Methode nur für Parameter der Anwendungskonfiguration. Sie können diese Methode beispielsweise verwenden, um die Modellparameter und Sicherheitsattribute als Eingabeargumente von Ihren Nutzern zu erfassen. Sie können diese Methode auch verwenden, um Parameter wie die Projekt-ID, die Region, die Anmeldedaten für die Anwendung und die API-Schlüssel zu erfassen.
   • Der Konstruktor gibt ein Objekt zurück, das "pickle-fähig" sein muss, damit es für die Reasoning-Engine bereitgestellt werden kann. Daher sollten Sie Dienstclients initialisieren und Verbindungen zu Datenbanken in der Methode .set_up und nicht in der Methode __init__ herstellen.
   • Diese Methode ist optional. Wenn er nicht angegeben ist, verwendet Vertex AI den Standard-Python-Konstruktor für die Klasse.
2. set_up():
   • Sie müssen diese Methode verwenden, um die Logik für die Anwendungsinitialisierung zu definieren. Sie können mit dieser Methode beispielsweise Verbindungen zu Datenbanken oder abhängigen Diensten herstellen, abhängige Pakete importieren oder Daten vorausberechnen, die zur Verarbeitung von Abfragen verwendet werden.
   • Diese Methode ist optional. Wenn sie nicht angegeben ist, geht Vertex AI davon aus, dass die Anwendung keine .set_up-Methode aufrufen muss, bevor Nutzerabfragen bereitgestellt werden.
3. query():
   • Sie müssen diese Methode verwenden, um eine Laufzeitlogik zu definieren, die Nutzerabfragen verarbeitet. Sie können diese Methode beispielsweise verwenden, um Inhalte mit generativen KI-Modellen zu generieren oder Echtzeitdaten von externen APIs abzurufen.
   • Diese Methode ist erforderlich. Wenn sie nicht angegeben ist, gibt der ReasoningEngine-Dienst einen Fehler zurück, wenn Sie versuchen, eine Remoteinstanz der Anwendung zu erstellen.
   • Sie sollten dieser Methode einen eindeutigen Docstring zuweisen, der ihre Funktion definiert, ihre Attribute dokumentiert und Typenannotationen für ihre Eingaben bereitstellt. Vermeiden Sie Variablenargumente in der query-Methode.

Anwendung lokal testen

Instanziieren Sie die Anwendung im lokalen Speicher mit dem folgenden Code:

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

Sie können die Anwendung testen, indem Sie Testabfragen an die lokale Instanz senden:

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

Die Antwort ist ein Wörterbuch, das in etwa so aussieht:

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

Nächste Schritte

• Stellen Sie die Anwendung bereit.