Multiagentensystem

Dieses Kapitel führt in das Multi-Agent-System ein.

Ein Multi-Agent-System erfüllt komplexe Aufgaben durch die Zusammenarbeit mehrerer Agenten.

Dies ist eine Schlüsseltechnologie für den Aufbau großer KI-Systeme, die komplexe Funktionen ermöglicht, die ein einzelner Agent nicht erreichen kann.


Grundlagen der Multi-Agent-Architektur

Die zentralen Herausforderungen eines Multi-Agent-Systems umfassen drei Aspekte.

Arbeitsteilung: Wie Aufgaben sinnvoll auf verschiedene Agenten verteilt werden.

Kommunikation: Wie Informationen zwischen Agenten weitergegeben werden.

Koordination: Wie sichergestellt wird, dass die Aktionen mehrerer Agenten konsistent und effizient sind.

Grundlegende Architekturmuster

Hierarchische Architektur

Die hierarchische Architektur verwendet eine Baumstruktur, bei der ein Master-Agent für die Planung verantwortlich ist.

Der Master-Agent (Orchestrator) ist für die Aufgabenzerlegung und Ergebnisintegration verantwortlich.

Der Sub-Agent (Subagent) ist für die Ausführung spezifischer Aufgaben verantwortlich.

Orchestrator (调度者)
    |
    +-- Agent A (专家A)
    +-- Agent B (专家B)
    +-- Agent C (专家C)

Peer-to-Peer-Architektur

In der Peer-to-Peer-Architektur sind alle Agenten gleichberechtigt und kommunizieren und arbeiten direkt zusammen.

Geeignet für Szenarien, in denen Agenten häufige Peer-to-Peer-Interaktion benötigen.

Agent A <--> Agent B
    |           |
    v           v
Agent C <--> Agent D

Rollenteilung und Zusammenarbeit

Ein effektives Multi-Agenten-System erfordert klare Rollendefinitionen.

Jeder Agent sollte über eigene Fachkenntnisse und einen eigenen Verantwortungsbereich verfügen.

Kollaborationsmechanismen stellen sicher, dass mehrere Agenten koordiniert zusammenarbeiten können.

Übliche Rollendefinitionen

Planer: Komplexe Aufgaben zerlegen und Ausführungspläne formulieren.

Ausführender: Tools aufrufen und spezifische Operationen ausführen.

Prüfer: Ergebnisse bewerten und Verbesserungsvorschläge liefern.

Koordinator: Kommunikation und Aufgabenverteilung zwischen Agenten verwalten.

Code-Implementierung

Grundlegende Implementierung eines Multi-Agenten-Systems

class Agent:
    """
Basis-Agent-Klasse
Jeder Agent hat seine eigene Rolle, Tools und Ausführungslogik
    """

   
    def __init__(self, role, llm, tools):
        # Name der Rolle des Agenten
        self.role = role
        # Zugehöriges Sprachmodell
        self.llm = llm
        # Liste der verfügbaren Tools
        self.tools = tools
   
    def execute(self, task, context=None):
        """
Aufgabe ausführen
:param task: Aufgabenbeschreibung
:param context: Kontextinformation
:return: Ausführungsergebnis
        """

        # Prompt erstellen
        prompt = self.build_prompt(task, context)
       
        # Antwort generieren
        response = self.llm.generate(prompt)
       
        # Wenn ein Tool-Aufruf erforderlich ist
        if response.needs_tool_call:
            return self.execute_tool(response)
       
        return response.content
   
    def build_prompt(self, task, context):
        """Prompt des Agenten aufbauen"""
        return f"Rolle: {self.role}\nAufgabe: {task}\nKontext: {context}"
   
    def execute_tool(self, response):
        """Tool-Aufruf ausführen"""
        tool_name = response.tool_name
        tool_input = response.tool_input
       
        # Das entsprechende Tool aus der Tools-Liste finden
        tool = self.get_tool(tool_name)
       
        # Das Tool ausführen
        return tool.execute(tool_input)


