Startseite / Artikel

Mehr-Agenten-KI-Systeme mit LangChain: Aufbau eines

Mehr-Agenten-KI-Systeme mit LangChain: Was ein Mehr-Agenten-System ist, wann mehrere Agenten einen einzelnen LLM-Agenten übertreffen und wie man Rollen erstellt und verbindet.

Verlag: REACTAPP.TOP11 Min. Lesezeit2636 Wörter

Quellen: Multi-Agent AI Systems with LangChain: Building an Orchestrator That Delegates Work

Die folgenden Notizen skizzieren einen praktischen Weg zu „Multi-Agenten-KI-Systeme mit LangChain: Entwicklung eines Orchestrators zur Delegation von Aufgaben“. Der Schwerpunkt liegt auf Verträgen, Überprüfungen sowie Code-Platzhaltern statt auf motivierenden Erläuterungen. Während der Übersichtsphase sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsame Umgebungen übergeht.

1. Was ist ein Multi-Agentensystem?

„1 Was ist eine Stufe?“ funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie einen gelungenen Transkriptbeispiel, einen Fehlerfall sowie die Rollback-Anmerkung, bevor Sie den Umfang erweitern. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Graphen prüfen können. Halten Sie den Zustand des Graphen flach und typisiert. Verschachtelte Datenblöcke verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Wiederaufnehmen der Verarbeitung.

User
  |
  v
Single Agent
  |
  +-- Search
  +-- Analyze
  +-- Calculate
  +-- Generate Report
                         User
                           |
                           v
                    +--------------+
                    | Main Agent   |
                    | Orchestrator |
                    +------+-------+
                           |
              +------------+------------+
              |                         |
              v                         v
       +-------------+           +-------------+
       | Math Agent  |           | Search Agent|
       +-------------+           +-------------+
              |                         |
          square()                  search()

2. Warum mehrere Agenten verwenden?

Der Ansatz „2 Warum – Mehrstufige Vorgehensweise“ funktioniert am besten, wenn er als messbare Struktur betrachtet wird. Erfassen Sie einen idealen Ablauf, einen Fehlerfall sowie die Notizen zur Rücksetzung, bevor Sie den Umfang erweitern. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollpunkte sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Halten Sie den Zustand der Graphen einfach und typisiert – verschachtelte Strukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Unterbrechungen beim Fortsetzen der Verarbeitung.

Database queries
Security analysis
Documentation search
Report generation
"I have a database question → call database agent."
"I have a security question → call security agent.""I need documentation → call documentation agent."

Einzelner Agent

Die Single-Agent-Phase funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Halten Sie den Zustand der Graphen flach und typisiert. Verschachtelte Strukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Störungen nach Unterbrechungen.

                    LLM
                     |
       +-------------+-------------+
       |             |             |
    Database       Search       Security
       |             |             |
       +-------------+-------------+

Die Single-Agent-Phase funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen zu Laufzeiten sowie Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Gebühren, wenn der Ablauf von einer Demo in gemeinsame Umgebungen wechselt.

Mehre Agenten

Für die Multi-Agenten-Phase sollten Eingaben, der Verantwortliche für einen Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablauf verfolgen zu müssen. Menschliche Freigabe sollte für Kanten erforderlich sein, die Geld ausgeben oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.

                      Main Agent
                    /     |      \
                   /      |       \
                  v       v        v
             DB Agent  Search   Security
                        Agent      Agent

3. Beispiel: Zwei spezialisierte Agenten

Für die 3. spezialisierte Phase von Beispiel Zwei sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Setzen Sie menschliche Freigabe für Schritte voraus, die Geld ausgeben oder Produktionsdaten ändern. Kompilierzeitbezogene Verbindungen bedeuten noch keine vollständige Geschäftsabwicklung.

Calculate the square of a number
Calculate the square root of a number
@tool
def square_root(x: float) -> float:
    """Calculate the square root of a number"""
    return x ** 0.5
@tool
def square(x: float) -> float:
    """Calculate the square of a number"""
    return x ** 2
subagent_square_root = create_agent(
    model=llm,
    tools=[square_root]
)
subagent_square = create_agent(
    model=llm,
    tools=[square]
)
square_root()
square()

4. Der wichtige Teil: Agenten in Tools umwandeln

