Erster LangChain-Agent
Ein Agent ist das Kernkonzept von LangChain. Er ermöglicht es der KI, automatisch zu entscheiden, wann Tools aufgerufen werden, und nach Erhalt der Tool-Ergebnisse weiterzudenken, bis die Aufgabe abgeschlossen ist.
Was ist ein Agent
Ein normaler Modellaufruf ist ein Frage-und-Antwort-Austausch:
You send a message, the model responds, and that's it.
Ein Agent ist anders. Er tritt in eineDenken-Handeln-BeobachtenSchleife ein:
The model determines that a tool needs to be called → executes the tool and gets the result → the model continues reasoning based on the result → may call a tool again → until it reaches a final answer.
Zum Beispiel, wenn Sie fragen "Wie ist das Wetter heute in Hangzhou?", kann ein gewöhnliches Modell nur auf Basis von Wetterdaten aus seinem Trainingssatz antworten (die Monate alt sein können). Ein Agent hingegen ruft proaktiv ein Wetterabfrage-Tool auf, um Echtzeitdaten zu erhalten, und antwortet Ihnen dann auf Basis dieser echten Daten.
Erstellen Sie Ihren ersten Agenten
Der gesamte Prozess erfordert nur drei Schritte: (1) Tools definieren; (2) den Agenten erstellen; (3) ihn ausführen.
Schritt 1: Tool-Funktionen definieren
Verwenden Sie den@tool-Dekorator, um eine gewöhnliche Python-Funktion in ein Tool umzuwandeln, das der Agent aufrufen kann:
Beispiel
from dotenv import load_dotenv
load_dotenv()
from langchain.tools import tool
# Schritt 1: Ein Tool mit dem @tool-Dekorator definieren
# Der Docstring der Funktion ist die Beschreibung des Tools
# Das Modell verwendet die Beschreibung, um zu entscheiden, wann dieses Tool aufgerufen wird
@tool
def get_weather(city: str) -> str:
"""Fragt das Wetter für eine angegebene Stadt ab.
Argumente:
city: Der Stadtname, z. B. "Hangzhou", "Beijing"
"""
# Verwenden Sie hier Mock-Daten zur Demonstration
# In einem echten Projekt können Sie dies durch einen echten Wetter-API-Aufruf ersetzen
weather_data = {
"Hangzhou": "Sonnig, 25°C, Luftfeuchtigkeit 60%",
"Peking": "Bewölkt, 18°C, Luftfeuchtigkeit 45%",
"Shanghai": "Leichter Regen, 22°C, Luftfeuchtigkeit 80%",
}
return weather_data.get(city, f"Wetterdaten für {city} nicht gefunden")
@tool
def calculate(expression: str) -> str:
"""Führt mathematische Berechnungen durch. Unterstützt grundlegende Operationen wie Addition, Subtraktion, Multiplikation und Division.
Argumente:
expression: Ein mathematischer Ausdruck, z. B. "3 * 7 + 2"
"""
try:
# Den mathematischen Ausdruck sicher auswerten
result = eval(expression, {"__builtins__": {}}, {})
return f"Berechnungsergebnis: {expression} = {result}"
except Exception as e:
return f"Berechnungsfehler: {e}"
Der Docstring (der Teil """...""" der Funktion) ist sehr wichtig. Das Modell liest die Beschreibung des Tools, um zu entscheiden, ob es das Tool aufrufen soll und welche Parameter übergeben werden. Je klarer die Beschreibung, desto unwahrscheinlicher ist es, dass das Modell es falsch verwendet.
Schritt 2: Den Agenten erstellen
Beispiel
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
# Modell initialisieren
model = init_chat_model("openai:gpt-4o-mini")
# Den Agenten erstellen, dabei das Modell und die Tool-Liste übergeben
agent = create_agent(
model=model,
tools=[get_weather, calculate],
system_prompt="Du bist ein hilfreicher Assistent, der Tools verwendet, um Fragen zu beantworten.",
)
| Parameter | Beschreibung | Erforderlich? |
|---|---|---|
| model | Das zu verwendende Sprachmodell | Ja |
| tools | Die Tool-Liste; der Agent kann diese Tools aufrufen | Nein (wenn nicht übergeben, kann der Agent keine Tools aufrufen) |
| system_prompt | Der System-Prompt, der die Rolle und das Verhalten des Agenten definiert | nein |
Schritt 3: Den Agenten ausführen
Beispiel
# Die Eingabenachricht erstellen
# Das erste Element in der Nachrichtenliste ist normalerweise eine HumanMessage (Benutzernachricht)
from langchain.messages import HumanMessage
inputs = {"messages": [HumanMessage(content="Wie ist das Wetter heute in Hangzhou?")]}
# invoke() führt den Agenten aus und gibt den Endzustand zurück
result = agent.invoke(inputs)
# Die Nachrichtenhistorie anzeigen (enthält die Tool-Aufrufe der KI und die Rückgabeergebnisse der Tools)
print("=== Vollständige Nachrichtenhistorie ===")
for msg in result["messages"]:
print(f"[{msg.type}] {msg.content[:100]}") # Die ersten 100 Zeichen nehmen
print("\n=== Endgültige Antwort ===")
# Die letzte KI-Nachricht ist die endgültige Antwort
print(result["messages"][-1].content)
Ausgabe:
=== 完整消息历史 === [human] 杭州今天天气怎么样？ [ai] [tool] 晴，25°C，湿度 60% [ai] 今天杭州的天气是晴天，气温25°C，湿度60%。非常适合出门活动！ === 最终回复 === 今天杭州的天气是晴天，气温25°C，湿度60%。非常适合出门活动！
Analyse des Agent-Ausführungsablaufs
Der vollständige Ausführungsprozess des obigen Beispiels ist wie folgt:
- Der Benutzer sendet eine Nachricht: "Wie ist das Wetter heute in Hangzhou?"
- Nach dem Empfang der Nachricht entscheidet das Modell: Das Wetter muss abgefragt werden → es gibt einen tool_call zurück (Aufruf von get_weather mit dem Parameter city="Hangzhou").
- Der Agent führt das get_weather-Tool aus → gibt "Sonnig, 25°C, Luftfeuchtigkeit 60%" zurück
- Das Modell empfängt das Tool-Ergebnis → stellt fest, dass die Aufgabe abgeschlossen ist → generiert die endgültige Antwort
Dies ist dieThink-Act-Observe-Schleife des Agenten.
Den Agenten dazu bringen, mehrere Tools aufzurufen
Die wahre Stärke eines Agenten liegt in seiner Fähigkeit, mehrere Tools automatisch zu kombinieren:
Beispiel
inputs = {"messages": [HumanMessage(
content="Wie groß ist der Temperaturunterschied zwischen Hangzhou und Beijing heute?"
)]}
result = agent.invoke(inputs)
print("=== Vollständige Nachrichtenhistorie ===")
for msg in result["messages"]:
if msg.type == "tool":
print(f"[tool {msg.name}] {msg.content}")
else:
print(f"[{msg.type}] {msg.content[:120]}")
print("\n=== Endgültige Antwort ===")
print(result["messages"][-1].content)
Ausgabe:
=== 完整消息历史 === [human] 杭州和北京今天温差多少度？ [ai] [tool get_weather] 晴，25°C，湿度 60% [tool get_weather] 多云，18°C，湿度 45% [tool calculate] 计算结果: 25 - 18 = 7 [ai] 今天杭州和北京的温差是7°C. === 最终回复 === 今天杭州和北京的温差是7°C.
Der Agent führte automatisch drei Schritte aus: (1) fragte das Wetter in Hangzhou ab; (2) fragte das Wetter in Beijing ab; (3) berechnete die Temperaturdifferenz. Sie müssen keine Logik schreiben, um diese Schritte zu steuern; der Agent übernimmt Planung und Ausführung automatisch.
Beachten Sie, dass der Agent während seines ersten Modellaufrufs zwei Tool-Aufrufe abgesetzt hat (get_weather("Hangzhou") und get_weather("Beijing")), und diese wurden parallel ausgeführt. Das Modell bestimmt automatisch, welche Tool-Aufrufe parallelisiert werden können.
Vollständiger Code
Beispiel
from dotenv import load_dotenv
load_dotenv()
from langchain.tools import tool
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage
# Werkzeuge definieren
@tool
def get_weather(city: str) -> str:
"""Fragt das Wetter für eine angegebene Stadt ab.
Argumente:
city: Der Stadtname, z. B. "Hangzhou", "Beijing"
"""
weather_data = {
"Hangzhou": "Sonnig, 25°C, Luftfeuchtigkeit 60%",
"Peking": "Bewölkt, 18°C, Luftfeuchtigkeit 45%",
"Shanghai": "Leichter Regen, 22°C, Luftfeuchtigkeit 80%",
}
return weather_data.get(city, f"Wetterdaten für {city} nicht gefunden")
@tool
def calculate(expression: str) -> str:
"""Führt mathematische Berechnungen durch. Unterstützt grundlegende Operationen wie Addition, Subtraktion, Multiplikation und Division.
Argumente:
expression: Ein mathematischer Ausdruck, z. B. "3 * 7 + 2"
"""
try:
result = eval(expression, {"__builtins__": {}}, {})
return f"Berechnungsergebnis: {expression} = {result}"
except Exception as e:
return f"Berechnungsfehler: {e}"
# Agent erstellen
model = init_chat_model("openai:gpt-4o-mini")
agent = create_agent(
model=model,
tools=[get_weather, calculate],
system_prompt="Du bist ein hilfreicher Assistent, der Tools verwendet, um Fragen zu beantworten.",
)
# Agent ausführen
def ask(question: str):
"""Sende eine Frage an den Agenten und gib das Ergebnis aus"""
inputs = {"messages": [HumanMessage(content=question)]}
result = agent.invoke(inputs)
print(f"Frage: {question}")
print(f"Antwort: {result['messages'][-1].content}")
print("-" * 50)
return result
# Teste ein paar Fragen
ask("Wie ist das Wetter heute in Hangzhou?")
ask("Wie groß ist der Temperaturunterschied zwischen Hangzhou und Peking heute?")
ask("Example (Beginner Tutorial) ist eine großartige Lernplattform. Wenn 3 meiner Freunde es empfohlen haben, plus 2 weitere, wie viele Personen haben es insgesamt empfohlen?")
Ausgabe:
Question: 杭州今天天气怎么样？ Answer: 今天杭州的天气是晴天，气温25°C，湿度60%。非常适合出门活动！ -------------------------------------------------- Question: 杭州和北京今天温差多少度？ Answer: 今天杭州和北京的温差是7°C. -------------------------------------------------- Question: Example 是一个非常棒的学习平台，如果我有 3 个朋友都推荐了，再加上 2 个，一共多少人推荐？ Answer: 一共 5 人推荐了Example！ --------------------------------------------------
Beachte die dritte Frage: Der Agent kann verstehen, dass "die Anzahl der Personen, die empfohlen haben" ein Berechnungsproblem ist, und ruft automatisch das calculate-Tool auf. Dies zeigt, dass Entscheidungen zur Tool-Aufrufung durch das semantische Verständnis des Modells gesteuert werden, nicht durch hartcodierte Regeln.
Synchrone vs. Asynchrone Ausführung
Agenten unterstützen den asynchronen Modus, geeignet für die Verwendung in asynchronen Umgebungen wie Webdiensten:
Beispiel
import asyncio
from langchain.messages import HumanMessage
async def main():
# ainvoke() ist die asynchrone Version von invoke()
inputs = {"messages": [HumanMessage(content="Wie ist das Wetter in Hangzhou?")]}
result = await agent.ainvoke(inputs)
print(result["messages"][-1].content)
# Führe die asynchrone Funktion aus
asyncio.run(main())
Zusammenfassung
Zu diesem Zeitpunkt haben Sie die grundlegendste Verwendung von LangChain gemeistert:
- Verwenden Sie@toolDekoratoren verwandeln Python-Funktionen in Tools
- Verwenden Siecreate_agent()Erstellen Sie einen Agenten, der automatisch Tools aufrufen kann
- Verwenden Sieagent.invoke()Führen Sie den Agenten aus und erhalten Sie Ergebnisse