Deep Brokers-Tutorial: LangGraph für intelligentere KI

Stellen Sie sich eine KI vor, die nicht nur Ihre Fragen beantwortet, sondern vorausdenkt, Aufgaben aufschlüsselt, eigene TODOs erstellt und sogar Unteragenten hervorbringt, um die Arbeit zu erledigen. Das ist das Versprechen von Deep Brokers. KI-Agenten nutzen bereits die Fähigkeiten von LLMs eine Stufe höher, und heute werfen wir einen Blick auf Deep Brokers, um zu sehen, wie sie diese Stufe noch weiter steigern können. Deep Brokers baut darauf auf LangGrapheine Bibliothek, die speziell für die Erstellung von Agenten entwickelt wurde, die komplexe Aufgaben bewältigen können. Werfen wir einen tieferen Blick auf Deep Brokers, verstehen ihre Kernfunktionen und nutzen dann die Bibliothek, um unsere eigenen KI-Agenten zu erstellen.

Deep Brokers

LangGraph bietet Ihnen eine graphbasierte Laufzeit für zustandsbehaftete Workflows, Sie müssen jedoch immer noch Ihre eigene Planung, Kontextverwaltung oder Aufgabenzerlegungslogik von Grund auf erstellen. DeepAgents (basierend auf LangGraph) bündelt sofort einsatzbereite Planungstools, auf einem virtuellen Dateisystem basierenden Speicher und Subagenten-Orchestrierung.

Sie können DeepAgents als Standalone-Model verwenden deepagents Bibliothek. Es umfasst Planungsfunktionen, kann Subagenten erzeugen und verwendet ein Dateisystem für die Kontextverwaltung. Es kann auch mit kombiniert werden LangSmith für den Einsatz und die Überwachung. Die hier erstellten Agenten verwenden standardmäßig das Modell „claude-sonnet-4-5-20250929“, das jedoch angepasst werden kann. Bevor wir mit der Erstellung der Agenten beginnen, wollen wir uns mit den Kernkomponenten befassen.

Kernkomponenten

• Detaillierte Systemaufforderungen – Der Deep-Agent verwendet eine Systemeingabeaufforderung mit detaillierten Anweisungen und Beispielen.
• Planungstools – Deep Brokers verfügen über ein integriertes Device für die Planung, das TODO-Pay attention-Verwaltungstool wird von den Agenten dafür verwendet. Dies hilft ihnen, auch bei der Ausführung einer komplexen Aufgabe konzentriert zu bleiben.
• Unteragenten – Subagenten werden für die delegierten Aufgaben erstellt und in Kontextisolation ausgeführt.
• Dateisystem – Virtuelles Dateisystem für die Kontextverwaltung und Speicherverwaltung. KI-Agenten verwenden hier Dateien als Werkzeug, um Kontext in den Speicher auszulagern, wenn das Kontextfenster voll ist.

Aufbau eines Deep Agent

Lassen Sie uns nun einen Recherche-Agenten erstellen, der die „Deepagents“-Bibliothek verwendet, der Tavily für die Websuche verwendet und über alle Komponenten eines Deep-Agenten verfügt.

Notiz: Wir werden das Tutorial in Google Colab durchführen.

Voraussetzungen

Sie benötigen einen OpenAI-Schlüssel für diesen Agenten, den wir erstellen werden. Sie können auch einen anderen Modellanbieter wie Gemini/Claude verwenden. Holen Sie sich Ihren OpenAI-Schlüssel von der Plattform: https://platform.openai.com/api-keys

Einen Tavily-API-Schlüssel für die Websuche erhalten Sie auch hier: https://app.tavily.com/residence

Öffnen Sie ein neues Notizbuch in Google Colab und fügen Sie die geheimen Schlüssel hinzu:

Speichern Sie die Schlüssel als OPENAI_API_KEY, TAVILY_API_KEY für die Demo und vergessen Sie nicht, den Pocket book-Zugriff zu aktivieren.

Lesen Sie auch: Gemini API-Dateisuche: Der einfache Weg, RAG zu erstellen

Anforderungen

!pip set up deepagents tavily-python langchain-openai 

Wir installieren diese Bibliotheken, die zum Ausführen des Codes erforderlich sind.

Importe und API-Setup

import os 
from deepagents import create_deep_agent 
from tavily import TavilyClient 
from langchain.chat_models import init_chat_model 
from google.colab import userdata 
 

# Set API keys 
TAVILY_API_KEY=userdata.get("TAVILY_API_KEY") 
os.environ("OPENAI_API_KEY")=userdata.get("OPENAI_API_KEY") 

Wir speichern die Tavily-API in einer Variablen und die OpenAI-API in der Umgebung.

Definieren der Instruments, des Subagenten und des Agenten

# Initialize Tavily shopper 
tavily_client = TavilyClient(api_key=TAVILY_API_KEY) 
 
# Outline internet search instrument 
def internet_search(question: str, max_results: int = 5) -> str: 
   """Run an online search to search out present data""" 
   outcomes = tavily_client.search(question, max_results=max_results) 
   return outcomes  

# Outline a specialised analysis sub-agent 
research_subagent = { 
   "title": "data-analyzer", 
   "description": "Specialised agent for analyzing information and creating detailed experiences", 
   "system_prompt": """You might be an knowledgeable information analyst and report author. 
   Analyze data completely and create well-structured, detailed experiences.""", 
   "instruments": (internet_search), 
   "mannequin": "openai:gpt-4o", 
}  