Zur Phase „4 The Important Part“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren. Authentifizieren Sie am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Tragertoken stellt keine Trennlinie zwischen verschiedenen Nutzungseinheiten dar. Zur Phase „4 The Important Part“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt.

@tool
def call_subagent_square_root(x: float) -> float:
    """Call subagent 1 in order to calculate
    the square root of a number"""
    response = subagent_square_root.invoke(
        {
            "messages": [
                HumanMessage(
                    content=f"Calculate the square root of {x}"
                )
            ]
        }
    )    return response["messages"][-1].content
@tool
def call_subagent_square(x: float) -> float:
    """Call subagent 2 in order to calculate
    the square of a number"""
    response = subagent_square.invoke(
        {
            "messages": [
                HumanMessage(
                    content=f"Calculate the square of {x}"
                )
            ]
        }
    )    return response["messages"][-1].content
Main Agent
     |
     +-- call_subagent_square_root()
     |
     +-- call_subagent_square()

5. Erstellung des Orchestrators

Beim Bearbeiten der 5 Phasen zur Erstellung des Orchestrators sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Operator ohne das Durchlesen des gesamten Graphen überprüfen können. Legen Sie nach aufwändigen Schritten einen Checkpoint an. Das Wiederaufnehmen sollte keine doppelte Abrechnung für denselben LLM-Aufruf verursachen, wenn ein Operator einen späteren Knoten erneut ausführt.

main_agent = create_agent(
    model=llm,
    tools=[
        call_subagent_square_root,
        call_subagent_square
    ],
    system_prompt=
        "You are a helpful assistant who can call "
        "subagents to calculate the square root or "
        "square of a number."
)
                         User
                           |
                           |
                           v
                  +----------------+
                  |   Main Agent    |
                  |  Orchestrator   |
                  +-------+--------+
                          |
                 Tool selection
                    /          \
                   /            \
                  v              v
        +----------------+  +----------------+
        | Square Root    |  | Square         |
        | Subagent       |  | Subagent       |
        +-------+--------+  +-------+--------+
                |                  |
                v                  v
          square_root()        square()

6. Was passiert, wenn der Benutzer eine Frage stellt?

Beim Bearbeiten der Phase „6 What Happens When“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf sowie den Notfallweg. Wiederholte Versuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen. Legen Sie nach teuren Schritten Zwischenchecks an – das Resume sollte keine doppelten Gebühren für denselben LLM-Aufruf erheben, wenn ein Operator einen späteren Knoten erneut versucht.

What is the square root of 456?
response = main_agent.invoke(
    {
        "messages": [
            HumanMessage(
                content="What is the square root of 456?"
            )
        ]
    }
)
call_subagent_square_root(x=456)
Calculate the square root of 456
square_root()
21.3541565
The square root of 456 is approximately 21.35.
User
 |
 | "What is the square root of 456?"
 v
Main Agent
 |
 | selects call_subagent_square_root
 v
Square Root Subagent
 |
 | invokes square_root(456)
 v
21.3541565
 |
 v
Main Agent
 |
 v
"The square root of 456 is approximately 21.35."

7. Wo passt der LLM hinein?

Beim Bearbeiten der Phase „7 Where Does the“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für unnötige Ressourcenverbrauch. Beim Bearbeiten der Phase „7 Where Does the“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo in gemeinsame Umgebungen wechselt.

llm = ChatOllama(
    model="llama3.2:latest",
    base_url="http://localhost:11434",
    temperature=0,
)
                Ollama / Llama
                     |
          +----------+----------+
          |                     |
          v                     v
     Main Agent            Subagents
     Orchestrator          Specialized
Main Agent       → powerful reasoning model
Security Agent   → security-specialized modelCoding Agent     → coding modelSimple Agent     → smaller/cheaper model

8. Multi-Agent bedeutet nicht mehrere LLMs

Der Ansatz „8 Multi-Agent Does Not“ funktioniert am besten, wenn er als messbare Struktur betrachtet wird. Erfassen Sie ein erfolgreiches Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf – Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den Betreiber ohne Durchsicht des gesamten Systems prüfen können. Legen Sie Obergrenzen für die Anzahl der Tokens pro Runde und pro Sitzung fest; agierende Tools erweitern den Kontext oft stark, wodurch harte Grenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen führen.

Model A
  |
  +-- Agent 1
  +-- Agent 2
  +-- Agent 3
Model A → Agent 1
Model B → Agent 2
Model C → Agent 3
Agent =
    Model
  + Instructions
  + Tools
  + State/Context
  + Decision-making