class MultiAgentSystem:
    """
Multi-Agenten-Kollaborationssystem
Verantwortlich für die Verwaltung der Zusammenarbeit zwischen mehreren Agenten
    """

   
    def __init__(self, agents, coordinator):
        # Agenten-Dictionary, Schlüssel ist der Rollenname
        self.agents = {a.role: a for a in agents}
        # Koordinator-Agent
        self.coordinator = coordinator
   
    def solve(self, task):
        """
Komplexe Aufgaben lösen
Durch die Koordination mehrerer Agenten zur Zusammenarbeit abgeschlossen
        """

        # Schritt 1: Der Koordinator analysiert die Aufgabe und bestimmt, welche Agenten teilnehmen müssen
        plan = self.coordinator.decompose(task)
       
        # Schritt 2: Aufgaben an die entsprechenden Agenten verteilen
        results = {}
        for role, subtask in plan.subtasks.items():
            # Den Agenten mit der entsprechenden Rolle abrufen
            agent = self.agents.get(role)
            if agent:
                # Die Teilaufgabe ausführen
                results[role] = agent.execute(subtask)
       
        # Schritt 3: Der Koordinator integriert die Ergebnisse
        final_result = self.coordinator.integrate(results)
       
        return final_result


class CoordinatorAgent:
    """Koordinator-Agent"""
   
    def __init__(self, llm):
        self.llm = llm
   
    def decompose(self, task):
        """
Die Aufgabe zerlegen
Analysiere die Aufgabe, bestimme, welche Agenten benötigt werden und wie die Arbeit aufgeteilt wird
        """

        prompt = f"""
Analysiere die folgende Aufgabe, zerlege sie in Teilaufgaben und weise sie geeigneten Agenten zu.

Aufgabe: {task}

Bitte gib aus:
1. Welche Agenten werden benötigt (Rollen)
2. Welche Teilaufgabe jeder Agent verantwortet
3. Abhängigkeiten zwischen Teilaufgaben

Ausgabeformat: JSON
"""

        response = self.llm.generate(prompt)
        return Plan.parse(response)
   
    def integrate(self, results):
        """
Die Ergebnisse mehrerer Agenten integrieren
        """

        prompt = f"""
Integriere die Ausführungsergebnisse der folgenden Agenten, um die endgültige Antwort zu generieren.

Ergebnisliste:
{results}

Bitte integriere und gib das endgültige Ergebnis aus.
"""

        return self.llm.generate(prompt)

AutoGen-Framework

AutoGen ist ein von Microsoft entwickeltes Multi-Agenten-Programmierframework.

Es bietet eine prägnante API zum Erstellen von Multi-Agenten-Dialogsystemen.

AutoGen vereinfacht die Komplexität der Entwicklung von Multi-Agenten-Systemen erheblich.

Kernkonzepte

AssistantAgent: Ein intelligenter Assistenz-Agent, der Tools aufrufen kann.

UserProxyAgent: Repräsentiert Benutzerverhalten, kann Code ausführen und Tool-Aufrufe durchführen.

GroupChat: Unterstützt Gruppenchat-Zusammenarbeit zwischen mehreren Agenten.

GroupChatManager: Verwaltet Agenteninteraktionen im Gruppenchat.

Codebeispiele

Grundlegende Verwendung von AutoGen

# Das autogen-Framework importieren
import autogen
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# ==================== LLM konfigurieren ====================
# Ein Konfigurationswörterbuch erstellen
llm_config = {
    "model": "gpt-4",
    "api_key": "your-api-key",  # In der tatsächlichen Verwendung aus Umgebungsvariablen lesen
    "temperature": 0.7
}

# ==================== Einen einzelnen Agenten erstellen ====================
# Einen Assistenten-Agenten erstellen
assistant = AssistantAgent(
    name="assistant",
    system_message="""
Du bist ein hilfreicher Python-Programmierassistent.
Du kannst Benutzern helfen, Code zu schreiben, zu debuggen und zu optimieren.
    """
,
    llm_config=llm_config
)

# Erstelle einen Benutzer-Proxy-Agenten
# human_input_mode="NEVER" bedeutet, dass keine manuelle Eingabe erforderlich ist.
# max_consecutive_auto_reply=10 bedeutet bis zu 10 aufeinanderfolgende automatische Antworten.
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10
)

# ==================== Einzelagenten-Konversation ====================
# Starte die Konversation
user_proxy.initiate_chat(
    assistant,
    message="Hilf mir, einen Quicksort-Algorithmus zu schreiben"
)