# Initialize GPT-4o-mini mannequin 
mannequin = init_chat_model("openai:gpt-4o-mini") 
# Create the deep agent 
# The agent routinely has entry to: write_todos, read_todos, ls, read_file, 
# write_file, edit_file, glob, grep, and activity (for subagents) 
agent = create_deep_agent( 
   mannequin=mannequin, 
   instruments=(internet_search),  # Passing the instrument 
   system_prompt="""You're a thorough analysis assistant. For this activity: 
   1. Use write_todos to create a activity listing breaking down the analysis 
   2. Use internet_search to assemble present data 
   3. Use write_file to save lots of your findings to /research_findings.md 
   4. You'll be able to delegate detailed evaluation to the data-analyzer subagent utilizing the duty instrument 
   5. Create a closing complete report and put it aside to /final_report.md 
   6. Use read_todos to test your progress 

   Be systematic and thorough in your analysis.""", 
   subagents=(research_subagent), 
) 

Wir haben ein Device für die Websuche definiert und dieses an unseren Agenten übergeben. Für diese Demo verwenden wir „gpt-4o-mini“ von OpenAI. Sie können dies auf jedes Modell ändern.

Beachten Sie auch, dass wir keine Dateien erstellt oder etwas für das Dateisystem definiert haben, das zum Auslagern des Kontexts und der Aufgabenliste erforderlich ist. Diese sind in „create_deep_agent()“ bereits vorgefertigt und es hat Zugriff darauf.

Laufende Inferenz

# Analysis question 
research_topic = "What are the most recent developments in AI brokers and LangGraph in 2025?"  

print(f"Beginning analysis on: {research_topic}n") 
print("=" * 70)  

# Execute the agent 
outcome = agent.invoke({ 
   "messages": ({"function": "person", "content material": research_topic}) 
}) 

print("n" + "=" * 70) 
print("Analysis accomplished.n") 

Notiz: Die Ausführung des Agenten kann eine Weile dauern.

Anzeigen der Ausgabe

# Agent execution hint 
print("AGENT EXECUTION TRACE:") 
print("-" * 70) 
for i, msg in enumerate(outcome("messages")): 
   if hasattr(msg, 'kind'): 
       print(f"n({i}) Kind: {msg.kind}") 
       if msg.kind == "human": 
           print(f"Human: {msg.content material}") 
       elif msg.kind == "ai": 
           if hasattr(msg, 'tool_calls') and msg.tool_calls: 
               print(f"AI instrument calls: {(tc('title') for tc in msg.tool_calls)}") 
           if msg.content material: 
               print(f"AI: {msg.content material(:200)}...") 
       elif msg.kind == "instrument": 
           print(f"Device '{msg.title}' outcome: {str(msg.content material)(:200)}...") 

# Closing AI response 
print("n" + "=" * 70) 
final_message = outcome("messages")(-1) 
print("FINAL RESPONSE:") 
print("-" * 70) 
print(final_message.content material) 

# Recordsdata created 
print("n" + "=" * 70) 
print("FILES CREATED:") 
print("-" * 70) 
if "information" in outcome and outcome("information"): 
   for filepath in sorted(outcome("information").keys()): 
       content material = outcome("information")(filepath) 
       print(f"n{'=' * 70}") 
       print(f"{filepath}") 
       print(f"{'=' * 70}") 
       print(content material) 
else: 
   print("No information discovered.") 

print("n" + "=" * 70) 
print("Evaluation full.") 

Wie wir sehen, hat der Agent gute Arbeit geleistet, er hat ein virtuelles Dateisystem verwaltet, nach mehreren Iterationen eine Antwort gegeben und battle der Meinung, dass es sich um einen „Deep-Agent“ handeln sollte. Aber es gibt Spielraum für Verbesserungen in unserem System, schauen wir uns diese im nächsten System an.

Mögliche Verbesserungen in unserem Agenten

Wir haben einen einfachen Deep Agent entwickelt, aber Sie können sich selbst herausfordern und etwas viel Besseres entwickeln. Hier sind einige Dinge, die Sie tun können, um diesen Agenten zu verbessern:

1. Nutzen Sie das Langzeitgedächtnis – Der Deep-Agent kann Benutzereinstellungen und Suggestions in Dateien (/recollections/) speichern. Dies wird dem Agenten helfen, bessere Antworten zu geben und aus den Gesprächen eine Wissensbasis aufzubauen.
2. Dateisystem steuern – Standardmäßig werden die Dateien in einem virtuellen Zustand gespeichert. Sie können dies mithilfe des „FilesystemBackend“ von deepagents.backends auf einem anderen Backend oder einer lokalen Festplatte speichern
3. Durch Verfeinerung der Systemansagen – Sie können mehrere Eingabeaufforderungen testen, um herauszufinden, welche für Sie am besten funktioniert.

Abschluss

Wir haben unsere Deep Brokers erfolgreich aufgebaut und können nun sehen, wie KI-Agenten können die LLM-Funktionen noch weiter steigern, indem sie LangGraph zur Bewältigung der Aufgaben verwenden. Mit integrierter Planung, Subagenten und einem virtuellen Dateisystem verwalten sie TODOs, Kontext und Recherche-Workflows reibungslos. Deep Brokers sind großartig, aber denken Sie auch daran, dass es nicht empfehlenswert ist, sie zu verwenden, wenn eine Aufgabe einfacher ist und von einem einfachen Agenten oder LLM erledigt werden kann.

Häufig gestellte Fragen

Leidenschaftlich für Technologie und Innovation, Absolvent des Vellore Institute of Know-how. Derzeit arbeite ich als Knowledge Science Trainee mit Schwerpunkt auf Knowledge Science. Großes Interesse an Deep Studying und generativer KI, begierig darauf, modernste Techniken zur Lösung komplexer Probleme und zur Entwicklung wirkungsvoller Lösungen zu erforschen.