KI-Agenten werden immer nützlicher, da sie über das reine Beantworten von Fragen hinausgehen und Aufgaben von Anfang bis Ende übernehmen. LangChain Deep Agents bieten mehr Kontrolle und Flexibilität, indem sie Agenten helfen, Arbeit in Teilschritte zu zerlegen, verschiedene Tools zu nutzen, Informationen zu verwalten und kleinere Aufgaben zu koordinieren. Das macht es einfacher, Agenten zu erstellen, die reale Workflows ohne ständige Anleitung bewältigen können. Sehen wir uns an, wie LangChain Deep Agents funktionieren und was sich damit bauen lässt.
Was sind LangChain Deep Agents?
LangChain Deep Agents sind ein Agenten-Framework, das auf den Kernbausteinen von LangChain und der LangGraph-Runtime aufbaut. Sie erweitern gängige Agenten-Workflows um integrierte Fähigkeiten wie Dateisystemzugriff, Delegation an Subagenten, Planung, Gedächtnis und Human-in-the-Loop-Unterstützung. Deep Agents nutzen eine Agentenschleife, die Reasoning, Tool-Aufrufe und iterative Ausführung kombiniert, wodurch sie sich für komplexe Aufgaben eignen, die mehrere Schritte, große Mengen an Kontext und koordinierte Workflows erfordern.
Im Gegensatz zu einfachen Agenten, die Tools hauptsächlich in einer simplen Schleife aufrufen, bieten Deep Agents zusätzliche Infrastruktur für den Umgang mit lang laufenden Aufgaben. Sie können Dateien verwalten, Arbeit an spezialisierte Subagenten delegieren, Kontext über komplexe Workflows hinweg beibehalten und bei Bedarf menschliches Eingreifen ermöglichen. Diese integrierten Fähigkeiten verringern den Aufwand an individueller Entwicklungsarbeit beim Aufbau fortgeschrittener Agentensysteme.
Wie LangChain Deep Agents funktionieren
Wenn ein Deep Agent eine Aufgabe erhält, analysiert er die Anfrage und plant die Schritte, die zur Erledigung nötig sind. Anschließend nutzt er verfügbare Tools wie Suche, Codeausführung oder Dateisystemoperationen, um Informationen zu sammeln und Aktionen durchzuführen.
Während der Ausführung verwalten Deep Agents den Kontext durch Lesen und Schreiben von Dateien. Anstatt alle Zwischenergebnisse im Konversationsverlauf zu speichern, können sie große Informationsmengen extern ablegen und bei Bedarf abrufen. Dieser Ansatz hilft Agenten, längere Workflows zu bewältigen und dabei die Einschränkungen durch die Größe des Kontextfensters zu verringern.
Bei komplexen Aufgaben, die mehrere Arbeitsbereiche umfassen, können Deep Agents bestimmte Teilaufgaben an spezialisierte Subagenten delegieren. Jeder Subagent konzentriert sich auf ein festgelegtes Ziel und gibt relevante Ergebnisse an den Hauptagenten zurück. Der Hauptagent kombiniert dann die Ausgaben der Subagenten, abgerufene Informationen und gespeicherte Dateien, um eine vollständige und kohärente Antwort zu erstellen.
Mit Funktionen wie Planung, Tool-Nutzung, Dateisystemverwaltung, Zusammenarbeit von Subagenten und menschlicher Aufsicht bilden LangChain Deep Agents eine Grundlage für den Aufbau leistungsfähigerer KI-Systeme, die mehrstufige Aufgaben aus der realen Welt bewältigen können.
Kernfähigkeiten von Deep Agents: Planung, Tools und Ausführung
Deep Agents können Aufgaben bewältigen, die mehrere Schritte, Entscheidungen und Aktionen erfordern. Ihre Kernfunktionen helfen ihnen, die Arbeit zu planen, die richtigen Tools zu nutzen und jeden Schritt effizient und mit weniger manuellem Aufwand abzuschließen. Schauen wir uns diese Fähigkeiten im Detail an:
Aufgabenplanung
Die Aufgabenplanung ermöglicht es Agenten, während der Ausführung eine strukturierte Aufgabenliste zu erstellen und zu verwalten. Statt ein komplexes Ziel als einzelne Anweisung zu behandeln, können Agenten es in kleinere Schritte unterteilen, den Fortschritt verfolgen und den Aufgabenstatus während des gesamten Workflows aktualisieren.
Wann Planung eingesetzt werden sollte
Lange oder komplizierte mehrstufige Aufgaben
Aufgaben, die von expliziter Fortschrittsverfolgung und strukturierter Ausführung profitieren
Benutzeroberflächen, die den Fortschritt aus dem Agentenstatus streamen
So aktivieren Sie es
Übergeben Sie TodoListMiddleware an den Parameter middleware. Dies gibt dem Agenten ein write_todos-Tool zur Pflege einer strukturierten Aufgabenliste mit Statusverfolgung (pending, in_progress, completed).
from deepagents import create_deep_agent
from deepagents.middleware import TodoListMiddleware
agent = create_deep_agent(
model="your-model",
middleware=[TodoListMiddleware()],
)Aufgaben werden im Agentenstatus persistiert und geben Agenten damit eine leichtgewichtige Planungsebene zur Organisation lang laufender Arbeit.
Virtuelle Dateisystem-Tools
Deep Agents bieten ein konfigurierbares virtuelles Dateisystem, das auf austauschbaren Backends basiert: In-Memory-Status, lokaler Datenträger, LangGraph-Store, kombiniertes Routing oder benutzerdefinierte Backends mit Berechtigungsregeln.
Integrierte Dateisystem-Tools
| Tool | Beschreibung |
|---|---|
ls | Listet Dateien in einem Verzeichnis mit Metadaten auf (Größe, Änderungszeitpunkt) |
read_file | Liest Dateiinhalte mit Zeilennummern; unterstützt Offset/Limit für große Dateien; liefert zudem multimodale Inhaltsblöcke für Bilder, Video, Audio und Dokumente |
write_file | Erstellt eine neue Datei oder überschreibt eine vorhandene |
edit_file | Führt exakte Zeichenkettenersetzungen in Dateien durch (mit globalem Ersetzungsmodus) |
delete | Löscht eine Datei oder ein Verzeichnis rekursiv |
glob | Findet Dateien, die einem Muster entsprechen (z. B. **/*.py) |
grep | Durchsucht Dateiinhalte mit mehreren Ausgabemodi |
execute | Führt Shell-Befehle in der Umgebung aus (nur bei Sandbox-Backends) |
Unterstützte multimodale Erweiterungen
Bild:
.png,.jpg,.jpeg,.gif,.webp,.heic,.heifVideo:
.mp4,.mpeg,.mov,.avi,.flv,.mpg,.webm,.wmv,.3gppAudio:
.wav,.mp3,.aiff,.aac,.ogg,.flacDokument:
.pdf,.ppt,.pptx
Dateisystemberechtigungen
Der Harness unterstützt deklarative Berechtigungsregeln, die festlegen, welche Dateien und Verzeichnisse der Agent lesen oder schreiben darf. Die Regeln werden von oben nach unten ausgewertet, wobei die erste passende Regel entscheidet.
from deepagents import create_deep_agent
agent = create_deep_agent(
model="anthropic:your-model",
permissions=[
{"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
{"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
],
)from deepagents import create_deep_agent
agent = create_deep_agent(
model="anthropic:your-model",
permissions=[
{"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
{"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
],
)So können Sie Agents auf bestimmte Verzeichnisse beschränken, sensible Dateien schützen und Subagents einen engeren Zugriff als den übergeordneten Agent geben.
Zugriff auf Tools einschränken
Sie können nur eine Teilmenge der Dateisystem-Tools freigeben, indem Sie eine tools-Zulassungsliste an FilesystemMiddleware übergeben. read_file muss immer enthalten sein.
from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware
# Read-only agent
agent = create_deep_agent(
model="your-model",
middleware=[
FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
],
)from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware
# Read-only agent
agent = create_deep_agent(
model="your-model",
middleware=[
FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
],
)Subagents (Delegation)
Der Harness enthält ein integriertes task-Tool, mit dem der Haupt-Agent temporäre Subagents für isolierte, langlaufende, mehrstufige oder parallele Aufgaben erstellen kann.
Wesentliche Merkmale
Frischer Kontext: Jeder Aufruf erzeugt eine neue Agent-Instanz mit eigenem Kontext
Autonome Ausführung: Der Subagent läuft eigenständig bis zum Abschluss
Einmalige Übergabe: Er liefert einen einzigen abschließenden Bericht an den Haupt-Agent zurück
Konfigurierbare Strategie: Verwenden Sie den Standard-Subagent
general-purposeoder definieren Sie eigene SubagentsKontexteffizienz: Aufwendige Teilaufgaben bleiben isoliert und werden zu einem kompakten Ergebnis verdichtet
Subagents deaktivieren
Um einen Agent ohne das task-Tool auszuführen, deaktivieren Sie den automatisch hinzugefügten Subagent über das Harness-Profil und übergeben Sie keine synchronen Subagents über subagents=. Versuchen Sie nicht, SubAgentMiddleware über excluded_middleware zu entfernen – dies wird absichtlich abgelehnt.
Tool-Calling-Funktionen
Deep Agents unterstützen drei Kategorien von Tools:
Benutzerdefinierte Funktionen & LangChain-Tools
Übergeben Sie benutzerdefinierte Funktionen oder LangChain-Tools direkt über den Parameter tools=:
MCP (Model Context Protocol)
Deep Agents unterstützen MCP vollständig und ermöglichen so den Zugriff auf Datenbanken, APIs, Dateisysteme und mehr über eine einheitliche Schnittstelle.
Codeausführung
Sandbox-Backends: Stellen ein
execute-Tool für Shell-Befehle in einer isolierten Umgebung bereitInterpreter: Fügen ein
eval-Tool hinzu, das JavaScript in einer gekapselten QuickJS-Laufzeitumgebung ausführt, für leichtgewichtige programmierbare Schichten
Wenn diese Fähigkeiten zusammenkommen, wird das Sprachmodell, das den Agent antreibt, zu einem wichtigen Bestandteil des Gesamtaufbaus. Ein leistungsfähiges Modell kann Deep Agents helfen, Anweisungen zu verstehen, Aufgaben durchdacht anzugehen und die verfügbaren Tools besser zu nutzen. Die Kimi API kann diese Modellebene bereitstellen und ist damit ein naheliegender nächster Schritt für den Aufbau leistungsfähigerer Deep-Agent-Workflows.
Kimi API in 6 Schritten mit LangChain Deep Agents verbinden
Ein leistungsfähiges Modell gibt Ihrem Deep Agent das Sprachverständnis und die Denkfähigkeit, die für die effektive Bearbeitung von Aufgaben nötig sind. Die Kimi API kann diese Fähigkeiten bereitstellen, während der Agent mit Tools arbeitet, Aufgaben verwaltet und komplexe Anweisungen verarbeitet. Mit der Modellebene an ihrem Platz lässt sich der Aufbau ganz natürlich fortsetzen, indem die Kimi API mit LangChain Agents verbunden wird. So verbinden Sie die Kimi API mit LangChain Deep Agents:
Schritt 1: Kimi API-Key erhalten
Melden Sie sich bei der Kimi API-Plattform an und erstellen Sie einen neuen API-Key. Kopieren Sie den Key und speichern Sie ihn sicher, da Sie ihn in Ihrer Deep-Agents-Konfiguration hinzufügen müssen. Dieser API-Key authentifiziert Ihre Anfragen und ermöglicht es LangChains Deep Agents, über die API auf Kimi-Modelle zuzugreifen.
Schritt 2: Umgebungsvariablen festlegen
Legen Sie Ihren Kimi API-Key als Umgebungsvariable fest. Die Kimi API nutzt den Moonshot-API-Endpunkt, konfigurieren Sie also folgende Variable:
export MOONSHOT_API_KEY="your-api-key-here"export MOONSHOT_API_KEY="your-api-key-here"Die Basis-URL der API lautet:
https://api.moonshot.ai/v1https://api.moonshot.ai/v1Schritt 3: Abhängigkeiten installieren
Installieren Sie Deep Agents und die erforderlichen LangChain-Abhängigkeiten:
pip install deepagents langchain-openai
``````bash
pip install deepagents langchain-openaiDa die Kimi API OpenAI-kompatibel ist, ermöglicht langchain-openai LangChain, sich über die OpenAI-kompatible Schnittstelle mit Kimi-Modellen zu verbinden.
Wenn Sie Ihrem Deep Agent Websuche-Funktionen hinzufügen möchten, können Sie optional Tavily installieren:
pip install tavily-pythonpip install tavily-pythonNachdem Sie einen Tavily API-Key über die Tavily-Plattform erstellt haben, legen Sie ihn als Umgebungsvariable fest:
export TAVILY_API_KEY="your-tavily-api-key"export TAVILY_API_KEY="your-tavily-api-key"Tavily benötigen Sie nur, wenn Sie Ihrem Agent Websuche-Tools hinzufügen möchten.
Schritt 4: Deep Agent mit Kimi API konfigurieren
Da die Kimi API mit dem OpenAI-API-Format kompatibel ist, können Sie sie über init_chat_model mit LangChain Deep Agents verbinden.
Das folgende Beispiel erstellt einen einfachen, von Kimi angetriebenen Deep Agent. Sie können ihn optional um Tools wie eine Websuche erweitern.
Einfacher, von Kimi angetriebener Deep Agent
Websuche-Funktionen hinzufügen (optional)
Um die Websuche zu aktivieren, verbinden Sie ein Suchtool wie Tavily:
Mit dieser Konfiguration können Deep Agents Kimi als Reasoning-Modell nutzen und gleichzeitig über Tavily auf externe Suchfunktionen zugreifen.
Schritt 5: Ihren von Kimi angetriebenen Deep Agent ausführen
Sobald Ihr Deep Agent mit Kimi konfiguriert ist, führen Sie den Agent aus, um zu testen, wie er mit Aufgaben und Tool-Aufrufen umgeht.
result = agent.invoke(
{"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)
print(result["messages"][-1].content)result = agent.invoke(
{"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)
print(result["messages"][-1].content)Schritt 6: LangSmith-Tracing aktivieren (optional)
LangSmith-Tracing hilft Ihnen, die Ausführung des Agents zu überwachen, einschließlich Tool-Aufrufen, Zwischenschritten und Modellantworten.
Aktivieren Sie das Tracing mit folgenden Umgebungsvariablen:
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"Nutzen Sie LangSmith, wenn Sie tiefere Einblicke in Agent-Workflows, Debugging oder Leistungsanalysen benötigen.
Vorteile der Nutzung der Kimi API
Die Verbindung der Kimi API mit Deep Agents kann komplexe Workflows leistungsfähiger und leichter zu verwalten machen. Die Kombination verleiht Agents stärkere Denkfähigkeiten und ermöglicht ihnen gleichzeitig, Tools zu nutzen, Dateien zu handhaben und mehrere Aufgaben zu bearbeiten. Werfen wir einen Blick auf die wichtigsten Vorteile dieser Konfiguration:
Bessere Denkfähigkeit und Aufgabenausführung des Agents
Kimi-Modelle bieten starkes Sprachverständnis und Denkfähigkeiten, die Deep Agents helfen, komplexe Anweisungen zu analysieren, Aufgaben zu zerlegen und präzisere Antworten zu erzeugen. So können Agents mehrstufige Workflows effektiver und mit weniger manueller Anleitung bewältigen.
Leistungsfähigere KI-Workflows aufbauen
Mit der an Deep Agents angebundenen Kimi API können Entwickler die Modellfähigkeiten von Kimi mit Tools, Dateisystemen und von LangChain unterstützten externen Integrationen kombinieren. So können Agents Aufgaben wie Recherche, Dokumentenverarbeitung, Codeanalyse und Datenverarbeitung innerhalb eines einheitlichen Workflows ausführen.
Komplexe Aufgaben mit autonomen Agents skalieren
Von Kimi angetriebene Deep Agents können lang laufende Aufgaben verwalten, indem sie Pläne erstellen, Tools einsetzen und Teilaufgaben bei Bedarf delegieren. Dadurch lassen sich KI-Anwendungen leichter aufbauen, die komplexe Workflows abschließen können, während sich wiederkehrende manuelle Arbeitsschritte reduzieren.
Fazit
Der Aufbau zuverlässiger KI-Agenten beginnt mit der Wahl der richtigen Grundlage für komplexe Workflows. LangChain Deep Agents bieten die Werkzeuge und die Struktur, die nötig sind, um Agenten zu erstellen, die planen, Tools einsetzen, Kontext verwalten und mehrstufige Aufgaben mit weniger manuellem Aufwand bewältigen können. Mit dem richtigen Modell und der passenden Konfiguration können Entwickler fortgeschrittene Agenten-Ideen in praktische Anwendungen umsetzen. Durch die Integration der Kimi API können Sie Ihre Deep-Agent-Workflows zusätzlich mit starken Reasoning- und Long-Context-Fähigkeiten erweitern. Entdecken Sie die Kimi API und erfahren Sie, was Sie mit KI-Agenten bauen können.