# ==================== Multi-Agenten-Gruppenchat ====================
# Erstelle mehrere Agenten
coder = AssistantAgent(
    name="coder",
    system_message="Du bist ein Experte für Python-Programmierung und dafür verantwortlich, Code zu schreiben.",
    llm_config=llm_config
)

reviewer = AssistantAgent(
    name="reviewer",
    system_message="Du bist ein Experte für Code-Reviews und dafür verantwortlich, die Codequalität zu überprüfen.",
    llm_config=llm_config
)

# Erstelle einen Gruppenchat
group_chat = GroupChat(
    agents=[coder, reviewer],
    messages=[],
    max_round=10  # Bis zu 10 Gesprächsrunden
)

# Erstelle einen Gruppenchat-Manager
manager = GroupChatManager(
    groupchat=group_chat,
    llm_config=llm_config
)

# Starte den Gruppenchat
user_proxy.initiate_chat(
    manager,
    message="Schreibe einen Quicksort-Algorithmus und überprüfe den Code"
)

Komplexeres AutoGen-Beispiel

AutoGen-Tool-Aufruf

import autogen
from autogen import AssistantAgent, UserProxyAgent

# Definiere die Tool-Liste
# Diese Tools werden in der Tool-Liste des Agenten registriert
tools = [
    {
        "name": "calculate",
        "description": "Mathematische Berechnungen durchführen",
        "parameters": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "Der mathematische Ausdruck zur Berechnung, z. B. '2+3*5'"
                }
            },
            "required": ["expression"]
        }
    },
    {
        "name": "search_web",
        "description": "Webinformationen suchen",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Suchbegriff"
                }
            },
            "required": ["query"]
        }
    }
]

# Erstelle einen Agenten mit Tool-Aufruf-Fähigkeit
assistant = AssistantAgent(
    name="assistant",
    system_message="""
Du bist ein hilfreicher Assistent.
Wenn du Berechnungen durchführen oder Informationen nachschlagen musst, kannst du relevante Tools aufrufen.
    """
,
    llm_config={
        "model": "gpt-4",
        "api_key": "your-api-key"
    },
    tools=tools  # Tools registrieren
)

# Erstelle einen Benutzer-Proxy
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER"
)

# Starte die Konversation, der Agent ruft automatisch Tools auf
user_proxy.initiate_chat(
    assistant,
    message="Was ist (15 + 25) * 2?"
)

# Beispielantwort:
# Der Agent könnte antworten:
# "Lass es mich berechnen: (15 + 25) * 2 = 40 * 2 = 80"
# Oder rufe direkt das calculate-Tool auf, um das Ergebnis zu erhalten

A2A- und MCP-Protokolle

Multiagentensysteme erfordern standardisierte Kommunikationsprotokolle.

A2A und MCP sind zwei wichtige Protokollstandards.

A2A (Agent-zu-Agent)-Protokoll

Das A2A-Protokoll definiert ein Standardformat für die Kommunikation zwischen Agenten.

Es unterstützt Agentenerkennung, Aufgabenzusammenarbeit und Zustandssynchronisation.

Kernfunktionen

Agentenerkennung: Agenten können die Fähigkeiten und Dienste anderer Agenten entdecken.

Aufgabenzusammenarbeit: Mehrere Agenten können gemeinsam komplexe Aufgaben erledigen.

Zustandssynchronisation: Agenten können Zustandsinformationen untereinander synchronisieren.

MCP (Model Context Protocol)-Protokoll

MCP ist ein offenes Standardprotokoll.

Es ermöglicht KI-Modellen, sich sicher mit externen Tools und Datenquellen zu verbinden.

MCP ist ein Standardprotokoll für die Tool-Integration, ähnlich der Rolle einer USB-Schnittstelle.

Kernkomponenten

Host: Die Hostumgebung zum Ausführen von KI-Anwendungen.

Client: Der Client, der Verbindungen mit MCP-Servern herstellt.

Server: Der Server, der Tools und Ressourcen bereitstellt.

Beispiel für eine MCP-Tool-Definition

MCP-Tool-Definition