9. Warum nicht einfach alle Tools einem Agenten geben?

Die 9-Why-Nicht-Nur-Methode funktioniert am besten, wenn sie als messbarer Ansatz betrachtet wird. Erfassen Sie einen „goldenen“ Transkriptbeispiel, einen Fehlerfall sowie die Notizen zur Rücksetzung, bevor Sie den Umfang erweitern. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Versuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Stellen Sie Tools mit eng definierten Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

                         Orchestrator
                              |
          +-------------------+-------------------+
          |                   |                   |
          v                   v                   v
    Database Agent       Security Agent      Research Agent
          |                   |                   |
       PostgreSQL          SIEM/Security       Web/MCP
                              |
                              v
                       Report Generator

10. Multi-Agent- gegen sequenziellen Workflow

Die 10 Multi-Agent vs Sequential-Phase funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Halten Sie den Graphenzustand strukturiert und typisiert – verschachtelte Datenstrukturen verbergen, welcher Knoten welches Feld geschrieben hat, und führen zu Störungen bei Unterbrechungen. Die 10 Multi-Agent vs Sequential-Phase funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Gebühren, wenn der Ablauf von einer Demo in gemeinsame Umgebungen wechselt.

Sequenzieller Workflow

Für die Phase des sequenziellen Workflows sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablauf durchzulesen. Menschliche Freigabe sollte für Schritte erforderlich sein, die Geld ausgeben oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.

Step 1
  ↓
Step 2
  ↓
Step 3
  ↓
Step 4
Retrieve documents
      ↓
Analyze documents
      ↓
Generate report
      ↓
Send email

Orchestriertes Mehr-Agenten-System

Zur Phase des orchestrierten Multi-Agenten-Systems sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholungsversuche, menschliche Überprüfungen und die Handhabung von Fehlnachrichten gehören zum Produkt selbst, nicht zu späteren Optimierungen. Setzen Sie menschliche Freigabe für Schritte voraus, die Geld ausgeben oder Produktionsdaten ändern. Eine Verkabelung zur Kompilierzeit bedeutet nicht automatisch vollständige Geschäftsabdeckung.

                     Orchestrator
                    /     |      \
                   /      |       \
               Agent A  Agent B  Agent C
Workflow = predefined control flow
Multi-Agent =
LLM-driven delegation between specialized agents

11. Produktionsarchitektur

In der 11. Phase der Produktionsarchitektur sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden, bevor Code geändert wird. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Es ist besser, kleine, testbare Einheiten statt umfangreicher Skripte zu verwenden. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System.

User
                           |
                           v
                 +-------------------+
                 | Orchestrator      |
                 | Agent             |
                 +---------+---------+
                           |
          +----------------+----------------+
          |                |                |
          v                v                v
    +-----------+    +-----------+    +-----------+
    | Research  |    | Security  |    | Database  |
    | Agent     |    | Agent     |    | Agent     |
    +-----+-----+    +-----+-----+    +-----+-----+
          |                |                |
          v                v                v
       Web/MCP          SIEM/APIs       PostgreSQL
          |                |                |
          +----------------+----------------+
                           |
                           v
                  +----------------+
                  | Final Response |
                  | / Report Agent |
                  +----------------+
Research Agent
    → web search
    → document retrieval
    → RAG
Security Agent
    → SIEM
    → vulnerability database
    → security APIsDatabase Agent
    → SQL
    → analyticsReport Agent
    → summarize
    → format
    → email

12. Wichtige Erkenntnisse

1. Spezialisieren Sie Agenten

Agent → one domain / capability

2. Verpacken Sie Subagenten als Tools

Main Agent
    |
    +-- Subagent Tool

3. Lassen Sie den Orchestrator delegieren

4. Halten Sie die Schnittstellen einfach

Tool name
Description
Arguments
Result

5. Beginnen Sie einfach

AI Orchestrator
                         |
        +----------------+----------------+
        |                |                |
    Research          Coding          Security
      Agent            Agent            Agent
        |                |                |
       MCP             GitHub          Security APIs
       RAG             Tools           SIEM

Fazit

User
  ↓
Main Agent
  ↓
Tool representing a subagent
  ↓
Specialized Subagent
  ↓
Domain-specific Tool
  ↓
Result
  ↓
Main Agent
  ↓
User

Operative Kontrollliste