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, wie wir mit Technologie interagieren. Im Mittelpunkt dieser Transformation stehen KI-Agenten – Softwareeinheiten, die so konzipiert sind, dass sie Aufgaben mit Hilfe der Leistungsfähigkeit von Large Language Models (LLMs) und externen Werkzeugen ausführen. Auch wenn das Konzept komplex klingt, haben Frameworks wie LangChain den Entwicklungsprozess erheblich vereinfacht, sodass die Erstellung von Agenten einem breiteren Publikum zugänglich ist.
Als API-Architektin und KI-Integrationsberaterin habe ich das unglaubliche Potenzial gut gestalteter KI-Agenten aus erster Hand erlebt. Sie können komplexe Arbeitsabläufe automatisieren, personalisierte Unterstützung bieten und neue Möglichkeiten für Unternehmen und Einzelpersonen erschließen. Dieser praktische Leitfaden führt Sie durch den Prozess der Erstellung solider KI-Agenten mit der LangChain-API, beginnend mit einem Verständnis der Kernkomponenten bis hin zur Implementierung praktischer, realer 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 anzugehen.
Verstehen von KI-Agenten und der Rolle von LangChain
Bevor wir den Code erkunden, lassen Sie uns klären, was ein KI-Agent ist und warum LangChain ein unverzichtbares Werkzeug zu ihrer Konstruktion ist. Ein KI-Agent ist ein System, das ein LLM als sein „Gehirn“ nutzt, um zu entscheiden, welche Maßnahmen ergriffen werden sollen. Im Gegensatz zu einem einfachen LLM-Aufruf, der eine einzelne Antwort generiert, kann ein Agent in einem mehrstufigen Argumentationsprozess agieren:
- Wahrnehmen: Verstehen der Eingabe des Nutzers oder des aktuellen Zustands.
- Überlegen: Bestimmen des besten Handlungswegs basierend auf seinem Verständnis und den verfügbaren Werkzeugen.
- Handeln: Ausführen einer oder mehrerer Aktionen mithilfe externer Werkzeuge.
- Lernen (optional, aber mächtig): Einbeziehen von Rückmeldungen, um die zukünftige Leistung zu verbessern.
LangChain bietet das Gerüst, das notwendig ist, um diese anspruchsvollen Agenten zu bauen. Es bietet eine strukturierte Möglichkeit, LLMs mit verschiedenen Datenquellen und Rechenwerkzeugen zu verbinden, sodass sie über einfache Textgenerierung hinausgehen können. Man kann LangChain als das Betriebssystem für Ihren KI-Agenten betrachten, das das Framework für seine Intelligenz, sein Gedächtnis und die Fähigkeit zur Interaktion mit der Welt bereitstellt.
Wichtige Komponenten eines LangChain-Agenten
Um einen Agenten mit LangChain zu erstellen, arbeiten Sie hauptsächlich mit diesen Kernkomponenten:
- Large Language Model (LLM): Der Intelligenzkern. Dies könnte OpenAIs GPT-Modelle, Anthropics Claude oder Open-Source-Alternativen sein. Das LLM verarbeitet Eingaben, denkt nach und gibt Entscheidungen aus.
- Werkzeuge: Funktionen, die der Agent aufrufen kann, um mit externen Systemen zu interagieren oder spezifische Berechnungen durchzuführen. Beispiele sind das Suchen im Web, Abfragen einer Datenbank, Aufrufen eines Rechners oder das Interagieren mit einer benutzerdefinierten API.
- Toolkits: Sammlungen verwandter Werkzeuge, die für spezifische Anwendungsfälle entworfen wurden (z. B. ein „Wikipedia-Toolkit“ oder ein „CSV-Agenten-Toolkit“).
- Agent Executor: Der Laufzeitprozess, der die Aktionen des Agenten orchestriert. Er nimmt die Entscheidungen des LLMs entgegen, führt die gewählten Werkzeuge aus und füttert die Ergebnisse zurück an das LLM für weiterführendes Nachdenken.
- Gedächtnis: Ermöglicht es dem Agenten, Informationen aus vorherigen Interaktionen zu behalten, was kohärente Gespräche über mehrere Runden und kontextbewusste Entscheidungsfindung ermöglicht.
- Prompt-Vorlagen: Definieren, wie die Eingaben der Nutzer und andere Informationen für das LLM formatiert werden, und leiten dessen Argumentationsprozess.
Einrichten Ihrer Umgebung und erste Schritte
Bevor Sie Code für einen Agenten schreiben, stellen Sie sicher, dass Ihre Python-Umgebung bereit ist. Sie benötigen Python 3.8+ und die LangChain-Bibliothek, sowie alle LLM-Anbieter, die Sie verwenden möchten.
Installation
Installieren Sie LangChain und einen LLM-Anbieter (z. B. OpenAI):
pip install langchain langchain-openai
pip install python-dotenv # Zur sicheren Verwaltung von API-KeysVerwalten Sie Ihre API-Keys sicher. Erstellen Sie eine .env-Datei im Stammverzeichnis Ihres Projekts:
OPENAI_API_KEY="your_openai_api_key_here"Laden Sie diese dann in Ihrem Python-Skript:
import os
from dotenv import load_dotenv
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")Grundlegende LLM-Interaktion
Um Ihr Setup zu bestätigen, machen wir einen einfachen LLM-Aufruf:
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Verwendung eines leistungsstarken Modells mit deterministischer Ausgabe
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. Lassen Sie uns nun unser LLM mit Werkzeugen ausstatten.
Werkzeuge für Ihren KI-Agenten erstellen
Werkzeuge sind die Hände und Füße des Agenten, die es ihm ermöglichen, mit der Außenwelt zu interagieren. LangChain macht das Definieren von Werkzeugen ganz einfach. Jedes Werkzeug sollte einen klaren Namen, eine Beschreibung und eine Funktion haben, die die Aktion ausführt.
Beispiel: Ein einfaches Taschenrechner-Werkzeug
Lassen Sie uns ein Werkzeug erstellen, das einfache mathematische Berechnungen durchführen kann. Während LLMs einfache Mathematik beherrschen, sind externe Werkzeuge für komplexe Berechnungen zuverlässiger.
from langchain.tools import tool
@tool
def calculator(expression: str) -> str:
"""Bewertet einen mathematischen Ausdruck und gibt das Ergebnis zurück.
Die Eingabe sollte ein String 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}"
# Sie können das Werkzeug direkt testen
print(calculator.invoke("10 * 5 + 3"))Beachten Sie den @tool-Decorator. Dieser konvertiert Ihre Funktion automatisch in ein LangChain-Werkzeug. Der Docstring ist entscheidend, da er als Beschreibung des Werkzeugs dient, die das LLM nutzt, um zu verstehen, wann und wie es verwendet werden kann.
Beispiel: Ein Web-Suchwerkzeug (unter Verwendung von Tavily)
Die meisten leistungsstarken Agenten benötigen Zugang zu aktuellen Informationen. Ein Web-Suchwerkzeug ist grundlegend. Wir verwenden Tavily, eine Such-API, die speziell für RAG (Retrieval Augmented Generation) und Anwendungsfälle von Agenten entwickelt wurde.
Installieren Sie zuerst Tavily und setzen Sie Ihren API-Key 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-Suchwerkzeug
search = TavilySearchResults(max_results=3) # Holen Sie sich die besten 3 Ergebnisse
# Sie können auch den Namen und die Beschreibung bei Bedarf anpassen
# search.name = "web_search"
# search.description = "Durchsucht das Web nach Informationen."
# Testen Sie das Suchwerkzeug
print(search.invoke("LangChain-Agenten-Tutorial"))Durch die Definition dieser Werkzeuge geben wir unserem Agenten die Fähigkeiten, die er benötigt, um sein Wissen über seine Trainingsdaten hinaus zu erweitern und Berechnungen genau durchzuführen.
Erstellen Sie Ihren ersten LangChain-Agenten
Mit unserem LLM und den Werkzeugen bereit können wir nun unseren ersten LangChain-Agenten zusammenstellen. Wir verwenden die Methode „create_openai_functions_agent“, die eine bequeme Möglichkeit bietet, Agenten zu erstellen, die die Funktionalitäten von OpenAI nutzen.
Schritte zum Erstellen des Agenten
- Definieren Sie Ihr LLM: Das Gehirn Ihres Agenten.
- Definieren Sie Ihre Werkzeuge: Die Fähigkeiten, die Ihr Agent hat.
- Erstellen Sie eine Prompt-Vorlage: Leiten Sie das LLM, wie es sich verhalten soll.
- Erstellen Sie den Agenten: Kombinieren Sie LLM, Werkzeuge und Prompt.
- Erstellen Sie den Agent Executor: Die Laufzeit, 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
# Lade Umgebungsvariablen
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# 1. Definiere LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# 2. Definiere Tools
@tool
def calculator(expression: str) -> str:
"""Bewertet einen mathematischen Ausdruck und gibt das Ergebnis zurück.
Der Eingabetext sollte einen gültigen mathematischen Ausdruck enthalten, 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 = "Durchsucht das Internet nach aktuellen Informationen zu einer gegebenen Anfrage."
tools = [calculator, search]
# 3. Erstelle eine Prompt-Vorlage
prompt = ChatPromptTemplate.from_messages(
[
("system", "Du bist ein hilfreicher KI-Assistent. Beantworte Fragen so genau wie möglich."),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# 4. Erstelle den Agenten
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Erstelle den Agenten-Executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Führe den Agenten aus
# print("--- Agentenlauf 1 (Einfache Berechnung) ---")
# result1 = agent_executor.invoke({"input": "Was ist 12345 * 6789?", "chat_history": []})
# print(result1["output"])
# print("\n--- Agentenlauf 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--- Agentenlauf 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 du verbose=True im AgentExecutor setzt, siehst du den Denkprozess des Agenten: welche Tools er in Betracht zieht, welches er auswählt, die Eingabe, die er dem Tool bereitstellt, und die Ausgabe des Tools. Dies ist äußerst nützlich zum Debuggen und zum Verständnis, wie dein Agent denkt.
Das Verständnis der Prompt-Vorlage
system: Legt die allgemeine Persona und die Anweisungen für den Agenten fest.MessagesPlaceholder(variable_name="chat_history"): Hier werden frühere Dialoge eingefügt, wodurch Gedächtnis ermöglicht wird.human: Die aktuelle Benutzereingabe.MessagesPlaceholder(variable_name="agent_scratchpad"): Hier werden die internen Gedankengänge des Agenten und die Ergebnisse der Tools während einer einzelnen Invocation gespeichert, sodass das LLM Schritt für Schritt logisch denken kann.
Speicher und Zustand zu deinem KI-Agenten hinzufügen
Ein wahrhaft intelligenter Agent benötigt Gedächtnis, um den Kontext über mehrere Dialogrunden hinweg aufrechtzuerhalten. LangChain bietet verschiedene Gedächtnistypen, die es deinem Agenten ermöglichen, sich an frühere Interaktionen zu erinnern.
Warum Gedächtnis wichtig ist
- Kohärenz: Agenten können sich auf frühere Aussagen und Fragen beziehen.
- Personalisierung: Agenten können sich Benutzerpräferenzen oder frühere Interaktionen merken.
- Effizienz: Vermeidet es, Informationen zu wiederholen oder um Klärung bereits gegebener Details zu bitten.
Implementierung von ConversationBufferMemory
ConversationBufferMemory ist ein einfacher, aber effektiver Gedächtnistyp, der alle vorhergehenden 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 # Speicher importieren
# Lade Umgebungsvariablen
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# LLM und Tools (gleich 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 Eingabetext sollte einen gültigen mathematischen Ausdruck enthalten, 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 = "Durchsucht das Internet nach aktuellen Informationen zu einer gegebenen Anfrage."
tools = [calculator, search]
# Erstelle eine Prompt-Vorlage (achte auf den `chat_history` Platzhalter)
prompt = ChatPromptTemplate.from_messages(
[
("system", "Du bist ein hilfreicher KI-Assistent. Merke dir frühere Interaktionen und beantworte 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)
# Erstelle den Agenten
agent = create_openai_functions_agent(llm, tools, prompt)
# Erstelle den Agenten-Executor und übergebe das Gedächtnis
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
# Führe den Agenten mit Gedächtnis aus
print("--- Agentenlauf 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 sieht es mit der Bevölkerung der Hauptstadt von Frankreich aus?")
result3 = agent_executor.invoke({"input": "Und wie sieht es mit der Bevölkerung der Hauptstadt von Frankreich aus?"})
print("Agent:", result3["output"])In diesem Beispiel erinnert sich der Agent an “Spanien” aus dem ersten Dialog und an “Frankreichs Hauptstadt” aus dem dritten, sodass er relevante Antworten geben kann, ohne dass das Land erneut explizit genannt werden muss. Der memory_key="chat_history" stellt sicher, dass der Inhalt des Gedächtnisses korrekt mit dem MessagesPlaceholder(variable_name="chat_history") in unserer Prompt-Vorlage verknüpft ist.
Andere Gedächtnistypen
Verwandte Artikel
- Das Herz effektiver API-Designmuster erfassen
- AI-Agent-Streaming-APIs
- Qdrant vs FAISS: Welches für Startups
🕒 Published: