LangChain für KI-Agenten: Vollständiges Tutorial
KI-Agenten sind autonome Software-Entitäten, die ihre Umgebung wahrnehmen, Entscheidungen treffen und handeln können, um spezifische 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 wesentlichen Komponenten und die praktische Implementierung von KI-Agenten verstehen möchten, beginnen Sie mit Dem vollständigen Leitfaden für KI-Agenten im Jahr 2026. LangChain hebt sich als leistungsstarkes Framework hervor, um diese Agenten zu erstellen und die notwendige Abstraktionen sowie Werkzeuge zur Integration von großen Sprachmodellen (LLMs) mit externen Datenquellen und Rechenressourcen bereitzustellen. Dieses Tutorial wird Sie beim Erstellen von KI-Agenten mit LangChain unterstützen und sich auf praktische Aspekte und zugrunde liegende Mechanismen konzentrieren.
Die Grundlagen der LangChain-Agenten verstehen
Im Herzen von LangChain orchestriert ein Agent die Interaktion zwischen einem LLM und einer Reihe von Werkzeugen. Das LLM fungiert als “Gehirn” des Agenten und entscheidet, welches Werkzeug verwendet werden soll und mit welchen Eingaben, basierend auf dem aktuellen Ziel und dem beobachteten Zustand. Die Werkzeuge sind Funktionen, die spezifische Aufgaben ausführen, wie z.B. Websuchen, Datenbankabfragen oder Codeausführung.
Die Hauptkomponenten eines LangChain-Agenten sind:
- LLM: Das Sprachmodell, das für das Denken und die Entscheidungsfindung verantwortlich ist.
- Werkzeuge: Funktionen, die der Agent zur Interaktion mit der Außenwelt nutzen kann.
- Prompt: Anweisungen, die dem LLM gegeben werden und sein Verhalten und die Nutzung der Werkzeuge lenken.
- Agent-Executor: Die Ausführungsumgebung, die die Schleife des Agenten verwaltet und Beobachtungen und Aktionen zwischen dem LLM und den Werkzeugen überträgt.
Betrachten wir einen Agenten, der so gestaltet ist, dass er Fragen zur aktuellen Nachrichtenlage beantwortet. Er könnte ein Werkzeug für Websuchen und ein anderes für Artikel haben. Das LLM würde bei einer Anfrage entscheiden, ob es im Web suchen, die Suche ausführen, die Ergebnisse beobachten und diese schließlich eventuell zusammenfassen soll, bevor es eine endgültige Antwort formuliert.
Ihr LangChain-Umfeld einrichten
Bevor Sie einen Agenten erstellen, stellen Sie sicher, dass Sie LangChain installiert haben und auf ein LLM zugreifen können. Wir werden die Modelle von OpenAI für dieses Tutorial 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"] = "IHRE_OPENAI_API_SCHLÜSSEL"
Für einfachere Beispiele können Sie das LLM direkt instanziieren:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(temperature=0)
Der Parameter `temperature` steuert das Maß an Randomisierung der Ausgabe des LLM. Ein Wert von 0 macht die Ausgabe deterministischer und faktischer, was für die Entscheidungsfindung der Agenten geeignet ist.
Erstellen Sie Ihren ersten LangChain-Agenten: Ein einfacher Suchagent
Erstellen wir einen Agenten, der in der Lage ist, Fragen mithilfe von Websuchen zu beantworten. Dazu benötigen wir ein Werkzeug zur Websuche. LangChain bietet Integrationen für verschiedene Suchanbieter. Wir werden das Werkzeug `TavilySearchResults` nutzen, das oft eine gute Standardwahl ist.
Zuerst installieren Sie das erforderliche Paket und konfigurieren Ihren Tavily-API-Schlüssel:
pip install langchain-community tavily-python
import os
os.environ["TAVILY_API_KEY"] = "IHRE_TAVILY_API_SCHLÜSSEL"
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) # Auf 3 Suchergebnisse begrenzen
tools = [search_tool]
# 3. Den Prompt des ReAct-Agenten aus dem LangChain Hub abrufen
# Das ReAct-Modell (Reasoning and Action) ist ein gängiger Ansatz für Agenten.
# Es ermutigt das LLM, einen Denkprozess zu generieren, bevor es eine Aktion trifft.
prompt = hub.pull("hwchase17/react")
# 4. Den Agenten erstellen
# create_react_agent erstellt einen Agenten, der den ReAct-Prompt nutzt.
agent = create_react_agent(llm, tools, prompt)
# 5. Den Agenten-Executor erstellen
# Der AgentExecutor ist verantwortlich für die Ausführung der Entscheidungs Schleife des Agenten.
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 Werkzeug `TavilySearchResults`.
- Wir rufen einen standardmäßigen ReAct-Prompt von `langchain_hub` ab. Dieser Prompt leitet das LLM dazu an, Schritt für Schritt zu denken (Denkweise) und dann eine Aktion und eine Aktionsauswahl zu treffen.
- `create_react_agent` kombiniert das LLM, die Werkzeuge und den Prompt zu einem Agenten.
- `AgentExecutor` führt den Agenten aus und verwaltet die Sequenz der Beobachtungen und Aktionen. Das Flag `verbose=True` ist entscheidend für das Debuggen, da es den internen Denkprozess des Agenten zeigt.
Die Ausgabe mit `verbose=True` zeigt bei jedem Schritt das „Denken“, „Aktion“, „Aktionseingabe“ und die „Beobachtung“ des Agenten an und veranschaulicht somit dessen Denkweise.
Werkzeuge und komplexere Fähigkeiten hinzufügen
Agenten werden wirklich leistungsstark, wenn sie mit verschiedenen Systemen interagieren können. Lassen Sie uns unseren Agenten mit einem Werkzeug zur Durchführung 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 eine 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 Bewertung des Ausdrucks: {e}"
tools = [search_tool, calculator]
# 3. Den Prompt des ReAct-Agenten abrufen
prompt = hub.pull("hwchase17/react")
# 4. Den Agenten erstellen
agent = create_react_agent(llm, tools, prompt)
# 5. Den Agenten-Executor erstellen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Den Agenten mit einer neuen Anfrage ausführen
response = agent_executor.invoke({"input": "Was ist 12345 multipliziert mit 67890? Außerdem, wer hat die letzte Weltmeisterschaft gewonnen?"})
print(response["output"])
Hier haben wir den Dekorator `@tool` verwendet, um schnell ein Werkzeug `calculator` zu definieren. Dieser Dekorator leitet automatisch die Beschreibung und das Argumenten-Schema des Werkzeugs ab, das das LLM nutzt, um zu verstehen, wie es aufgerufen werden soll. Der Agent entscheidet jetzt, ob er den `calculator` oder die `TavilySearchResults` je nach Eingabeanfrage nutzen soll. Diese Modularität ist entscheidend für den Aufbau von anspruchsvollen KI-Agenten. Für eine fortgeschrittenere Multi-Agenten-Koordination bieten Frameworks wie CrewAI Multi-Agent Systems Guide leistungsstarke Abstraktionen.
Arten von Agenten und deren Anwendungsfälle
LangChain bietet verschiedene Arten von Agenten, die jeweils unterschiedliche Stärken und Entscheidungsmechanismen aufweisen:
- `create_react_agent` (ReAct-Agent): Verwendet das ReAct-Modell (Reasoning and Action). Das LLM generiert ein „Denken“ (internes Monolog) gefolgt von einer „Aktion“ (Werkzeugaufruf) und einer „Eingabe der Aktion“. Dies ist ein sehr effektiver 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 dazu angeregt, Werkzeugaufrufe im JSON-Format zu erzeugen.
- `create_openai_functions_agent`: nutzt die Funktionalitäten von OpenAI zur Funktionsaufruf. Das LLM erzeugt direkt ein strukturiertes Objekt, das angibt, welches Werkzeug aufgerufen werden soll und welche Argumente es benötigt, was oft zuverlässiger ist als die Textanalyse. Dies ist oft die bevorzugte Wahl bei der Verwendung von OpenAI-Modellen.
Die Wahl des Agententyps hängt von Ihrem spezifischen Anwendungsfall und dem LLM ab, das Sie verwenden. Für die meisten allgemeinen Aufgaben mit den OpenAI-Modellen ist `create_openai_functions_agent` ein ausgezeichneter Ausgangspunkt aufgrund seiner Zuverlässigkeit. Lassen Sie uns ein Beispiel betrachten, in dem wir es verwenden.
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. Initialisiere LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Definiere die Werkzeuge
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 Uhrzeit im angegebenen Format zurück."""
import datetime
return datetime.datetime.now().strftime(format_str)
tools = [search_tool, current_time]
# 3. Definiere den Prompt des Agenten (unter Verwendung spezifischer OpenAI-Agenten-Nachrichten)
system_message = SystemMessage(
content="Sie sind ein hilfreicher KI-Assistent. Nutzen Sie die verfügbaren Werkzeuge, um die Fragen zu beantworten."
)
prompt = [system_message, HumanMessage(content="{input}"), MessagesPlaceholder(variable_name="agent_scratchpad")]
# 4. Erstelle den Agenten mit create_openai_functions_agent
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Erstelle den Agenten-Executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Führe den Agenten aus
response = agent_executor.invoke({"input": "Wie spät ist es gerade und was waren die wichtigsten Schlagzeilen der Presse von gestern?"})
print(response["output"])
Beachten Sie das `MessagesPlaceholder(variable_name=”agent_scratchpad”)` im Prompt. Hier werden die Gedanken, Handlungen und Zwischenbeobachtungen des Agents in die Konversationshistorie eingefügt, wodurch das LLM den Kontext aufrechterhalten kann.
Verwaltung des Status und der Erinnerung des Agents
Damit die Agents komplexe und mehrpartige Interaktionen realisieren können, benötigen sie Gedächtnis. LangChain bietet verschiedene Gedächtniskomponenten, um die Historie der Gespräche zu speichern und abzurufen. Das AgentExecutor kann mit 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. Initialisiere LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Definiere die Werkzeuge
search_tool = TavilySearchResults(max_results=3)
tools = [search_tool]
# 3. Definiere den Prompt des Agents
system_message = SystemMessage(
content="Sie sind ein hilfreicher KI-Assistent. Nutzen Sie die verfügbaren Werkzeuge, um die Fragen zu beantworten. Seien Sie prägnant in Ihren Antworten."
)
prompt = [
system_message,
MessagesPlaceholder(variable_name="chat_history"), # Platzhalter für die Gesprächshistorie
HumanMessage(content="{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
]
# 4. Erstelle das Gedächtnis
# ConversationBufferWindowMemory hält ein Fenster der 'k' letzten Interaktionen.
memory = ConversationBufferWindowMemory(memory_key="chat_history", return_messages=True, k=3)
# 5. Erstelle den Agenten
agent = create_openai_functions_agent(llm, tools, prompt)
# 6. Erstelle den Agenten-Executor mit Gedächtnis
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
memory=memory # Gedächtnis hier hinzufügen
)
# 7. Führe ein mehrteiliges Gespräch aus
print("--- Erster Teil ---")
response1 = agent_executor.invoke({"input": "Was ist die Hauptstadt von Japan?"})
print(response1["output"])
print("\n--- Zweiter Teil ---")
response2 = agent_executor.invoke({"input": "Wie hoch ist die Bevölkerung?"}) # Bezieht sich auf "seine" (die Hauptstadt von Japan)
print(response2["output"])
print("\n--- Dritter Teil ---")
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”) im Prompt kann der Agent nun den Kontext über mehrere Teile hinweg aufrechterhalten. Das LLM sieht die vorherigen Nachrichten, was ihm ermöglicht, Referenzen wie „seine Bevölkerung“ im zweiten Teil zu verstehen. Dies ist entscheidend für den Aufbau von ansprechenden und funktionalen KI-Agents, insbesondere für Anwendungsfälle wie die Erstellung eines KI-Agents für den Kundenservice.
Erweiterte Personalisierung des Agents und Tool-Entwicklung
Obwohl LangChain viele integrierte Werkzeuge anbietet, müssen Sie oft benutzerdefinierte Werkzeuge erstellen, um mit Ihren spezifischen Anwendungen, Datenbanken oder internen APIs zu interagieren.
Benutzerdefinierte Werkzeuge können einfache Funktionen sein, die mit @tool dekoriert sind, wie bei calculator und current_time gezeigt. Für komplexere Szenarien könnten Sie eine Klasse definieren, die von BaseTool erbt, oder StructuredTool verwenden, um eine präzise Argumentdefinition zu ermöglichen.
from langchain.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type
# Definiere das Eingabeschema für das benutzerdefinierte Werkzeug
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 zum Abrufen eines spezifischen Datensatzes aus einer Datenbanktabelle anhand seiner ID."
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 die Tabelle '{table_name}' mit der ID '{record_id}' nicht gefunden"
async def _arun(self, table_name: str, record_id: int) -> str:
"""Asynchrone Version des Werkzeugs (optional)."""
# Implementieren Sie die asynchrone Logik hier
raise NotImplementedError("Asynchrone Anfrage für dieses Werkzeug nicht implementiert.")
# Fügen Sie dieses Werkzeug zur Liste der Werkzeuge Ihres Agents hinzu
# tools.append(GetDatabaseRecordTool())
Dieses GetDatabaseRecordTool demonstriert, wie man ein Werkzeug mit einem spezifischen Eingabeschema unter Verwendung von Pydantic definiert, und bietet dem LLM klare Anweisungen, wie es zu verwenden ist. Dieser Kontrollgrad ist entscheidend für die Integration von Agents in Unternehmenssysteme. Wenn Sie Frameworks vergleichen, überlegen Sie, wie jedes von ihnen diese Integrationen benutzerdefinierter Werkzeuge handhabt; siehe Vergleichen der 5 besten KI-Agenten-Frameworks 2026 für weiteren Kontext.
Wichtige Punkte zum Mitnehmen
- Die Agents von LangChain verwenden ein LLM, um die Nutzung der Werkzeuge zu orchestrieren, was ihnen ermöglicht, mit der Außenwelt über ihre Trainingsdaten hinaus zu interagieren.
- Die Hauptkomponenten sind das LLM, die Werkzeuge, ein Prompt und der Agenten-Executor.
- Das ReAct-Modell (Reason and Act) ist ein solider Ansatz, der oft durch die Prompts im LangChain Hub unterstützt wird.
create_openai_functions_agentwird in der Regel für OpenAI-Modelle empfohlen, da es eine zuverlässige strukturierte Ausgabe bietet.- Gedächtniskomponenten (z.B.
ConversationBufferWindowMemory) sind entscheidend für mehrteilige Gespräche und kontextuelles Bewusstsein. - Benutzerdefinierte Werkzeuge sind einfach zu erstellen, indem Sie den Decorator
@toolverwenden oder vonBaseToolfür komplexere Interaktionen erben, was es den Agents ermöglicht, sich in proprietäre Systeme zu integrieren. - Verwenden Sie immer
verbose=Truewährend der Entwicklung, um den internen Denkprozess des Agents zu überprüfen und effektiv zu debuggen.
Fazit
LangChain bietet einen umfassenden und flexiblen Rahmen zum Aufbau von KI-Agents. Indem Sie seine Hauptkomponenten—LLMs, Werkzeuge, Prompts und Executor verstehen—können Sie Agents erstellen, die komplexes Denken und Interaktion durchführen können. Von einfachen Such-Agents bis hin zu komplexen Systemen mit Gedächtnis und benutzerdefinierten Integrationen bietet LangChain die notwendigen Elemente, um Ihre Ideen für KI-Agents zu verwirklichen. Während das Feld der KI-Agents weiterhin wächst, wird das Beherrschen von Frameworks wie LangChain immer wertvoller für die Entwicklung intelligenter und autonomer Anwendungen.
🕒 Published: