Autor: Priya Sharma – API-Architektin und KI-Integrationsberaterin
Die Fähigkeit, intelligente Systeme zu schaffen, die Anweisungen verstehen, logisch denken und autonom handeln können, verändert unsere Interaktion mit der Technologie. Im Zentrum dieser Transformation stehen KI-Agenten – Software-Entitäten, die entwickelt wurden, um Aufgaben unter Nutzung der Leistungsfähigkeit von Large Language Models (LLMs) und externen Tools auszuführen. Obwohl das Konzept komplex erscheinen mag, haben Frameworks wie LangChain den Entwicklungsprozess erheblich vereinfacht und die Erstellung von Agenten einem breiteren Publikum zugänglich gemacht.
Als API-Architektin und KI-Integrationsberaterin habe ich mit eigenen Augen das unglaubliche Potenzial gut gestalteter KI-Agenten gesehen. Sie können komplexe Arbeitsabläufe automatisieren, personalisierte Unterstützung bieten und neue Fähigkeiten für Unternehmen und Einzelpersonen freischalten. Dieser praktische Leitfaden wird Sie durch den Prozess des Aufbaus robuster KI-Agenten mit der LangChain-API führen, von der Verständnis der Hauptkomponenten bis zur Implementierung praktischer und konkreter Beispiele. Am Ende werden Sie eine solide Grundlage haben, um Ihre eigenen intelligenten Agenten zu entwerfen und bereitzustellen, die bereit sind, eine Vielzahl von Herausforderungen zu meistern.
KI-Agenten verstehen und die Rolle von LangChain
Bevor wir den Code erkunden, lassen Sie uns klären, was ein KI-Agent ist und warum LangChain ein unverzichtbares Werkzeug für deren Erstellung ist. Ein KI-Agent ist ein System, das ein LLM als sein „Gehirn“ nutzt, um zu entscheiden, welche Aktionen zu ergreifen sind. Im Gegensatz zu einem einfachen LLM-Aufruf, der eine einzige Antwort generiert, kann ein Agent einen mehrstufigen Denkprozess durchlaufen:
- Wahrnehmen: Die Eingabe des Benutzers oder den aktuellen Zustand verstehen.
- Logisch denken: Den besten Handlungsverlauf basierend auf seinem Verständnis und den verfügbaren Tools bestimmen.
- Handeln: Eine oder mehrere Aktionen unter Verwendung externer Tools ausführen.
- Lernen (optional, aber leistungsstark): Rückmeldungen einbeziehen, um die zukünftige Leistung zu verbessern.
LangChain bietet den notwendigen Rahmen, um diese anspruchsvollen Agenten zu bauen. Es bietet eine strukturierte Methode, um LLMs mit verschiedenen Datenquellen und Computerwerkzeugen zu verbinden, sodass sie über die einfache Textgenerierung hinausgehen können. Denken Sie an LangChain als das Betriebssystem Ihres KI-Agenten, das den Rahmen für seine Intelligenz, sein Gedächtnis und seine Fähigkeit zur Interaktion mit der Welt bereitstellt.
Schlüsselkomponenten eines LangChain-Agenten
Um einen Agenten mit LangChain zu erstellen, arbeiten Sie hauptsächlich mit diesen wesentlichen Komponenten:
- Large Language Model (LLM): Der Kern der Intelligenz. Dies könnten die GPT-Modelle von OpenAI, Claude von Anthropic oder Open-Source-Alternativen sein. Das LLM verarbeitet Eingaben, denkt logisch und trifft Entscheidungen.
- Tools: Funktionen, die der Agent aufrufen kann, um mit externen Systemen zu interagieren oder spezifische Berechnungen durchzuführen. Beispiele sind die Internetsuche, die Abfrage einer Datenbank, der Aufruf eines Rechners oder die Interaktion mit einer benutzerdefinierten API.
- Toolset: Sammlungen verwandter Tools, die für spezifische Anwendungsfälle entwickelt wurden (z. B. ein „Wikipedia-Toolset“ oder ein „CSV-Agenten-Toolset“).
- Agent Executor: Die Ausführungsumgebung, die die Aktionen des Agenten orchestriert. Sie trifft die Entscheidungen des LLM, führt die gewählten Tools aus und gibt die Ergebnisse an das LLM für eine weitere logische Verarbeitung zurück.
- Speicher: Ermöglicht es dem Agenten, Informationen aus vorherigen Interaktionen zu behalten, was konsistente Gespräche über mehrere Runden und kontextbezogene Entscheidungsfindung ermöglicht.
- Prompt-Modelle: Definieren, wie die Benutzereingabe und andere Informationen für das LLM formatiert werden, um dessen Denkprozess zu leiten.
Einrichten Ihrer Umgebung und erste Schritte
Bevor Sie den Code für den Agenten schreiben, stellen Sie sicher, dass Ihre Python-Umgebung bereit ist. Sie benötigen Python 3.8+ und die LangChain-Bibliothek sowie einen LLM-Anbieter, den Sie verwenden möchten.
Installation
Installieren Sie LangChain und einen LLM-Anbieter (z. B. OpenAI):
pip install langchain langchain-openai
pip install python-dotenv # Um API-Schlüssel sicher zu verwaltenVerwalten Sie Ihre API-Schlüssel sicher. Erstellen Sie eine Datei .env im Stammverzeichnis Ihres Projekts:
OPENAI_API_KEY="your_openai_api_key_here"Laden Sie sie dann in Ihr Python-Skript:
import os
from dotenv import load_dotenv
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")Grundlegende Interaktion mit dem LLM
Um Ihre Konfiguration zu bestätigen, machen wir einen einfachen Aufruf an das LLM:
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Verwendung eines leistungsstarken Modells mit deterministischem Output
messages = [
HumanMessage(content="Was ist die Hauptstadt von Frankreich?")
]
response = llm.invoke(messages)
print(response.content)Diese grundlegende Interaktion bestätigt, dass Ihre LLM-Verbindung funktioniert. Jetzt rüsten wir unser LLM mit Tools aus.
Tools für Ihren KI-Agenten erstellen
Die Tools sind die Hände und Füße des Agenten, die ihm ermöglichen, mit der Außenwelt zu interagieren. LangChain macht die Definition von Tools einfach. Jedes Tool sollte einen klaren Namen, eine Beschreibung und eine Funktion haben, die die Aktion ausführt.
Beispiel: Ein einfaches Rechner-Tool
Erstellen wir ein Tool, das grundlegende Arithmetik durchführen kann. Obwohl LLMs einfache Mathematik durchführen können, sind externe Tools zuverlässiger für komplexe Berechnungen.
from langchain.tools import tool
@tool
def calculator(expression: str) -> str:
"""Bewertet einen mathematischen Ausdruck und gibt das Ergebnis zurück.
Die Eingabe muss eine Zeichenkette mit einem gültigen mathematischen Ausdruck sein, z. B. '2 + 2' oder '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Fehler bei der Bewertung des Ausdrucks: {e}"
# Sie können das Tool direkt testen
print(calculator.invoke("10 * 5 + 3"))Beachten Sie den Dekorator @tool. Dies wandelt Ihre Funktion automatisch in ein LangChain-Tool um. Die Docstring ist entscheidend, da sie als Beschreibung des Tools dient, die das LLM verwendet, um zu verstehen, wann und wie es eingesetzt werden soll.
Beispiel: Ein Web-Such-Tool (unter Verwendung von Tavily)
Die meisten leistungsstarken Agenten benötigen Zugriff auf aktuelle Informationen. Ein Web-Such-Tool ist grundlegend. Wir werden Tavily verwenden, eine Such-API, die speziell für RAG (Retrieval Augmented Generation) und Anwendungsfälle von Agenten entwickelt wurde.
Installieren Sie zunächst Tavily und konfigurieren Sie Ihren API-Schlüssel in Ihrer .env-Datei:
pip install tavily-pythonTAVILY_API_KEY="your_tavily_api_key_here"Laden Sie es dann:
import os
from dotenv import load_dotenv
from langchain_community.tools.tavily_search import TavilySearchResults
load_dotenv()
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# Erstellen Sie das Tavily-Such-Tool
search = TavilySearchResults(max_results=3) # Die 3 besten Ergebnisse abrufen
# Sie können auch den Namen und die Beschreibung nach Bedarf anpassen
# search.name = "web_search"
# search.description = "Websuche nach Informationen."
# Testen Sie das Such-Tool
print(search.invoke("Tutorial zum LangChain-Agenten"))Durch die Definition dieser Tools geben wir unserem Agenten die notwendigen Fähigkeiten, um sein Wissen über seine Trainingsdaten hinaus zu erweitern und Berechnungen präzise durchzuführen.
Erstellen Sie Ihren ersten LangChain-Agenten
Mit unserem LLM und unseren Tools bereit können wir jetzt unseren ersten LangChain-Agenten zusammenstellen. Wir werden die Methode „create_openai_functions_agent“ verwenden, die eine praktische Möglichkeit bietet, Agenten zu erstellen, die die Funktionsaufruffähigkeiten von OpenAI nutzen.
Schritte zum Erstellen des Agenten
- Definieren Sie Ihr LLM: Das Gehirn Ihres Agenten.
- Definieren Sie Ihre Tools: Die Fähigkeiten, die Ihr Agent hat.
- Erstellen Sie ein Prompt-Modell: Leiten Sie das LLM in seinem Verhalten.
- Erstellen Sie den Agenten: Kombinieren Sie LLM, Tools und Prompt.
- Erstellen Sie den Agent Executor: Die Ausführungsumgebung, die die Entscheidungen des Agenten ausführt.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# Umgebungsvariablen laden
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# 1. LLM definieren
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# 2. Werkzeuge definieren
@tool
def calculator(expression: str) -> str:
"""Bewertet einen mathematischen Ausdruck und gibt das Ergebnis zurück.
Der Eingang muss eine Zeichenkette mit einem gültigen mathematischen Ausdruck sein, z.B. '2 + 2' oder '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Fehler bei der Auswertung des Ausdrucks: {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Sucht im Internet nach aktuellen Informationen zu einer gegebenen Anfrage."
tools = [calculator, search]
# 3. Ein Prompt-Modell erstellen
prompt = ChatPromptTemplate.from_messages(
[
("system", "Sie sind ein hilfreicher KI-Assistent. Beantworten Sie die Fragen so genau wie möglich."),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# 4. Den Agenten erstellen
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Den Agenten-Executor erstellen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Den Agenten ausführen
# print("--- Ausführung des Agenten 1 (Einfache Berechnung) ---")
# result1 = agent_executor.invoke({"input": "Was ist 12345 * 6789?", "chat_history": []})
# print(result1["output"])
# print("\n--- Ausführung des Agenten 2 (Websuche) ---")
# result2 = agent_executor.invoke({"input": "Was ist die Hauptstadt von Portugal und wie hoch ist die aktuelle Bevölkerung?", "chat_history": []})
# print(result2["output"])
# print("\n--- Ausführung des Agenten 3 (Kombiniert) ---")
# result3 = agent_executor.invoke({"input": "Was ist die Quadratwurzel von 81 und wer hat das World Wide Web erfunden?", "chat_history": []})
# print(result3["output"])Wenn Sie verbose=True im AgentExecutor festlegen, sehen Sie den Denkprozess des Agenten: welche Werkzeuge er in Betracht zieht, welches er auswählt, den Eingang, den er dem Werkzeug gibt, und die Ausgabe des Werkzeugs. Das ist äußerst nützlich für das Debugging und um zu verstehen, wie Ihr Agent denkt.
Das Prompt-Modell verstehen
system: Definiert die allgemeine Persönlichkeit und die Anweisungen für den Agenten.MessagesPlaceholder(variable_name="chat_history"): Hier werden die vorherigen Gesprächsrunden eingefügt, was Gedächtnis ermöglicht.human: Der aktuelle Eingang des Benutzers.MessagesPlaceholder(variable_name="agent_scratchpad"): Hier wird der interne Denkprozess des Agenten und die Ausgaben der Werkzeuge während einer einzigen Invocation gespeichert, was dem LLM ermöglicht, Schritt für Schritt zu denken.
Gedächtnis und Zustand zu Ihrem KI-Agenten hinzufügen
Ein wirklich intelligenter Agent benötigt Gedächtnis, um den Kontext über mehrere Gesprächsrunden hinweg aufrechtzuerhalten. LangChain bietet verschiedene Arten von Gedächtnis, die es Ihrem Agenten ermöglichen, sich an vergangene Interaktionen zu erinnern.
Warum ist Gedächtnis wichtig?
- Kohärenz: Agenten können sich auf frühere Aussagen und Fragen beziehen.
- Personalisierung: Agenten können sich an die Vorlieben des Benutzers oder an vergangene Interaktionen erinnern.
- Effizienz: Vermeidet es, Informationen zu wiederholen oder nach Klarstellungen zu Details zu fragen, die bereits bereitgestellt wurden.
Implementierung von ConversationBufferMemory
ConversationBufferMemory ist eine einfache, aber effektive Gedächtnisart, die alle vorherigen Nachrichten direkt speichert.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory # Gedächtnis importieren
# Umgebungsvariablen laden
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# LLM und Werkzeuge (identisch wie vorher)
llm = ChatOpenAI(model="gpt-4o", temperature=0)
@tool
def calculator(expression: str) -> str:
"""Bewertet einen mathematischen Ausdruck und gibt das Ergebnis zurück.
Der Eingang muss eine Zeichenkette mit einem gültigen mathematischen Ausdruck sein, z.B. '2 + 2' oder '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Fehler bei der Auswertung des Ausdrucks: {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Sucht im Internet nach aktuellen Informationen zu einer gegebenen Anfrage."
tools = [calculator, search]
# Ein Prompt-Modell erstellen (beachten Sie den Platzhalter `chat_history`)
prompt = ChatPromptTemplate.from_messages(
[
("system", "Sie sind ein hilfreicher KI-Assistent. Erinnern Sie sich an frühere Interaktionen und beantworten Sie die Fragen so genau wie möglich."),
MessagesPlaceholder(variable_name="chat_history"), # Hier wird das Gedächtnis injiziert
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# Gedächtnis initialisieren
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Den Agenten erstellen
agent = create_openai_functions_agent(llm, tools, prompt)
# Den Agenten-Executor erstellen und das Gedächtnis übergeben
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
# Den Agenten mit Gedächtnis ausführen
print("--- Ausführung des Agenten mit Gedächtnis ---")
print("\nBenutzer: Was ist die Hauptstadt von Spanien?")
result1 = agent_executor.invoke({"input": "Was ist die Hauptstadt von Spanien?"})
print("Agent:", result1["output"])
print("\nBenutzer: Wie hoch ist die Bevölkerung?")
result2 = agent_executor.invoke({"input": "Wie hoch ist die Bevölkerung?"})
print("Agent:", result2["output"])
print("\nBenutzer: Und wie hoch ist die Bevölkerung der Hauptstadt von Frankreich?")
result3 = agent_executor.invoke({"input": "Und wie hoch ist die Bevölkerung der Hauptstadt von Frankreich?"})
print("Agent:", result3["output"])In diesem Beispiel erinnert sich der Agent an „Spanien“ aus der ersten Runde und an „Hauptstadt von Frankreich“ aus der dritten, was ihm ermöglicht, relevante Antworten zu geben, ohne das Land explizit neu formulieren zu müssen. Der memory_key="chat_history" stellt sicher, dass der Inhalt des Gedächtnisses korrekt dem MessagesPlaceholder(variable_name="chat_history") in unserem Prompt-Modell zugeordnet wird.
Andere Gedächtnisarten
Verwandte Artikel
- Im Herzen effektiver API-Designmuster
- Streaming-APIs für KI-Agenten
- Qdrant vs FAISS: Welches für Startups
🕒 Published: