Auf dieser Seite erfahren Sie, wie Sie einen Agent mit der frameworkspezifischen LangChain-Vorlage (der Klasse LangchainAgent im Vertex AI SDK für Python) entwickeln. Der Agent gibt den Wechselkurs zwischen zwei Währungen an einem bestimmten Datum zurück. Gehen Sie wie folgt vor:
- Modell definieren und konfigurieren
- Tool definieren und verwenden
- Optional: Chatverlauf speichern
- Optional: Aufforderungsvorlage anpassen
- Optional: Orchestration anpassen
Hinweise
Richten Sie Ihre Umgebung ein, indem Sie die Schritte unter Umgebung einrichten ausführen.
Schritt 1: Modell definieren und konfigurieren
Geben Sie die zu verwendende Modellversion an.
model = "gemini-2.0-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. 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 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 mit den Modellkonfigurationen einen LangchainAgent:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
model=model, # Required.
model_kwargs=model_kwargs, # Optional.
)
Wenn Sie die Ausführung in einer interaktiven Umgebung (z.B. Terminal oder Colab-Notebook) vornehmen, können Sie eine Abfrage als Zwischenschritt zum Testen ausführen:
response = agent.query(input="What is the exchange rate from US dollars to SEK today?")
print(response)
Die Antwort ist ein Python-Dictionary, das dem folgenden Beispiel ähnelt:
{"input": "What is the exchange rate from US dollars to Swedish currency?",
"output": """I cannot provide the live exchange rate from US dollars to Swedish currency (Swedish krona, SEK).
**Here's why:**
* **Exchange rates constantly fluctuate.** Factors like global economics, interest rates, and political events cause
these changes throughout the day.
* **Providing inaccurate information would be misleading.**
**How to find the current exchange rate:**
1. **Use a reliable online converter:** Many websites specialize in live exchange rates. Some popular options include:
* Google Finance (google.com/finance)
* XE.com
* Bank websites (like Bank of America, Chase, etc.)
2. **Contact your bank or financial institution:** They can give you the exact exchange rate they are using.
Remember to factor in any fees or commissions when exchanging currency.
"""}
Erweiterte Anpassung (optional)
Für die Vorlage LangchainAgent wird standardmäßig ChatVertexAI verwendet, da sie Zugriff auf alle in Google Cloudverfügbaren Fundierungsmodelle bietet. Wenn Sie ein Modell verwenden möchten, das nicht über ChatVertexAI verfügbar ist, können Sie das model_builder=-Argument 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 Chat Models.
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 LangchainAgent verwendet, wenn Sie das model_builder-Argument weglassen, z. B.
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
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 ihn schließlich in LangchainAgent mit dem folgenden Code:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
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 ihn schließlich in LangchainAgent mit dem folgenden Code:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
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 konvertieren.
Wenn Sie Ihre Funktion definieren, ist es wichtig, Kommentare einzufügen, die die Parameter der Funktion, die Funktion selbst und die Rückgabe der Funktion 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()
So testen Sie die Funktion, bevor Sie sie in Ihrem Agent 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 LangchainAgent verwenden möchten, fügen Sie es der Liste der Tools unter dem Argument tools= hinzu:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
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 Agenten lokal mit US-Dollar und schwedischen Kronen zu testen:
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."}
(Optional) Mehrere Tools
Tools für LangchainAgent können auf andere Weise definiert und instanziiert werden.
Fundierungs-Tool
Importieren Sie zuerst das generate_models-Paket 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 dann in LangchainAgent:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
model=model,
tools=[grounded_search_tool],
)
agent.query(input="When is the next total solar eclipse in US?")
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-communityAls Nächstes importieren Sie das Paket und erstellen 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 LangchainAgent:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
model=model,
tools=[movie_search_tool],
)
response = agent.query(
input="List some sci-fi movies from the 1990s",
)
Es sollte eine Antwort wie die folgende 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.
Vertex AI-Erweiterung
Zuerst das Erweiterungspaket importieren und das Tool erstellen
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 dann in LangchainAgent:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
model=model,
tools=[generate_and_execute_code],
)
agent.query(
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},
}
"""
)
Es sollte eine Antwort wie die folgende 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 Erweiterung Code Interpreter zugreifen kann, müssen Sie dem Dienstkonto „AI Platform Reasoning Engine Service Agent“ die Rolle „Vertex AI User“ (roles/aiplatform.user) hinzufügen. Weitere Informationen finden Sie unter Zugriff verwalten.
Weitere Informationen finden Sie unter Vertex AI Extensions.
Sie können alle oder nur einige der Tools verwenden, die Sie in LangchainAgent erstellt haben:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
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)
],
)
agent.query(input="When is the next total solar eclipse in US?")
(Optional) Toolkonfiguration
Mit Gemini können Sie Einschränkungen für die Tool-Nutzung 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.LangchainAgent(
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"],
},
},
},
)
agent.query(
input="Explain the Schrodinger equation in a few sentences",
)
Weitere Informationen finden Sie unter Toolkonfiguration.
Schritt 3: Chatprotokoll speichern
Wenn Sie Chatnachrichten erfassen und an eine Datenbank anhängen möchten, definieren Sie eine get_session_history-Funktion und übergeben Sie sie, wenn Sie den Agent erstellen. Diese Funktion sollte ein session_id-Objekt als Eingabe verwenden und ein BaseChatMessageHistory-Objekt zurückgeben.
session_idist eine Kennung für die Sitzung, zu der diese Eingabenachrichten gehören. So können Sie mehrere Unterhaltungen gleichzeitig führen.BaseChatMessageHistoryist die Schnittstelle für Klassen, die Nachrichtenobjekte laden und speichern können.
Datenbank einrichten
Eine Liste der von Google bereitgestellten ChatMessageHistory-Anbieter, die in LangChain unterstützt werden, finden Sie unter Memory.
Folgen Sie zuerst der LangChain-Dokumentation, um das entsprechende Paket zu installieren und zu verwenden, um eine Datenbank Ihrer Wahl einzurichten (z.B. Firestore, Bigtable oder Spanner):
Definieren Sie als Nächstes eine get_session_history-Funktion so:
Firestore (nativer Modus)
def get_session_history(session_id: str):
from langchain_google_firestore import FirestoreChatMessageHistory
from google.cloud import firestore
client = firestore.Client(project="PROJECT_ID")
return FirestoreChatMessageHistory(
client=client,
session_id=session_id,
collection="TABLE_NAME",
encode_message=False,
)
Bigtable
def get_session_history(session_id: str):
from langchain_google_bigtable import BigtableChatMessageHistory
return BigtableChatMessageHistory(
instance_id="INSTANCE_ID",
table_id="TABLE_NAME",
session_id=session_id,
)
Spanner
def get_session_history(session_id: str):
from langchain_google_spanner import SpannerChatMessageHistory
return SpannerChatMessageHistory(
instance_id="INSTANCE_ID",
database_id="DATABASE_ID",
table_name="TABLE_NAME",
session_id=session_id,
)
Erstellen Sie schließlich den Agent und übergeben Sie ihn als chat_history:
from vertexai import agent_engines
agent = agent_engines.LangchainAgent(
model=model,
chat_history=get_session_history, # <- new
)
Achten Sie beim Abfragen des Agents darauf, dass Sie session_id übergeben, damit der Agent sich an frühere Fragen und Antworten „erinnern“ kann:
agent.query(
input="What is the exchange rate from US dollars to Swedish currency?",
config={"configurable": {"session_id": "SESSION_ID"}},
)
Sie können prüfen, ob nachfolgende Anfragen sich an die Sitzung erinnern:
response = agent.query(
input="How much is 100 USD?",
config={"configurable": {"session_id": "SESSION_ID"}},
)
print(response)
Schritt 4: Aufforderungsvorlage anpassen
Mithilfe von Prompt-Vorlagen wird die Nutzereingabe in Anweisungen für ein Modell übersetzt. 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 Agent, die auf alle Anfragen angewendet werden sollen. |
| Optional: Chatprotokoll | Nachrichten, die dem Chatverlauf aus einer früheren Sitzung entsprechen. |
| Nutzereingabe | Die Anfrage des Nutzers, auf die der Agent antworten soll. |
| Agent Scratchpad | Nachrichten, die vom Agenten erstellt werden (z.B. mit Funktionsaufrufen), während er seine Tools verwendet und Schlussfolgerungen zieht, um eine Antwort für den Nutzer zu formulieren. |
Die Standardvorlage für Prompts wird generiert, wenn Sie den Agent erstellen, ohne eine eigene Vorlage für Prompts anzugeben. Sie sieht dann 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}"),
])
Im folgenden Beispiel wird die vollständige Prompt-Vorlage implizit verwendet, wenn Sie den Agenten instanziieren:
from vertexai import agent_engines
system_instruction = "I help look up the rate between currencies"
agent = agent_engines.LangchainAgent(
model=model,
system_instruction=system_instruction,
chat_history=get_session_history,
tools=[get_exchange_rate],
)
Sie können die Standardvorlage für Prompts mit Ihrer eigenen Vorlage überschreiben und sie beim Erstellen des Agents 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.LangchainAgent(
model=model,
prompt=custom_prompt_template,
chat_history=get_session_history,
tools=[get_exchange_rate],
)
agent.query(
input="What is the exchange rate from US dollars to Swedish currency?",
config={"configurable": {"session_id": "SESSION_ID"}},
)
Schritt 5: Orchestrierung anpassen
Alle LangChain-Komponenten implementieren die Runnable-Schnittstelle, die Eingabe- und Ausgabeschemas für die Orchestrierung bereitstellt. Für die Klasse LangchainAgent muss ein ausführbares Programm erstellt werden, damit sie auf Anfragen reagieren kann. Standardmäßig erstellt LangchainAgent ein solches ausführbares Programm, indem das Modell mit Tools verknüpft wird. Dabei wird ein AgentExecutor verwendet, das in ein RunnableWithMessageHistory eingebunden ist, wenn das Chatprotokoll aktiviert ist.
Sie können die Orchestrierung anpassen, wenn Sie (i) einen Agenten implementieren möchten, der eine deterministische Reihe von Schritten ausführt (anstatt eine offene Argumentation durchzuführen), oder (ii) den Agenten auf ReAct-ähnliche Weise auffordern möchten, jeden Schritt mit Überlegungen dazu zu versehen, warum er diesen Schritt ausgeführt hat. Dazu müssen Sie beim Erstellen von LangchainAgent 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,
chat_history: Optional["GetSessionHistoryCallable"] = None,
model_tool_kwargs: Optional[Mapping[str, Any]] = None,
agent_executor_kwargs: Optional[Mapping[str, 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).toolsundmodel_tool_kwargsentsprechen den zu verwendenden Tools und Konfigurationen (siehe Tool definieren und verwenden).chat_historyentspricht der Datenbank zum Speichern von Chatnachrichten (siehe Chatprotokoll speichern).system_instructionundpromptentsprechen der Aufforderungskonfiguration (siehe Aufforderungsvorlage anpassen).agent_executor_kwargsundrunnable_kwargssind die Schlüsselwortargumente, mit denen Sie die zu erstellende ausführbare Datei anpassen können.
So haben Sie verschiedene Möglichkeiten, die Orchestrierungslogik anzupassen.
ChatModel
Im einfachsten Fall können Sie zum Erstellen eines Agents ohne Orchestrierung die runnable_builder für LangchainAgent ü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.LangchainAgent(
model=model,
runnable_builder=llm_builder,
)
ReAct
Wenn Sie das standardmäßige Tool-Aufrufverhalten durch einen eigenen ReAct-Agenten auf der Grundlage Ihres eigenen prompt überschreiben möchten (siehe Promptvorlage anpassen), müssen Sie die runnable_builder für LangchainAgent ü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.LangchainAgent(
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 das folgende Diagramm mit der LangChain Expression Language (LCEL):
Input
/ \
Pros Cons
\ /
Summary
Sie müssen runnable_builder für LangchainAgent ü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.LangchainAgent(
model=model,
runnable_builder=lcel_builder,
)
LangGraph
So erstellen Sie das folgende Diagramm mit LangGraph:
Input
/ \
Pros Cons
\ /
Summary
Sie müssen runnable_builder für LangchainAgent ü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.LangchainAgent(
model=model,
runnable_builder=langgraph_builder,
)
# Example query
agent.query(input={"role": "user", "content": "scrum methodology"})
Nächste Schritte
- LangChain-Agent verwenden
- Agent bewerten
- Agent bereitstellen
- Fehlerbehebung bei der Entwicklung eines Agents
- Support anfordern