Anwendungsvorlage anpassen

In Anwendung entwickeln haben wir für die Entwicklung einer Anwendung eine vordefinierte Vorlage (z.B. reasoning_engines.LangchainAgent) verwendet. In diesem Abschnitt wird die Anpassung Ihrer eigenen Anwendungsvorlage beschrieben. Dies kann nützlich sein, wenn Sie Anforderungen haben, die über das hinausgehen, was die vordefinierte Vorlage bietet.

Eine Anwendungsvorlage in Reasoning Engine ist als Python-Klasse definiert. Der folgende Python-Code ist beispielsweise ein Beispiel für eine LangChain-Anwendung, die in Vertex AI bereitgestellt werden kann. Sie können der Variable CLASS_NAME einen Wert wie MyAgent geben. :

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 für die Anwendungskonfiguration. Sie können mit dieser Methode beispielsweise die Modellparameter und Sicherheitsattribute als Eingabeargumente von Ihren Nutzern erfassen. Sie können diese Methode auch verwenden, um Parameter wie die Projekt-ID, die Region, Anmeldedaten für Anwendungen und 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 statt in der Methode __init__ herstellen.
    • Diese Methode ist optional. Wenn er nicht angegeben ist, verwendet Vertex AI den standardmäßigen Python-Konstruktor für die Klasse.
  2. set_up():
    • Sie müssen diese Methode verwenden, um die Logik für die Anwendungsinitialisierung zu definieren. Beispielsweise können Sie mit dieser Methode Verbindungen zu Datenbanken oder abhängigen Diensten herstellen, abhängige Pakete importieren oder Daten vorausberechnen, die zur Bereitstellung von Abfragen verwendet werden.
    • Diese Methode ist optional. Ist er nicht angegeben, 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 definiert, was die Methode tut, ihre Attribute dokumentiert und Typannotationen für die Eingaben bereitstellt. Vermeiden Sie Variablenargumente in der Methode query.

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