LangChain für KI-Agenten: Vollständiges Tutorial
KI-Agenten sind autonome Softwareeinheiten, die ihre Umgebung wahrnehmen, Entscheidungen treffen und Maßnahmen ergreifen können, um bestimmte Ziele zu erreichen. Sie stellen einen bedeutenden Fortschritt in der Art und Weise dar, wie wir mit intelligenten Systemen interagieren und sie entwickeln. Wenn Sie die Kernkomponenten und die praktische Implementierung von KI-Agenten verstehen möchten, beginnen Sie mit Der vollständigen Anleitung zu KI-Agenten im Jahr 2026. LangChain hebt sich als leistungsfähiges Framework für den Aufbau dieser Agenten hervor und bietet die notwendigen Abstraktionen und Werkzeuge zur Integration großer Sprachmodelle (LLMs) mit externen Datenquellen und Rechenfähigkeiten. Dieses Tutorial wird Sie durch den Aufbau von KI-Agenten mit LangChain führen, wobei der Fokus auf den praktischen Aspekten und den zugrunde liegenden Mechanismen liegt.
Verstehen der Grundlagen von LangChain-Agenten
Im Kern orchestriert ein LangChain-Agent die Interaktion zwischen einem LLM und einer Reihe von Werkzeugen. Das LLM fungiert als das „Gehirn“ des Agenten, das entscheidet, welches Werkzeug verwendet wird und mit welchen Eingaben, basierend auf dem aktuellen Ziel und dem beobachteten Zustand. Werkzeuge sind Funktionen, die spezifische Aufgaben ausführen, wie z.B. das Durchsuchen des Webs, Abfragen einer Datenbank oder Ausführen von Code.
Die Hauptkomponenten eines LangChain-Agenten sind:
- LLM: Das Sprachmodell, das für das Denken und die Entscheidungsfindung verantwortlich ist.
- Werkzeuge: Funktionen, die der Agent verwenden kann, um mit der externen Welt zu interagieren.
- Prompt: Anweisungen, die dem LLM gegeben werden, um sein Verhalten und die Nutzung von Werkzeugen zu leiten.
- Agent Executor: Die Laufzeitumgebung, die die Schleife des Agenten verwaltet und Beobachtungen sowie Aktionen zwischen dem LLM und den Werkzeugen überträgt.
Betrachten Sie einen Agenten, der entwickelt wurde, um Fragen zu aktuellen Ereignissen zu beantworten. Er könnte ein Werkzeug zum Durchführen von Websuchen und ein weiteres zum Abrufen von Artikeln haben. Das LLM würde basierend auf einer Anfrage entscheiden, ob es das Web durchsuchen, die Suche ausführen, die Ergebnisse beobachten und diese gegebenenfalls zusammenfassen sollte, bevor es eine endgültige Antwort formuliert.
Einrichten Ihrer LangChain-Umgebung
Bevor Sie einen Agenten erstellen, stellen Sie sicher, dass Sie LangChain installiert haben und Zugriff auf ein LLM haben. Wir werden im Tutorial die Modelle von OpenAI verwenden, aber LangChain unterstützt viele andere.
pip install langchain langchain-openai
Sie müssen Ihren OpenAI-API-Schlüssel als Umgebungsvariable festlegen:
import os
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
Für einfachere Beispiele können Sie das LLM direkt instanziieren:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(temperature=0)
Der `temperature`-Parameter steuert die Zufälligkeit der Ausgaben des LLM. Ein Wert von 0 macht die Ausgabe deterministischer und faktenbasierter, was für die Entscheidungsfindung des Agenten geeignet ist.
Erstellen Ihres ersten LangChain-Agenten: Ein einfacher Suchagent
Lassen Sie uns einen Agenten konstruieren, der Fragen mithilfe von Websuchen beantworten kann. Dies erfordert ein Werkzeug zur Websuche. LangChain bietet Integrationen für verschiedene Suchanbieter. Wir werden das `TavilySearchResults`-Werkzeug verwenden, das oft eine gute Standardoption ist.
Zuerst installieren Sie das benötigte Paket und legen Ihren Tavily-API-Schlüssel fest:
pip install langchain-community tavily-python
import os
os.environ["TAVILY_API_KEY"] = "YOUR_TAVILY_API_KEY"
Jetzt definieren wir die Werkzeuge und instanziieren den Agenten.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_community.tools.tavily_search import TavilySearchResults
# 1. LLM initialisieren
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Werkzeuge definieren
search_tool = TavilySearchResults(max_results=3) # Begrenzt auf 3 Suchergebnisse
tools = [search_tool]
# 3. Den ReAct-Agenten-Prompt vom LangChain Hub abrufen
# Das ReAct-Muster (Reasoning and Acting) ist ein häufig verwendeter Ansatz für Agenten.
# Es fordert das LLM auf, einen Denkprozess zu generieren, bevor es eine Aktion ausführt.
prompt = hub.pull("hwchase17/react")
# 4. Den Agenten erstellen
# create_react_agent konstruiert einen Agenten, der den ReAct-Prompt verwendet.
agent = create_react_agent(llm, tools, prompt)
# 5. Den Agent Executor erstellen
# Der AgentExecutor ist dafür verantwortlich, die Entscheidungsloop des Agenten auszuführen.
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Den Agenten ausführen
response = agent_executor.invoke({"input": "Was ist die Hauptstadt von Frankreich und wie hoch ist die aktuelle Bevölkerung?"})
print(response["output"])
In diesem Beispiel:
- Wir initialisieren `ChatOpenAI` als unser LLM.
- Wir erstellen ein `TavilySearchResults`-Werkzeug.
- Wir ziehen einen standardmäßigen ReAct-Prompt aus dem `langchain_hub`. Dieser Prompt leitet das LLM an, Schritt für Schritt zu denken (Thought) und dann eine Aktion sowie eine Aktions-Eingabe zu entscheiden.
- `create_react_agent` kombiniert das LLM, die Werkzeuge und den Prompt zu einem Agenten.
- `AgentExecutor` führt den Agenten aus und verwaltet die Abfolge von Beobachtungen und Aktionen. Das Flag `verbose=True` ist entscheidend für das Debugging, da es den internen Denkprozess des Agenten anzeigt.
Die Ausgabe mit `verbose=True` zeigt das „Thought“, „Action“, „Action Input“ und „Observation“ des Agenten bei jedem Schritt und demonstriert sein Denken.
Hinzufügen komplexerer Werkzeuge und Fähigkeiten
Agenten werden wirklich leistungsfähig, wenn sie mit verschiedenen Systemen interagieren können. Lassen Sie uns unseren Agenten mit einem Werkzeug zum Durchführen von Berechnungen erweitern.
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.tools import tool # Dekorator für einfache Werkzeugerstellung
# 1. LLM initialisieren
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Werkzeuge definieren
search_tool = TavilySearchResults(max_results=3)
@tool
def calculator(expression: str) -> str:
"""Bewertet einen mathematischen Ausdruck und gibt das Ergebnis zurück."""
try:
return str(eval(expression))
except Exception as e:
return f"Fehler bei der Auswertung des Ausdrucks: {e}"
tools = [search_tool, calculator]
# 3. Den ReAct-Agenten-Prompt abrufen
prompt = hub.pull("hwchase17/react")
# 4. Den Agenten erstellen
agent = create_react_agent(llm, tools, prompt)
# 5. Den Agent Executor erstellen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Den Agenten mit einer neuen Abfrage ausführen
response = agent_executor.invoke({"input": "Was ist 12345 mal 67890? Finde auch heraus, wer die letzte Weltmeisterschaft gewonnen hat."})
print(response["output"])
Hier haben wir den `@tool`-Dekorator verwendet, um schnell ein `calculator`-Werkzeug zu definieren. Dieser Dekorator leitet automatisch die Beschreibung und das Argument Schema des Werkzeugs ab, die das LLM verwendet, um zu verstehen, wie es aufgerufen werden soll. Der Agent wird nun entscheiden, ob er den `calculator` oder `TavilySearchResults` basierend auf der Eingabeanfrage verwenden möchte. Diese Modularität ist entscheidend für den Aufbau anspruchsvoller KI-Agenten. Für fortschrittlichere Koordination zwischen mehreren Agenten bieten Frameworks wie CrewAI Multi-Agent Systems Guide leistungsfähige Abstraktionen.
Agenttypen und deren Anwendungsfälle
LangChain bietet mehrere Agenttypen, die jeweils unterschiedliche Stärken und zugrunde liegende Entscheidungsmechanismen aufweisen:
- `create_react_agent` (ReAct-Agent): Verwendet das ReAct-(Reasoning and Acting)-Muster. Das LLM generiert ein „Thought“ (internes Monolog) und dann eine „Action“ (Werkzeugaufruf) sowie „Action Input“. Dies ist ein hochwirksamer und weit verbreiteter Ansatz für allgemeine Agenten.
- `create_json_agent`: Entwickelt für Agenten, die mit APIs interagieren, die JSON-Eingaben und -Ausgaben erwarten. Das LLM wird aufgefordert, JSON-formatierten Werkzeugaufrufe zu generieren.
- `create_openai_functions_agent`: Verwendet die Funktionen zum Aufrufen von OpenAI. Das LLM gibt direkt ein strukturiertes Objekt aus, das angibt, welches Werkzeug aufzurufen ist und welche Argumente es hat, was zuverlässiger sein kann als das Parsen von Text. Dies ist oft die bevorzugte Wahl bei Verwendung von OpenAI-Modellen.
Die Wahl des richtigen Agenttyps hängt von Ihrem spezifischen Anwendungsfall und dem LLM ab, das Sie verwenden. Für die meisten allgemeinen Aufgaben mit OpenAI-Modellen ist `create_openai_functions_agent` ein ausgezeichneter Ausgangspunkt aufgrund seiner Zuverlässigkeit. Lassen Sie uns ein Beispiel ansehen, das es verwendet.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.messages import SystemMessage, HumanMessage
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# 1. LLM initialisieren
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Werkzeuge definieren
search_tool = TavilySearchResults(max_results=3)
@tool
def current_time(format_str: str = "%Y-%m-%d %H:%M:%S") -> str:
"""Gibt das aktuelle Datum und die aktuelle Uhrzeit im angegebenen Format zurück."""
import datetime
return datetime.datetime.now().strftime(format_str)
tools = [search_tool, current_time]
# 3. Die Agentenaufforderung definieren (unter Verwendung von OpenAI-Funktionsagent-spezifischen Nachrichten)
system_message = SystemMessage(
content="Du bist ein hilfreicher KI-Assistent. Nutze die verfügbaren Werkzeuge, um Fragen zu beantworten."
)
prompt = [system_message, HumanMessage(content="{input}"), MessagesPlaceholder(variable_name="agent_scratchpad")]
# 4. Den Agenten mit create_openai_functions_agent erstellen
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Den Agenten-Executor erstellen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Den Agenten ausführen
response = agent_executor.invoke({"input": "Wie spät ist es gerade und was waren die wichtigsten Nachrichtenüberschriften von gestern?"})
print(response["output"])
Beachte den `MessagesPlaceholder(variable_name=”agent_scratchpad”)` in der Aufforderung. Hier werden die zwischenzeitlichen Gedanken, Aktionen und Beobachtungen des Agenten in den Gesprächsverlauf eingefügt, sodass das LLM den Kontext aufrechterhalten kann.
Verwaltung des Agentenzustands und der Erinnerung
Damit Agenten komplexe, mehrstufige Interaktionen durchführen können, benötigen sie ein Gedächtnis. LangChain bietet verschiedene Gedächtniskomponenten zur Speicherung und zum Abrufen des Gesprächsverlaufs. Der `AgentExecutor` kann mit einem Gedächtnis konfiguriert werden.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.messages import SystemMessage, HumanMessage, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferWindowMemory # Gedächtnis importieren
# 1. LLM initialisieren
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Werkzeuge definieren
search_tool = TavilySearchResults(max_results=3)
tools = [search_tool]
# 3. Die Agentenaufforderung definieren
system_message = SystemMessage(
content="Du bist ein hilfreicher KI-Assistent. Nutze die verfügbaren Werkzeuge, um Fragen zu beantworten. Halte deine Antworten prägnant."
)
prompt = [
system_message,
MessagesPlaceholder(variable_name="chat_history"), # Platzhalter für den Chatverlauf
HumanMessage(content="{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
]
# 4. Gedächtnis erstellen
# ConversationBufferWindowMemory hält ein Fenster der letzten 'k' Interaktionen.
memory = ConversationBufferWindowMemory(memory_key="chat_history", return_messages=True, k=3)
# 5. Den Agenten erstellen
agent = create_openai_functions_agent(llm, tools, prompt)
# 6. Den Agenten-Executor mit Gedächtnis erstellen
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
memory=memory # Gedächtnis hier hinzufügen
)
# 7. Mehrstufiges Gespräch führen
print("--- Erster Zug ---")
response1 = agent_executor.invoke({"input": "Was ist die Hauptstadt von Japan?"})
print(response1["output"])
print("\n--- Zweiter Zug ---")
response2 = agent_executor.invoke({"input": "Wie hoch ist die Bevölkerung?"}) # Bezugnehmend auf "die" (Hauptstadt Japans)
print(response2["output"])
print("\n--- Dritter Zug ---")
response3 = agent_executor.invoke({"input": "Und wie steht es um die Hauptstadt von Brasilien?"})
print(response3["output"])
Durch die Einführung von `ConversationBufferWindowMemory` und die Einbeziehung von `MessagesPlaceholder(variable_name=”chat_history”)` in der Aufforderung kann der Agent nun den Kontext über mehrere Züge hinweg aufrechterhalten. Das LLM sieht die vorherigen Nachrichten, was ihm ermöglicht, Verweise wie “die Bevölkerung” im zweiten Zug zu verstehen. Dies ist entscheidend für den Aufbau ansprechender und funktionaler KI-Agenten, insbesondere für Anwendungsfälle wie einen Kundenservice-KI-Agenten.
Erweiterte Agentenanpassung und Werkzeugentwicklung
Obwohl LangChain viele integrierte Werkzeuge bereitstellt, musst du oft benutzerdefinierte Werkzeuge erstellen, um mit deinen spezifischen Anwendungen, Datenbanken oder internen APIs zu interagieren.
Benutzerdefinierte Werkzeuge können einfache Funktionen sein, die mit `@tool` dekoriert sind, wie im Fall von `calculator` und `current_time` gezeigt. Für komplexere Szenarien könntest du eine Klasse definieren, die von `BaseTool` erbt oder `StructuredTool` für eine präzise Argumentdefinition verwenden.
from langchain.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type
# Eingabeschema für das benutzerdefinierte Werkzeug definieren
class GetDatabaseRecordInput(BaseModel):
table_name: str = Field(description="Name der Datenbanktabelle")
record_id: int = Field(description="ID des abzurufenden Datensatzes")
class GetDatabaseRecordTool(BaseTool):
name = "get_database_record"
description = "Nützlich um einen bestimmten Datensatz aus einer Datenbanktabelle anhand seiner ID abzurufen."
args_schema: Type[BaseModel] = GetDatabaseRecordInput
def _run(self, table_name: str, record_id: int) -> str:
"""Simuliert das Abrufen eines Datensatzes aus einer Datenbank."""
print(f"DEBUG: Abrufen des Datensatzes {record_id} aus der Tabelle {table_name}")
if table_name == "users" and record_id == 1:
return "Benutzerdatensatz: {'id': 1, 'name': 'Alice', 'email': '[email protected]'}"
elif table_name == "products" and record_id == 101:
return "Produktdatensatz: {'id': 101, 'name': 'Laptop', 'price': 1200}"
return f"Datensatz für Tabelle '{table_name}' mit ID '{record_id}' nicht gefunden"
async def _arun(self, table_name: str, record_id: int) -> str:
"""Asynchrone Version des Werkzeugs (optional)."""
# Asynchrone Logik hier implementieren
raise NotImplementedError("Asynchrone Aufrufe sind für dieses Werkzeug nicht implementiert.")
# Füge dieses Werkzeug zur Werkzeugliste deines Agenten hinzu
# tools.append(GetDatabaseRecordTool())
Dieses `GetDatabaseRecordTool` demonstriert, wie man ein Werkzeug mit einem spezifischen Eingabeschema unter Verwendung von Pydantic definiert, das dem LLM klare Anweisungen gibt, wie es verwendet werden soll. Dieses Maß an Kontrolle ist entscheidend für die Integration von Agenten in Unternehmenssysteme. Beim Vergleich von Frameworks solltest du berücksichtigen, wie jedes diese benutzerdefinierten Werkzeugintegrationen behandelt; siehe Vergleich der besten 5 KI-Agenten-Frameworks 2026 für mehr Kontext.
Wichtige Erkenntnisse
- LangChain-Agenten verwenden ein LLM, um die Nutzung von Werkzeugen zu orchestrieren, wodurch sie mit der externen Welt über ihre Trainingsdaten hinaus interagieren können.
- Die Kernkomponenten sind das LLM, Werkzeuge, eine Aufforderung und der Agenten-Executor.
- Das ReAct-Muster (Reasoning and Acting) ist ein solider Ansatz, der häufig durch Aufforderungen aus dem LangChain Hub erleichtert wird.
- `create_openai_functions_agent` wird im Allgemeinen für OpenAI-Modelle empfohlen, da es eine zuverlässige strukturierte Ausgabe liefert.
- Gedächtniskomponenten (z.B. `ConversationBufferWindowMemory`) sind entscheidend für mehrstufige Gespräche und kontextuelles Bewusstsein.
- Benutzerdefinierte Werkzeuge sind einfach zu erstellen, indem der `@tool`-Dekorator verwendet wird oder indem von `BaseTool` für komplexere Interaktionen geerbt wird, was es Agenten ermöglicht, sich mit proprietären Systemen zu integrieren.
- Verwende immer `verbose=True` während der Entwicklung, um den internen Gedankengang des Agenten zu überprüfen und effektiv zu debuggen.
Fazit
LangChain bietet ein gründliches und flexibles Framework für den Aufbau von KI-Agenten. Durch das Verständnis seiner Kernkomponenten—LLMs, Werkzeuge, Aufforderungen und Executor—kannst du Agenten konstruieren, die in der Lage sind, komplexe Überlegungen und Interaktionen durchzuführen. Von einfachen Suchagenten bis hin zu ausgeklügelten Systemen mit Gedächtnis und benutzerdefinierten Integrationen bietet LangChain die Bausteine, um deine Ideen für KI-Agenten zu verwirklichen. Da sich das Feld der KI-Agenten weiterentwickelt, wird das Beherrschen von Frameworks wie LangChain zunehmend wertvoll für die Entwicklung intelligenter, autonomer Anwendungen.
🕒 Published: