LanggraphAgent im Agent Platform SDK können Sie Agenten erstellen, die komplexe Aufgaben ausführen und sich in externe Tools einbinden lassen.
In diesem Dokument wird beschrieben, wie Sie einen LangGraph-Agenten entwickeln. Dazu gehören das Definieren des Modells, das Ausstatten mit Tools zum Ausführen von Aktionen wie dem Abrufen von Wechselkursen und das Anpassen des Orchestrierungsablaufs.
Weitere Informationen zum Verwalten Ihrer bereitgestellten KI-Agenten finden Sie unter Bereitgestellte KI-Agenten verwalten.
Hinweis
Richten Sie Ihre Umgebung ein, indem Sie die Schritte unter Umgebung einrichten ausführen.
Schritt 1: Modell definieren und konfigurieren
Geben Sie das gewünschte Modell an:
model = "gemini-3.5-flash"
Optional: Konfigurieren Sie die Sicherheitseinstellungen des Modells. Weitere Informationen zu den verfügbaren Optionen für Sicherheitseinstellungen in Gemini finden Sie unter Sicherheitsattribute konfigurieren. Hier ein Beispiel für die Konfiguration der Sicherheitseinstellungen:
from langchain_google_vertexai import HarmBlockThreshold, HarmCategory
safety_settings = {
HarmCategory.HARM_CATEGORY_UNSPECIFIED: HarmBlockThreshold.BLOCK_NONE,
HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
}
Optional: Geben Sie Modellparameter so an:
model_kwargs = {
# temperature (float): The sampling temperature controls the degree of
# randomness in token selection.
"temperature": 0.28,
# max_output_tokens (int): The token limit determines the maximum amount of
# text output from one prompt.
"max_output_tokens": 1000,
# top_p (float): Tokens are selected from most probable to least until
# the sum of their probabilities equals the top-p value.
"top_p": 0.95,
# top_k (int): The next token is selected from among the top-k most
# probable tokens. This is not supported by all model versions. See
# https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/image-understanding#valid_parameter_values
# for details.
"top_k": None,
# safety_settings (Dict[HarmCategory, HarmBlockThreshold]): The safety
# settings to use for generating content.
# (you must create your safety settings using the previous step first).
"safety_settings": safety_settings,
}
Erstellen Sie mithilfe der Modellkonfigurationen einen LanggraphAgent:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model, # Required.
model_kwargs=model_kwargs, # Optional.
)
Wenn Sie in einer interaktiven Umgebung (z.B. Terminal oder Colab-Notebook) arbeiten, können Sie eine Abfrage als Zwischenschritt zum Testen ausführen:
response = agent.query(input={"messages": [
("user", "What is the exchange rate from US dollars to SEK today?"),
]})
print(response)
Die Antwort ist ein Python-Wörterbuch, das in etwa so aussieht:
{
'messages': [{
'id': ['langchain', 'schema', 'messages', 'HumanMessage'],
'kwargs': {
'content': 'What is the exchange rate from US dollars to Swedish currency?',
'id': '5473dd25-d796-42ad-a690-45bc49a64bec',
'type': 'human',
},
'lc': 1,
'type': 'constructor',
}, {
'id': ['langchain', 'schema', 'messages', 'AIMessage'],
'kwargs': {
'content': """
I do not have access to real-time information, including currency exchange rates.
To get the most up-to-date exchange rate from US dollars to Swedish currency (SEK),
I recommend checking a reliable online currency converter like: ...
These websites will provide you with the current exchange rate and allow you to
convert specific amounts.""",
'id': 'run-c42f9940-8ba8-42f1-a625-3aa0780c9e87-0',
...
'usage_metadata': {
'input_tokens': 12,
'output_tokens': 145,
'total_tokens': 157,
},
},
'lc': 1,
'type': 'constructor',
}],
}
Optional: Erweiterte Anpassungen
Die Vorlage LanggraphAgent verwendet standardmäßig ChatVertexAI, da sie Zugriff auf alle in Google Cloudverfügbaren Foundation Models bietet. Wenn Sie ein Modell verwenden möchten, das nicht über ChatVertexAI verfügbar ist, können Sie das Argument model_builder= mit einer Python-Funktion der folgenden Signatur angeben:
from typing import Optional
def model_builder(
*,
model_name: str, # Required. The name of the model
model_kwargs: Optional[dict] = None, # Optional. The model keyword arguments.
**kwargs, # Optional. The remaining keyword arguments to be ignored.
):
Eine Liste der in LangChain unterstützten Chatmodelle und ihrer Funktionen finden Sie unter Chatmodelle.
Die unterstützten Werte für model= und model_kwargs= sind für jedes Chatmodell spezifisch. Weitere Informationen finden Sie in der entsprechenden Dokumentation.
ChatVertexAI
Standardmäßig installiert.
Wird in LanggraphAgent verwendet, wenn Sie das model_builder-Argument weglassen, z. B.
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model, # Required.
model_kwargs=model_kwargs, # Optional.
)
ChatAnthropic
Folgen Sie zuerst der Dokumentation, um ein Konto einzurichten und das Paket zu installieren.
Als Nächstes definieren Sie einen model_builder, die ChatAnthropic zurückgibt:
def model_builder(*, model_name: str, model_kwargs = None, **kwargs):
from langchain_anthropic import ChatAnthropic
return ChatAnthropic(model_name=model_name, **model_kwargs)
Verwenden Sie sie schließlich in LanggraphAgent mit dem folgenden Code:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model="claude-3-opus-20240229", # Required.
model_builder=model_builder, # Required.
model_kwargs={
"api_key": "ANTHROPIC_API_KEY", # Required.
"temperature": 0.28, # Optional.
"max_tokens": 1000, # Optional.
},
)
ChatOpenAI
Sie können ChatOpenAI in Verbindung mit der ChatCompletions API von Gemini verwenden.
Folgen Sie zuerst der Dokumentation, um das Paket zu installieren.
Als Nächstes definieren Sie einen model_builder, die ChatOpenAI zurückgibt:
def model_builder(
*,
model_name: str,
model_kwargs = None,
project: str, # Specified via vertexai.init
location: str, # Specified via vertexai.init
**kwargs,
):
import google.auth
from langchain_openai import ChatOpenAI
# Note: the credential lives for 1 hour by default.
# After expiration, it must be refreshed.
creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_req = google.auth.transport.requests.Request()
creds.refresh(auth_req)
if model_kwargs is None:
model_kwargs = {}
endpoint = f"https://{location}-aiplatform.googleapis.com"
base_url = f'{endpoint}/v1beta1/projects/{project}/locations/{location}/endpoints/openapi'
return ChatOpenAI(
model=model_name,
base_url=base_url,
api_key=creds.token,
**model_kwargs,
)
Verwenden Sie sie schließlich in LanggraphAgent mit dem folgenden Code:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model="google/gemini-3.5-flash", # Or "meta/llama3-405b-instruct-maas"
model_builder=model_builder, # Required.
model_kwargs={
"temperature": 0, # Optional.
"max_retries": 2, # Optional.
},
)
Schritt 2: Tool definieren und verwenden
Nachdem Sie Ihr Modell definiert haben, definieren Sie im nächsten Schritt die Tools, die Ihr Modell für Logik verwendet. Ein Tool kann ein LangChain-Tool oder eine Python-Funktion sein. Sie können auch eine definierte Python-Funktion in ein LangChain-Tool konvertieren.
Wenn Sie Ihre Funktion definieren, ist es wichtig, Kommentare einzufügen, die die Parameter der Funktion, die Funktionsweise und die Rückgabewerte der Funktion vollständig und klar beschreiben. Diese Informationen werden vom Modell verwendet, um zu bestimmen, welche Funktion verwendet werden soll. Sie müssen Ihre Funktion auch lokal testen, um zu prüfen, ob sie funktioniert.
Verwenden Sie den folgenden Code, um eine Funktion zu definieren, die einen Wechselkurs zurückgibt:
def get_exchange_rate(
currency_from: str = "USD",
currency_to: str = "EUR",
currency_date: str = "latest",
):
"""Retrieves the exchange rate between two currencies on a specified date.
Uses the Frankfurter API (https://api.frankfurter.app/) to obtain
exchange rate data.
Args:
currency_from: The base currency (3-letter currency code).
Defaults to "USD" (US Dollar).
currency_to: The target currency (3-letter currency code).
Defaults to "EUR" (Euro).
currency_date: The date for which to retrieve the exchange rate.
Defaults to "latest" for the most recent exchange rate data.
Can be specified in YYYY-MM-DD format for historical rates.
Returns:
dict: A dictionary containing the exchange rate information.
Example: {"amount": 1.0, "base": "USD", "date": "2023-11-24",
"rates": {"EUR": 0.95534}}
"""
import requests
response = requests.get(
f"https://api.frankfurter.app/{currency_date}",
params={"from": currency_from, "to": currency_to},
)
return response.json()
Führen Sie den folgenden Befehl aus, um die Funktion zu testen, bevor Sie sie in Ihrem Agenten verwenden:
get_exchange_rate(currency_from="USD", currency_to="SEK")
Die Antwort sollte in etwa so aussehen:
{'amount': 1.0, 'base': 'USD', 'date': '2024-02-22', 'rates': {'SEK': 10.3043}}
Wenn Sie das Tool in LanggraphAgent verwenden möchten, fügen Sie es der Liste der Tools unter dem Argument tools= hinzu:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model, # Required.
tools=[get_exchange_rate], # Optional.
model_kwargs=model_kwargs, # Optional.
)
Sie können den Agent lokal testen, indem Sie Testabfragen an ihn senden. Führen Sie den folgenden Befehl aus, um den KI-Agenten lokal mit US-Dollar und schwedischen Kronen zu testen:
response = agent.query(input={"messages": [
("user", "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."}
Optional: Mehrere Tools
Tools für LanggraphAgent können auf andere Weise definiert und instanziiert werden.
Fundierungs-Tool
Importieren Sie zuerst das Paket generate_models und erstellen Sie das Tool.
from vertexai.generative_models import grounding, Tool
grounded_search_tool = Tool.from_google_search_retrieval(
grounding.GoogleSearchRetrieval()
)
Verwenden Sie dann das Tool in LanggraphAgent:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model,
tools=[grounded_search_tool],
)
response = agent.query(input={"messages": [
("user", "When is the next total solar eclipse in US?"),
]})
print(response)
Die Antwort ist ein Wörterbuch, das in etwa so aussieht:
{"input": "When is the next total solar eclipse in US?",
"output": """The next total solar eclipse in the U.S. will be on August 23, 2044.
This eclipse will be visible from three states: Montana, North Dakota, and
South Dakota. The path of totality will begin in Greenland, travel through
Canada, and end around sunset in the United States."""}
Weitere Informationen finden Sie unter Fundierung.
LangChain-Tool
Installieren Sie zuerst das Paket, in dem das Tool definiert ist.
pip install langchain-google-communityImportieren Sie als Nächstes das Paket und erstellen Sie das Tool.
from langchain_google_community import VertexAISearchRetriever
from langchain.tools.retriever import create_retriever_tool
retriever = VertexAISearchRetriever(
project_id="PROJECT_ID",
data_store_id="DATA_STORE_ID",
location_id="DATA_STORE_LOCATION_ID",
engine_data_type=1,
max_documents=10,
)
movie_search_tool = create_retriever_tool(
retriever=retriever,
name="search_movies",
description="Searches information about movies.",
)
Verwenden Sie schließlich das Tool in LanggraphAgent:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model,
tools=[movie_search_tool],
)
response = agent.query(input={"messages": [
("user", "List some sci-fi movies from the 1990s"),
]})
print(response)
Sie sollten eine Antwort wie die folgende erhalten:
{"input": "List some sci-fi movies from the 1990s",
"output": """Here are some sci-fi movies from the 1990s:
* The Matrix (1999): A computer hacker learns from mysterious rebels about the true nature of his reality and his role in the war against its controllers.
* Star Wars: Episode I - The Phantom Menace (1999): Two Jedi Knights escape a hostile blockade to find a queen and her protector, and come across a young boy [...]
* Men in Black (1997): A police officer joins a secret organization that monitors extraterrestrial interactions on Earth.
[...]
"""}
Das vollständige Beispiel finden Sie im Notebook.
Weitere Beispiele für in LangChain verfügbare Tools finden Sie unter Google-Tools.
Agent Platform-Erweiterung
Importieren Sie zuerst das Erweiterungspaket und erstellen Sie das Tool.
from typing import Optional
def generate_and_execute_code(
query: str,
files: Optional[list[str]] = None,
file_gcs_uris: Optional[list[str]] = None,
) -> str:
"""Get the results of a natural language query by generating and executing
a code snippet.
Example queries: "Find the max in [1, 2, 5]" or "Plot average sales by
year (from data.csv)". Only one of `file_gcs_uris` and `files` field
should be provided.
Args:
query:
The natural language query to generate and execute.
file_gcs_uris:
Optional. URIs of input files to use when executing the code
snippet. For example, ["gs://input-bucket/data.csv"].
files:
Optional. Input files to use when executing the generated code.
If specified, the file contents are expected be base64-encoded.
For example: [{"name": "data.csv", "contents": "aXRlbTEsaXRlbTI="}].
Returns:
The results of the query.
"""
operation_params = {"query": query}
if files:
operation_params["files"] = files
if file_gcs_uris:
operation_params["file_gcs_uris"] = file_gcs_uris
from vertexai.preview import extensions
# If you have an existing extension instance, you can get it here
# i.e. code_interpreter = extensions.Extension(resource_name).
code_interpreter = extensions.Extension.from_hub("code_interpreter")
return extensions.Extension.from_hub("code_interpreter").execute(
operation_id="generate_and_execute",
operation_params=operation_params,
)
Verwenden Sie dann das Tool in LanggraphAgent:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model,
tools=[generate_and_execute_code],
)
response = agent.query(input={"messages": [("user", """
Using the data below, construct a bar chart that includes only the height values with different colors for the bars:
tree_heights_prices = {
\"Pine\": {\"height\": 100, \"price\": 100},
\"Oak\": {\"height\": 65, \"price\": 135},
\"Birch\": {\"height\": 45, \"price\": 80},
\"Redwood\": {\"height\": 200, \"price\": 200},
\"Fir\": {\"height\": 180, \"price\": 162},
}
""")]})
print(response)
Sie sollten eine Antwort wie die folgende erhalten:
{"input": """Using the data below, construct a bar chart that includes only the height values with different colors for the bars:
tree_heights_prices = {
\"Pine\": {\"height\": 100, \"price\": 100},
\"Oak\": {\"height\": 65, \"price\": 135},
\"Birch\": {\"height\": 45, \"price\": 80},
\"Redwood\": {\"height\": 200, \"price\": 200},
\"Fir\": {\"height\": 180, \"price\": 162},
}
""",
"output": """Here's the generated bar chart:
```python
import matplotlib.pyplot as plt
tree_heights_prices = {
"Pine": {"height": 100, "price": 100},
"Oak": {"height": 65, "price": 135},
"Birch": {"height": 45, "price": 80},
"Redwood": {"height": 200, "price": 200},
"Fir": {"height": 180, "price": 162},
}
heights = [tree["height"] for tree in tree_heights_prices.values()]
names = list(tree_heights_prices.keys())
plt.bar(names, heights, color=['red', 'green', 'blue', 'purple', 'orange'])
plt.xlabel('Tree Species')
plt.ylabel('Height')
plt.title('Tree Heights')
plt.show()
```
"""}
Damit Ihr bereitgestellter KI-Agent auf die Code Interpreter-Erweiterung zugreifen kann, müssen Sie dem Dienstkonto des AI Platform Reasoning Engine-Dienst-Agents die Rolle „Agent Platform User“ (roles/aiplatform.user) hinzufügen. Weitere Informationen finden Sie unter Zugriff verwalten.
Sie können alle oder einen Teil der Tools verwenden, die Sie in LanggraphAgent erstellt haben:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model,
tools=[
get_exchange_rate, # Optional (Python function)
grounded_search_tool, # Optional (Grounding Tool)
movie_search_tool, # Optional (Langchain Tool)
generate_and_execute_code, # Optional (Vertex Extension)
],
)
response = agent.query(input={"messages": [
("user", "List some sci-fi movies from the 1990s"),
]})
print(response)
Optional: Toolkonfiguration
Mit Gemini können Sie die Nutzung von Tools einschränken. Anstatt dem Modell beispielsweise zu erlauben, Antworten in natürlicher Sprache zu generieren, können Sie erzwingen, dass nur Funktionsaufrufe generiert werden („erzwungener Funktionsaufruf“).
from vertexai import agent_engines
from vertexai.preview.generative_models import ToolConfig
agent = agent_engines.LanggraphAgent(
model="gemini-3.5-flash",
tools=[search_arxiv, get_exchange_rate],
model_tool_kwargs={
"tool_config": { # Specify the tool configuration here.
"function_calling_config": {
"mode": ToolConfig.FunctionCallingConfig.Mode.ANY,
"allowed_function_names": ["search_arxiv", "get_exchange_rate"],
},
},
},
)
response = agent.query(input={"messages": [
("user", "Explain the Schrodinger equation in a few sentences"),
]})
print(response)
Weitere Informationen finden Sie unter Toolkonfiguration.
Schritt 3: Prüfpunkte speichern
Wenn Sie Chatnachrichten verfolgen und an eine Datenbank anhängen möchten, definieren Sie eine checkpointer_builder-Funktion und übergeben Sie sie beim Erstellen des KI-Agenten.
Datenbank einrichten
Installieren und verwenden Sie zuerst das entsprechende Paket, um eine Datenbank Ihrer Wahl einzurichten (z.B. AlloyDB for PostgreSQL oder Cloud SQL for PostgreSQL):
Definieren Sie als Nächstes eine checkpointer_builder-Funktion:
Cloud SQL for PostgreSQL
checkpointer_kwargs = {
"project_id": "PROJECT_ID",
"region": "REGION",
"instance": "INSTANCE",
"database": "DATABASE",
}
def checkpointer_builder(**kwargs):
from langchain_google_cloud_sql_pg import (
PostgresEngine,
PostgresSaver,
)
engine = PostgresEngine.from_instance(**kwargs)
engine.init_checkpoint_table()
return PostgresSaver.create_sync(engine)
AlloyDB for PostgreSQL
checkpointer_kwargs = {
"project_id": "PROJECT_ID",
"region": "REGION",
"instance": "INSTANCE",
"database": "DATABASE",
"cluster": "CLUSTER",
}
def checkpointer_builder(**kwargs):
from langchain_google_alloydb_pg import (
AlloyDBEngine,
AlloyDBSaver,
)
from google.cloud.alloydb.connector import IPTypes
engine = AlloyDBEngine.from_instance(
ip_type=IPTypes.PUBLIC,
**kwargs,
)
engine.init_checkpoint_table()
return AlloyDBSaver.create_sync(engine)
Erstellen Sie schließlich den Agenten und übergeben Sie ihn als checkpointer_builder:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model,
checkpointer_kwargs=checkpointer_kwargs, # <- new
checkpointer_builder=checkpointer_builder, # <- new
)
Geben Sie beim Abfragen des KI-Agenten eine thread_id an, damit der KI-Agent sich an frühere Fragen und Antworten „erinnern“ kann:
response = agent.query(
input={"messages": [
("user", "What is the exchange rate from US dollars to Swedish currency?")
]},
config={"configurable": {"thread_id": "THREAD_ID"}},
)
print(response)
Sie können prüfen, ob sich die nachfolgenden Abfragen die Sitzung merken:
response = agent.query(
input={"messages": [("user", "How much is 100 USD?")]},
config={"configurable": {"thread_id": "THREAD_ID"}},
)
print(response)
Schritt 4: Prompt-Vorlage anpassen
Prompt-Vorlagen helfen dabei, Nutzereingaben in Anweisungen für ein Modell zu übersetzen. Sie werden verwendet, um die Antwort eines Modells zu steuern, damit es den Kontext versteht und relevante und kohärente sprachbasierte Ausgaben generiert. Weitere Informationen finden Sie unter ChatPromptTemplates.
Die Standard-Prompt-Vorlage ist sequenziell in Abschnitte unterteilt.
| Bereich | Beschreibung |
|---|---|
| Optional: Systemanweisung | Anweisungen für den Agenten, die für alle Abfragen gelten. |
| Optional: Chatprotokoll | Nachrichten, die dem Chatverlauf einer früheren Sitzung entsprechen. |
| Nutzereingabe | Die Anfrage des Nutzers, auf die der KI-Agent antworten soll. |
| Scratchpad für KI-Agenten | Nachrichten, die vom Agenten erstellt wurden (z.B. mit Funktionsaufrufen), während er seine Tools verwendet und Schlussfolgerungen zieht, um eine Antwort für den Nutzer zu formulieren. |
Die Standard-Prompt-Vorlage wird generiert, wenn Sie den Agenten erstellen, ohne eine eigene Prompt-Vorlage anzugeben. Sie sieht vollständig so aus:
from langchain_core.prompts import ChatPromptTemplate
from langchain.agents.format_scratchpad.tools import format_to_tool_messages
prompt_template = {
"user_input": lambda x: x["input"],
"history": lambda x: x["history"],
"agent_scratchpad": lambda x: format_to_tool_messages(x["intermediate_steps"]),
} | ChatPromptTemplate.from_messages([
("system", "{system_instruction}"),
("placeholder", "{history}"),
("user", "{user_input}"),
("placeholder", "{agent_scratchpad}"),
])
Wenn Sie den KI-Agenten im folgenden Beispiel instanziieren, verwenden Sie implizit die vollständige Prompt-Vorlage:
from vertexai import agent_engines
system_instruction = "I help look up the rate between currencies"
agent = agent_engines.LanggraphAgent(
model=model,
system_instruction=system_instruction,
checkpointer_kwargs=checkpointer_kwargs,
checkpointer_builder=checkpointer_builder,
tools=[get_exchange_rate],
)
Sie können die Standard-Prompt-Vorlage durch Ihre eigene Prompt-Vorlage überschreiben und diese beim Erstellen des KI-Agenten verwenden, z. B.:
from vertexai import agent_engines
custom_prompt_template = {
"user_input": lambda x: x["input"],
"history": lambda x: x["history"],
"agent_scratchpad": lambda x: format_to_tool_messages(x["intermediate_steps"]),
} | ChatPromptTemplate.from_messages([
("placeholder", "{history}"),
("user", "{user_input}"),
("placeholder", "{agent_scratchpad}"),
])
agent = agent_engines.LanggraphAgent(
model=model,
prompt=custom_prompt_template,
checkpointer_kwargs=checkpointer_kwargs,
checkpointer_builder=checkpointer_builder,
tools=[get_exchange_rate],
)
response = agent.query(
input={"messages": [
("user", "What is the exchange rate from US dollars to Swedish currency?"),
]},
config={"configurable": {"thread_id": "THREAD_ID"}},
)
print(response)
Schritt 5: Orchestrierung anpassen
Alle LangChain-Komponenten implementieren die Runnable-Schnittstelle, die Eingabe- und Ausgabeschemas für die Orchestrierung bereitstellt. Für die Klasse LanggraphAgent muss ein ausführbares Programm erstellt werden, damit sie auf Abfragen reagieren kann. Standardmäßig erstellt LanggraphAgent ein solches ausführbares Element mithilfe der vordefinierten React-Agent-Implementierung von LangGraph.
Sie können die Orchestrierung anpassen, wenn Sie (i) einen Agenten implementieren möchten, der eine deterministische Reihe von Schritten ausführt (anstatt offene Schlussfolgerungen zu ziehen), oder (ii) den Agenten im ReAct-Stil auffordern möchten, jeden Schritt mit Gedanken zu kommentieren, warum er diesen Schritt ausgeführt hat. Dazu müssen Sie beim Erstellen von LanggraphAgent das ausführbare Standardprogramm überschreiben, indem Sie das runnable_builder=-Argument mit einer Python-Funktion der folgenden Signatur angeben:
from typing import Optional
from langchain_core.language_models import BaseLanguageModel
def runnable_builder(
model: BaseLanguageModel,
*,
system_instruction: Optional[str] = None,
prompt: Optional["RunnableSerializable"] = None,
tools: Optional[Sequence["_ToolLike"]] = None,
checkpointer: Optional[Any] = None,
runnable_kwargs: Optional[Mapping[str, Any]] = None,
**kwargs,
):
Dabei gilt:
modelentspricht dem Chatmodell, das vonmodel_builderzurückgegeben wird (siehe Modell definieren und konfigurieren).toolsentspricht den zu verwendenden Tools und Konfigurationen (siehe Tool definieren und verwenden).checkpointerentspricht der Datenbank zum Speichern von Prüfpunkten (siehe Prüfpunkte speichern).system_instructionundpromptentsprechen der Prompt-Konfiguration (siehe Prompt-Vorlage anpassen).runnable_kwargssind die Keyword-Argumente, mit denen Sie das zu erstellende Runnable anpassen können.
So haben Sie verschiedene Möglichkeiten, die Orchestrierungslogik anzupassen.
ChatModel
Im einfachsten Fall können Sie einen Agenten ohne Orchestrierung erstellen, indem Sie die runnable_builder für LanggraphAgent überschreiben, um die model direkt zurückzugeben.
from vertexai import agent_engines
from langchain_core.language_models import BaseLanguageModel
def llm_builder(model: BaseLanguageModel, **kwargs):
return model
agent = agent_engines.LanggraphAgent(
model=model,
runnable_builder=llm_builder,
)
ReAct
Wenn Sie das standardmäßige Tool-Aufrufverhalten durch einen eigenen ReAct-Agenten auf der Grundlage Ihrer eigenen prompt überschreiben möchten (siehe Prompt-Vorlage anpassen), müssen Sie die runnable_builder durch LanggraphAgent überschreiben.
from typing import Sequence
from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import BasePromptTemplate
from langchain_core.tools import BaseTool
from langchain import hub
from vertexai import agent_engines
def react_builder(
model: BaseLanguageModel,
*,
tools: Sequence[BaseTool],
prompt: BasePromptTemplate,
agent_executor_kwargs = None,
**kwargs,
):
from langchain.agents.react.agent import create_react_agent
from langchain.agents import AgentExecutor
agent = create_react_agent(model, tools, prompt)
return AgentExecutor(agent=agent, tools=tools, **agent_executor_kwargs)
agent = agent_engines.LanggraphAgent(
model=model,
tools=[get_exchange_rate],
prompt=hub.pull("hwchase17/react"),
agent_executor_kwargs={"verbose": True}, # Optional. For illustration.
runnable_builder=react_builder,
)
LCEL-Syntax
So erstellen Sie den folgenden Graphen mit der LangChain Expression Language (LCEL):
Input
/ \
Pros Cons
\ /
Summary
müssen Sie runnable_builder für LanggraphAgent überschreiben:
from vertexai import agent_engines
def lcel_builder(*, model, **kwargs):
from operator import itemgetter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
output_parser = StrOutputParser()
planner = ChatPromptTemplate.from_template(
"Generate an argument about: {input}"
) | model | output_parser | {"argument": RunnablePassthrough()}
pros = ChatPromptTemplate.from_template(
"List the positive aspects of {argument}"
) | model | output_parser
cons = ChatPromptTemplate.from_template(
"List the negative aspects of {argument}"
) | model | output_parser
final_responder = ChatPromptTemplate.from_template(
"Argument:{argument}\nPros:\n{pros}\n\nCons:\n{cons}\n"
"Generate a final response given the critique",
) | model | output_parser
return planner | {
"pros": pros,
"cons": cons,
"argument": itemgetter("argument"),
} | final_responder
agent = agent_engines.LanggraphAgent(
model=model,
runnable_builder=lcel_builder,
)
LangGraph
So erstellen Sie den folgenden Graphen mit LangGraph:
Input
/ \
Pros Cons
\ /
Summary
müssen Sie runnable_builder für LanggraphAgent überschreiben:
from vertexai import agent_engines
def langgraph_builder(*, model, **kwargs):
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langgraph.graph import END, MessageGraph
output_parser = StrOutputParser()
planner = ChatPromptTemplate.from_template(
"Generate an argument about: {input}"
) | model | output_parser
pros = ChatPromptTemplate.from_template(
"List the positive aspects of {input}"
) | model | output_parser
cons = ChatPromptTemplate.from_template(
"List the negative aspects of {input}"
) | model | output_parser
summary = ChatPromptTemplate.from_template(
"Input:{input}\nGenerate a final response given the critique",
) | model | output_parser
builder = MessageGraph()
builder.add_node("planner", planner)
builder.add_node("pros", pros)
builder.add_node("cons", cons)
builder.add_node("summary", summary)
builder.add_edge("planner", "pros")
builder.add_edge("planner", "cons")
builder.add_edge("pros", "summary")
builder.add_edge("cons", "summary")
builder.add_edge("summary", END)
builder.set_entry_point("planner")
return builder.compile()
agent = agent_engines.LanggraphAgent(
model=model,
runnable_builder=langgraph_builder,
)
# Example query
response = agent.query(input={"role": "user", "content": "scrum methodology"})
print(response)
Nächste Schritte
KI-Agenten bereitstellen
Hier erfahren Sie, wie Sie einen Agenten auf der Agent Platform Runtime auf fünf verschiedene Arten bereitstellen können, je nach Ihren Entwicklungsanforderungen.
KI-Agenten bewerten
Einfachen Agenten erstellen und bereitstellen und mit dem Gen AI Evaluation Service bewerten
Fehlerbehebung bei der Agentenerstellung
Hier erfahren Sie, wie Sie häufige Fehler beim Erstellen benutzerdefinierter KI-Agenten beheben.