{
    "name": "filesystem",
"description": "Werkzeug für Dateisystemoperationen",
    "version": "1.0.0",
    "tools": [
        {
            "name": "read_file",
"description": "Dateiinhalt lesen",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
"description": "Dateipfad, erforderlich"
                    },
                    "encoding": {
                        "type": "string",
"description": "Dateikodierung, optional, Standard ist utf-8"
                    }
                },
                "required": ["path"]
            }
        },
        {
            "name": "write_file",
"description": "Dateiinhalt schreiben",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
"description": "Dateipfad, erforderlich"
                    },
                    "content": {
                        "type": "string",
"description": "Dateiinhalt, erforderlich"
                    }
                },
                "required": ["path", "content"]
            }
        },
        {
            "name": "list_directory",
"description": "Verzeichnisinhalt auflisten",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
"description": "Verzeichnispfad"
                    }
                }
            }
        }
    ],
    "resources": [
        {
            "uri": "file://config",
"description": "Konfigurationsdatei"
        }
    ]
}

Hinweis: A2A und MCP lösen unterschiedliche Probleme. A2A adressiert die Kommunikation zwischen Agenten, während MCP die Verbindung zwischen Agenten und externen Tools adressiert. Beide können zusammen verwendet werden, um ein vollständiges Multiagentensystem aufzubauen.


Master-Slave-Agentenmuster

Der Master-Subagent-Modus ist ein klassisches Multiagenten-Architekturmuster.

Der Master-Agent (Orchestrator) ist für die Aufgabenzerlegung und Ergebnisintegration verantwortlich.

Der Subagent (Subagent) ist für die Ausführung spezifischer Aufgaben verantwortlich.

Geeignete Szenarien

Szenarien, in denen Aufgaben klar in unabhängige Teilaufgaben zerlegt werden können.

Szenarien, in denen Agenten mit unterschiedlicher Expertise zusammenarbeiten müssen.

Komplexe Workflows, die zentrale Koordination und Steuerung erfordern.

Code-Implementierung

Implementierung des Master-Slave-Agentenmusters

class OrchestratorAgent:
    """
Haupt-Orchestrierungs-Agent (Master-Agent)
Verantwortlich für Aufgabenzerlegung, -zuweisung und Ergebnisintegration
    """

   
    def __init__(self, llm, subagents):
        # Sprachmodell
        self.llm = llm
        # Subagent-Wörterbuch
        self.subagents = {a.role: a for a in subagents}
   
    def handle_request(self, request):
        """
Benutzeranfragen verarbeiten
Vollständiger Orchestrierungsablauf
        """

        # ==================== Analysephase ====================
        # Analysiere die Anfrage, um festzustellen, ob eine Zusammenarbeit mehrerer Agenten erforderlich ist
        plan = self.llm.plan(request)
       
        if len(plan.subtasks) == 1:
            # Einzelne Aufgabe, direkt an den entsprechenden Agenten weiterleiten
            target_role = plan.target_role
            return self.subagents[target_role].execute(plan.subtasks[0])
       
        # ==================== Multi-Agenten-Kollaborationsphase ====================
        # Aufgabenwarteschlange erstellen
        task_queue = self.create_task_queue(plan.subtasks)
       
        # Abgeschlossene Ergebnisse speichern
        results = []
       
        # Verarbeitungsschleife, bis alle Aufgaben abgeschlossen sind
        while task_queue:
            # Aufgaben abrufen, die parallel ausgeführt werden können
            parallel_tasks = self.get_parallel_tasks(task_queue)
           
            # Parallel ausführen
            parallel_results = self.execute_in_parallel(parallel_tasks)
            results.extend(parallel_results)
           
            # Aufgabenwarteschlange aktualisieren
            # Abhängigkeiten behandeln, abgeschlossene Aufgaben entfernen, neue Aufgaben hinzufügen
            task_queue = self.update_queue(task_queue, parallel_results)
       
        # ==================== Integrationsphase ====================
        # Alle Ergebnisse integrieren
        return self.integrate_results(results)
   
    def create_task_queue(self, subtasks):
        """Aufgabenwarteschlange erstellen"""
        return TaskQueue(subtasks)
   
    def get_parallel_tasks(self, task_queue):
        """
Aufgaben abrufen, die parallel ausgeführt werden können
Aufgaben mit Abhängigkeiten ausschließen
        """

        ready_tasks = []
        for task in task_queue.tasks:
            # Prüfen, ob alle Aufgabenabhängigkeiten erfüllt sind
            if all(dep in task_queue.completed for dep in task.dependencies):
                ready_tasks.append(task)
        return ready_tasks
   
    def execute_in_parallel(self, tasks):
        """Mehrere Aufgaben parallel ausführen"""
        import concurrent.futures
       
        results = []
        with concurrent.futures.ThreadPoolExecutor() as executor:
            # Alle Aufgaben übermitteln
            future_to_task = {
                executor.submit(self.execute_task, task): task
                for task in tasks
            }
           
            # Ergebnisse sammeln
            for future in concurrent.futures.as_completed(future_to_task):
                task = future_to_task[future]
                try:
                    result = future.result()
                    results.append(result)
                except Exception as e:
                    results.append(TaskResult(task=task, error=str(e)))
       
        return results
   
    def execute_task(self, task):
        """Eine einzelne Aufgabe ausführen"""
        agent = self.subagents.get(task.role)
        if not agent:
            return TaskResult(task=task, error=f"Unbekannte Rolle: {task.role}")
       
        return agent.execute(task.description)
   
    def update_queue(self, task_queue, completed_results):
        """Aufgabenwarteschlange aktualisieren"""
        # Abgeschlossene Aufgaben als abgeschlossen markieren
        for result in completed_results:
            task_queue.completed.add(result.task.id)
       
        # Abgeschlossene Aufgaben entfernen
        task_queue.tasks = [
            t for t in task_queue.tasks
            if t.id not in task_queue.completed
        ]
       
        return task_queue
   
    def integrate_results(self, results):
        """
Ergebnisse von mehreren Agenten integrieren
Endgültige Antwort generieren
        """

        prompt = f"""
Integrieren Sie die Ausführungsergebnisse der folgenden Agenten und generieren Sie eine endgültige Antwort.

Ergebnisliste:
{results}

Bitte zu einer vollständigen, zusammenhängenden Antwort zusammenführen.
"""

        return self.llm.generate(prompt)


