LanggraphAgent im Agent Platform SDK können Sie Agents erstellen, die komplexe Aufgaben ausführen und in externe Tools eingebunden werden können.
In diesem Dokument wird beschrieben, wie Sie einen LangGraph-Agenten entwickeln, einschließlich der Definition des Modells, der Ausstattung mit Tools zur Ausführung von Aktionen wie dem Abrufen von Wechselkursen und der Anpassung des Orchestrierungsablaufs.
Weitere Informationen zum Verwalten Ihrer bereitgestellten Agents finden Sie unter Bereitgestellte Agents verwalten.
Hinweis
Folgen Sie der Anleitung unter Umgebung einrichten, um Ihre Umgebung einzurichten.
Schritt 1: Modell definieren und konfigurieren
Geben Sie das gewünschte Modell an:
model = "gemini-2.0-flash"
Optional: Konfigurieren Sie die Sicherheitseinstellungen des Modells. Weitere Informationen zu den Optionen für Sicherheitseinstellungen in Gemini finden Sie unter Sicherheitsattribute konfigurieren. Das folgende Beispiel zeigt, wie Sie die Sicherheitseinstellungen konfigurieren können:
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 die 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 einen LanggraphAgent mit den Modellkonfigurationen:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model=model, # Required.
model_kwargs=model_kwargs, # Optional.
)
Wenn Sie in einer interaktiven Umgebung arbeiten (z.B. Terminal oder Colab-Notebook), 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 dem folgenden Beispiel ähnelt:
{
'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 Anpassung
Die LanggraphAgent-Vorlage 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.
Definieren Sie als Nächstes einen model_builder, der 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 ihn 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.
Definieren Sie als Nächstes einen model_builder, der 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 ihn schließlich in LanggraphAgent mit dem folgenden Code:
from vertexai import agent_engines
agent = agent_engines.LanggraphAgent(
model="google/gemini-2.0-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 umwandeln.
Wenn Sie Ihre Funktion definieren, ist es wichtig, Kommentare einzufügen, die die Parameter der Funktion, ihre Funktionsweise und die Rückgabe vollständig und klar beschreiben. Anhand dieser Informationen bestimmt das Modell, welche Funktion verwendet werden soll. Sie müssen Ihre Funktion auch lokal testen, um zu bestätigen, dass 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()
Wenn Sie die Funktion testen möchten, bevor Sie sie in Ihrem Agent verwenden, führen Sie Folgendes aus:
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 tools= Argument 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 durchführen. Führen Sie den folgenden Befehl aus, um den Agent 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 dem folgenden ähnelt:
{"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 auch 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 das Tool als Nächstes 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 dem folgenden ähnelt:
{"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, das das Tool definiert.
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 das Tool schließlich 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)
Es sollte eine Antwort wie diese zurückgegeben werden:
{"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 das Tool als Nächstes 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)
Es sollte eine Antwort wie diese zurückgegeben werden:
{"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 Agent auf die Code Interpreter-Erweiterung zugreifen kann, müssen Sie dem Dienstkonto des AI Platform Reasoning Engine Service Agent die Rolle „Agent Platform User“ (roles/aiplatform.user) hinzufügen. Weitere Informationen finden Sie unter Zugriff
verwalten.
Sie können alle (oder eine Teilmenge) der von Ihnen in
LanggraphAgent erstellten Tools verwenden:
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 Einschränkungen für die Toolnutzung festlegen. 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-2.0-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 einer Datenbank hinzufügen möchten, definieren Sie eine Funktion checkpointer_builder und übergeben Sie sie beim Erstellen des Agent.
Datenbank einrichten
Installieren Sie zuerst das entsprechende Paket und richten Sie damit eine Datenbank Ihrer Wahl ein (z.B. AlloyDB for PostgreSQL oder Cloud SQL for PostgreSQL):
Definieren Sie als Nächstes eine Funktion checkpointer_builder so:
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 Agent 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
)
Wenn Sie den Agent abfragen, geben Sie eine thread_id an, damit sich der Agent an frühere Fragen und Antworten „erinnert“:
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 bei nachfolgenden Abfragen die Sitzung gespeichert bleibt:
response = agent.query(
input={"messages": [("user", "How much is 100 USD?")]},
config={"configurable": {"thread_id": "THREAD_ID"}},
)
print(response)
Schritt 4: Promptvorlage anpassen
Promptvorlagen helfen, 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-Promptvorlage ist sequenziell in Abschnitte unterteilt.
| Bereich | Beschreibung |
|---|---|
| Optional: Systemanweisung | Anweisungen für den Agent, die auf alle Abfragen angewendet werden. |
| Optional: Chatprotokoll | Nachrichten, die dem Chatprotokoll aus einer früheren Sitzung entsprechen. |
| Nutzereingabe | Die Abfrage des Nutzers, auf die der Agent antworten soll. |
| Agent-Scratchpad | Nachrichten, die vom Agent erstellt wurden (z.B. mit Funktionsaufrufen), während er seine Tools verwendet und Logik anwendet, um eine Antwort für den Nutzer zu formulieren. |
Die Standard-Promptvorlage wird generiert, wenn Sie den Agent erstellen, ohne eine eigene Promptvorlage 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}"),
])
Sie verwenden die vollständige Promptvorlage implizit, wenn Sie den Agent im folgenden Beispiel instanziieren:
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-Promptvorlage durch Ihre eigene Promptvorlage ersetzen und sie beim Erstellen des Agent 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 den LanggraphAgent class
muss ein ausführbares Programm erstellt werden, damit er auf Abfragen reagieren kann. Standardmäßig erstellt
LanggraphAgent ein solches ausführbares Programm mit der vorgefertigten ReAct
Agent-Implementierung von LangGraph.
Sie können die Orchestrierung anpassen, wenn Sie (i) einen Agent implementieren möchten, der eine deterministische Reihe von Schritten ausführt (anstatt eine offene Logik anzuwenden), oder (ii) den Agent auf ReAct-ähnliche Weise auffordern möchten, jeden Schritt mit Überlegungen 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 Argument runnable_builder= 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 Promptkonfiguration (siehe Promptvorlage anpassen).runnable_kwargssind die Schlüsselwortargumente, mit denen Sie das zu erstellende ausführbare Programm anpassen können.
So haben Sie verschiedene Möglichkeiten, die Orchestrierungslogik anzupassen.
ChatModel
Im einfachsten Fall können Sie zum Erstellen eines Agent ohne Orchestrierung
runnable_builder für LanggraphAgent überschreiben, um das 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 von
Ihrer eigenen prompt überschreiben möchten (siehe Promptvorlage anpassen),
müssen Sie die runnable_builder für 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
Wenn Sie das folgende Diagramm mit der LangChain Expression Language (LCEL) erstellen möchten,
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
Wenn Sie das folgende Diagramm mit LangGraph erstellen möchten,
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
Agents bereitstellen
Hier erfahren Sie mehr über die fünf Möglichkeiten, einen Agent in Agent Platform Runtime bereitzustellen, je nach Ihren Entwicklungsanforderungen.
Agents bewerten
Erstellen und stellen Sie einen einfachen Agent bereit und verwenden Sie den Gen AI Evaluation Service, um den Agent zu bewerten.
Fehlerbehebung bei der Agent-Erstellung
Hier erfahren Sie, wie Sie häufige Fehler beim Erstellen benutzerdefinierter Agents beheben.