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
"""
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
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
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
"""
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