class Subagent:
    """Von der Agent-Basisklasse"""
   
    def __init__(self, role, llm, tools=Keine):
        self.role = role
        self.llm = llm
        self.tools = tools or []
   
    def execute(self, task):
        """Spezifische Logik zum Ausführen der Aufgabe"""
        raise NotImplementedError

Vor- und Nachteile des Master-Slave-Musters

Vorteile Nachteile
Klare Struktur, einfach zu verstehen und zu implementieren Der Master-Agent wird zum Single Point of Failure
Zentralisierte Koordination, einfach zu steuern Der Master-Agent kann zu einem Leistungsengpass werden
Geeignet für gut geschichtete Aufgaben Geringe Flexibilität, schwierig dynamisch anzupassen
Komfortables Debugging, jede Teilaufgabe kann nachverfolgt werden Nicht geeignet für Szenarien mit häufiger Peer-to-Peer-Interaktion

Kapitelzusammenfassung

Dieses Kapitel führt in die Kernkonzepte und Implementierungsmethoden von Multi-Agenten-Systemen ein.

Grundlagen der Multi-Agenten-ArchitekturEinführung in zwei grundlegende Modi: hierarchische Architektur und Peer-Architektur.

Rollenteilung und ZusammenarbeitVerbessert die Systemeffizienz durch klare Rollendefinitionen.

AutoGen-FrameworkBietet ein Programmierframework, das die Multi-Agenten-Entwicklung vereinfacht.

A2A- und MCP-ProtokolleSie sind Standardprotokolle für Agentenkommunikation und Tool-Integration.

Master-Slave-AgentenmusterGeeignet für komplexe Aufgaben mit klarer hierarchischer Struktur.

Die Wahl der geeigneten Multi-Agenten-Architektur hängt vom konkreten Szenario ab.

Für einfache Szenarien reicht ein einzelner Agent aus, um die Anforderungen zu erfüllen.

Für komplexe Szenarien ist es notwendig, ein geeignetes Architekturmuster basierend auf den Merkmalen der Aufgabe zu wählen.

Weitere Erweiterungen