Skip to content

AutoGen und MCP: Aufbau leistungsstarker Multi-Agent-Systeme

Einführung

In der heutigen schnell voranschreitenden Welt der künstlichen Intelligenz haben sich die Anwendungen großer Sprachmodelle (LLM) von einfachen Dialogsystemen zu komplexen Agentensystemen entwickelt. Microsofts AutoGen-Framework führt als leistungsstarkes Multi-Agent-Entwicklungstool die Innovation in diesem Bereich an. Dieser Artikel untersucht eingehend eine Schlüsselkomponente des AutoGen-Frameworks - das Model Context Protocol (MCP) - und wie es zur Entwicklung leistungsstarker Multi-Agent-Systeme genutzt werden kann.

AutoGen-Einführung

AutoGen ist ein von Microsoft entwickeltes Open-Source-Framework, das darauf abzielt, den Aufbau von Multi-Agent-Systemen basierend auf großen Sprachmodellen zu vereinfachen. Es bietet eine Reihe flexibler Tools und APIs, die es Entwicklern ermöglichen, Agentennetzwerke zu erstellen, die miteinander kooperieren können, wobei jeder Agent spezifische Aufgaben ausführen oder spezifische Rollen übernehmen kann.

Die Kernvorteile von AutoGen sind:

  1. Multi-Agent-Kooperation: Unterstützt komplexe Interaktionen und Kooperationen zwischen mehreren Agenten
  2. Tool-Nutzungsfähigkeiten: Agenten können verschiedene Tools nutzen, um ihre Fähigkeiten zu erweitern
  3. Flexible Gesprächsabläufe: Unterstützt anpassbare Gesprächsabläufe und Steuerungslogik
  4. Skalierbarkeit: Einfache Integration neuer Modelle und Tools

Was ist MCP (Model Context Protocol)?

Das Model Context Protocol (MCP) ist ein offener Standard, der darauf abzielt, die Interaktion zwischen AI-Modellen und externen Tools und Services zu vereinheitlichen. Im AutoGen-Framework spielt MCP die Rolle einer Brücke, die Agenten mit externen Tools verbindet.

Die Kernidee von MCP besteht darin, ein standardisiertes Protokoll bereitzustellen, das es AI-Modellen (wie großen Sprachmodellen) ermöglicht, auf konsistente Weise mit verschiedenen externen Services und Tools zu interagieren. Diese Tools können lokale Kommandozeilen-Tools, Remote-API-Services oder sogar andere AI-Systeme sein.

Schlüsseleigenschaften von MCP

  1. Standardisierte Schnittstelle: Bietet einheitliche Tool-Aufruf- und Antwortformate
  2. Mehrere Kommunikationswege: Unterstützt Standard-Input/Output (STDIO) und Server-Sent Events (SSE) und andere Kommunikationsmethoden
  3. Tool-Discovery-Mechanismus: Ermöglicht dynamische Erkennung und Nutzung verfügbarer Tools
  4. Session-Management: Unterstützt die Aufrechterhaltung von Session-Zuständen für Tool-Aufrufe

MCP-Implementierung in AutoGen

Im AutoGen-Framework wird MCP-Unterstützung durch das autogen_ext.tools.mcp-Modul bereitgestellt. Dieses Modul bietet verschiedene Komponenten, die es Entwicklern ermöglichen, MCP-kompatible Tools einfach in AutoGen-Agenten zu integrieren.

Kernkomponenten

  1. McpWorkbench: Umhüllt MCP-Server und bietet Schnittstellen zum Auflisten und Aufrufen von vom Server bereitgestellten Tools
  2. StdioMcpToolAdapter: Ermöglicht Interaktion mit MCP-Tools über Standard-Input/Output
  3. SseMcpToolAdapter: Ermöglicht Interaktion mit MCP-Tools über HTTP, die Server-Sent Events (SSE) unterstützen
  4. McpSessionActor: Verwaltet Sessions mit MCP-Servern

Konfigurationsparameter

MCP-Tool-Adapter benötigen spezifische Server-Parameter zur Verbindungsherstellung:

  1. StdioServerParams: Parameter für die Verbindung zu MCP-Servern über Standard-Input/Output

    • command: Auszuführender Befehl
    • args: Befehlsargumente
    • env: Umgebungsvariablen
    • read_timeout_seconds: Lese-Timeout-Zeit
  2. SseServerParams: Parameter für die Verbindung zu MCP-Servern über HTTP/SSE

    • url: Server-URL
    • headers: HTTP-Header-Informationen
    • timeout: Verbindungs-Timeout-Zeit
    • sse_read_timeout: SSE-Lese-Timeout-Zeit

Praktischer Anwendungsfall: Aufbau eines Multi-Source-Informationsabrufsystems

Im Folgenden zeigen wir anhand eines praktischen Anwendungsfalls, wie AutoGen und MCP verwendet werden können, um ein System zu erstellen, das Informationen aus mehreren Quellen (GitHub, Jira und Confluence) abrufen kann.

Systemarchitektur

Das System besteht aus drei Hauptkomponenten:

  1. Such-Agent: Verantwortlich für das Abrufen relevanter Informationen aus mehreren Informationsquellen
  2. Zusammenfassungs-Agent: Verantwortlich für die Verarbeitung und Zusammenfassung der abgerufenen Informationen
  3. Benutzer-Proxy: Repräsentiert den Benutzer und interagiert mit anderen Agenten

Das System verwendet MCP-Tools zur Verbindung mit GitHub- und Atlassian-Services (Jira und Confluence), wodurch Agenten auf Informationen auf diesen Plattformen zugreifen können.

Code-Implementierung

python
from typing import Sequence
import os
import asyncio
from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools
from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
from autogen_agentchat.messages import BaseAgentEvent, BaseChatMessage
from autogen_agentchat.agents import AssistantAgent, UserProxyAgent
from autogen_agentchat.teams import SelectorGroupChat
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.ui import Console

def get_model_client() -> AzureOpenAIChatCompletionClient:
    return AzureOpenAIChatCompletionClient(
        azure_deployment=os.getenv("AZURE_OPENAI_MODEL_DEPLOYMENT"),
        api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
        azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
        model="gpt-4o"
    )

search_agent_prompt = """
Bitte suchen Sie mit den Ihnen zur Verfügung stehenden Tools nach möglichst vielen verwandten Informationen aus Jira, Confluence und Github,
basierend auf der Benutzerfrage. Geben Sie die gefundenen Informationen ohne Verarbeitung oder Kommentare zurück.
Falls keine Informationen gefunden werden, antworten Sie mit "Entschuldigung, ich konnte keine relevanten Informationen zu diesem Problem finden."
"""

summary_agent_prompt = """
Sie sind ein AI-Assistent. Bitte helfen Sie bei der Beantwortung der Benutzerfrage entsprechend der Antwort des Such-Agenten.
"""

async def main() -> None:
    github_server_params = StdioServerParams(
            command="docker",
            args=[
                "run",
                "-i",
                "--rm",
                "-e",
                "GITHUB_PERSONAL_ACCESS_TOKEN",
                "-e",
                "GH_HOST",
                "ghcr.io/github/github-mcp-server"
            ],
            env={
                "GITHUB_PERSONAL_ACCESS_TOKEN": os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN"),
                "GH_HOST": os.getenv("GH_HOST")
            }
    )
    github_tools = await mcp_server_tools(github_server_params)

    atl_server_params = StdioServerParams(
        command="uv",
        args=[
            'run',
            'mcp-atlassian',
            '-v',
            '--jira-url',
            os.getenv("JIRA_HOST"),
            '--jira-personal-token',
            os.getenv("JIRA_PERSONAL_TOKEN"),
            '--confluence-url',
            os.getenv("CONFLUENCE_HOST"),
            '--confluence-personal-token',
            os.getenv("CONFLUENCE_PERSONAL_TOKEN"),
        ],
    )

    atl_tools = await mcp_server_tools(atl_server_params)

    # Erstellen Sie einen Agenten, der die Übersetzungstools verwenden kann
    search_agent = AssistantAgent(
        name="search_agent",
        model_client=get_model_client(),
        tools=github_tools + atl_tools,
        system_message=search_agent_prompt,
    )

    summary_agent = AssistantAgent(
        name="summary_agent",
        model_client=get_model_client(),
        system_message=summary_agent_prompt,
    )

    user_proxy = UserProxyAgent("user", input_func=input)

    # Erstellen Sie die Beendigungsbedingung, die das Gespräch beendet, wenn der Benutzer "Exit" sagt
    termination = TextMentionTermination("Exit")

    def selector_func(messages: Sequence[BaseAgentEvent | BaseChatMessage]) -> str | None:
        if messages[-1].source == "user":
            return search_agent.name
        elif messages[-1].source == search_agent.name:
            return summary_agent.name
        elif messages[-1].source == summary_agent.name:
            return user_proxy.name
        return user_proxy.name

    team = SelectorGroupChat(
        [search_agent, summary_agent, user_proxy],
        model_client=get_model_client(),
        termination_condition=termination,
        selector_func=selector_func,
        allow_repeated_speaker=False,
    )

    task = "Was ist Marvin?"

    await Console(team.run_stream(task=task))

if __name__ == "__main__":
    asyncio.run(main())

Code-Analyse

  1. MCP-Server-Konfiguration:

    • Verwendung von StdioServerParams zur Konfiguration von GitHub- und Atlassian-MCP-Servern
    • Authentifizierungsinformationen und Server-Adressen werden über Umgebungsvariablen übergeben
  2. Tool-Abruf:

    • Verwendung der mcp_server_tools-Funktion zum Abrufen verfügbarer Tools von MCP-Servern
    • Zusammenführung von GitHub- und Atlassian-Tools zu einer Tool-Liste
  3. Agenten-Erstellung:

    • Erstellung des Such-Agenten mit Zuweisung aller MCP-Tools
    • Erstellung des Zusammenfassungs-Agenten, verantwortlich für die Verarbeitung der Suchergebnisse
    • Erstellung des Benutzer-Proxys zur Behandlung von Benutzereingaben
  4. Gesprächsablauf-Steuerung:

    • Verwendung von selector_func zur Definition der Interaktionsreihenfolge zwischen Agenten
    • Implementierung eines einfachen Workflows: Benutzerfrage -> Such-Agent sucht -> Zusammenfassungs-Agent fasst zusammen -> Rückgabe an Benutzer
  5. Beendigungsbedingung:

    • Verwendung von TextMentionTermination zur Definition der Gesprächsbeendigungsbedingung

Erweiterte Anwendungsszenarien für MCP

Neben dem obigen Beispiel kann MCP in verschiedenen erweiterten Szenarien angewendet werden:

1. Dateisystem-Operationen

Mit einem Dateisystem-MCP-Server können Agenten Dateierstellung, -lesen, -schreiben und andere Operationen durchführen:

python
# Einrichten der Dateisystem-MCP-Server-Parameter
desktop = str(Path.home() / "Desktop")
server_params = StdioServerParams(
    command="npx.cmd",
    args=["-y", "@modelcontextprotocol/server-filesystem", desktop]
)

# Abrufen aller verfügbaren Tools
tools = await mcp_server_tools(server_params)

# Erstellen eines Agenten, der diese Tools verwenden kann
agent = AssistantAgent(
    name="file_manager",
    model_client=OpenAIChatCompletionClient(model="gpt-4"),
    tools=tools,
)

2. Web-Inhalte-Abruf

Mit einem Fetch-MCP-Server können Agenten Web-Inhalte abrufen und verarbeiten:

python
# Abrufen von Fetch-Tools
fetch_mcp_server = StdioServerParams(command="uvx", args=["mcp-server-fetch"])
tools = await mcp_server_tools(fetch_mcp_server)

# Erstellen eines Agenten, der Fetch-Tools verwenden kann
agent = AssistantAgent(
    name="fetcher",
    model_client=OpenAIChatCompletionClient(model="gpt-4o"),
    tools=tools,
    reflect_on_tool_use=True
)

3. Web-Browser-Automatisierung

Mit einem Playwright-MCP-Server können Agenten Web-Browser steuern und komplexe Interaktionen durchführen:

python
params = StdioServerParams(
    command="npx",
    args=["@playwright/mcp@latest"],
    read_timeout_seconds=60,
)

async with create_mcp_server_session(params) as session:
    await session.initialize()
    tools = await mcp_server_tools(server_params=params, session=session)

    agent = AssistantAgent(
        name="Assistant",
        model_client=model_client,
        tools=tools,
    )

Vorteile und Einschränkungen von MCP

Vorteile

  1. Standardisierte Schnittstelle: Bietet einheitliche Tool-Aufrufmethoden und vereinfacht den Integrationsprozess
  2. Vielfältige Tool-Unterstützung: Unterstützt verschiedene Arten von Tools, von lokalen Kommandozeilen-Tools bis hin zu Remote-API-Services
  3. Session-Management: Unterstützt die Aufrechterhaltung von Session-Zuständen für Tool-Aufrufe, geeignet für zustandsbasierte Tools (wie Browser)
  4. Skalierbarkeit: Einfaches Hinzufügen neuer Tools und Services

Einschränkungen

  1. Abhängigkeit von externen Services: Benötigt Unterstützung externer MCP-Server
  2. Konfigurationskomplexität: Die Konfiguration einiger Tools kann komplex sein
  3. Performance-Overhead: Interprozesskommunikation oder Netzwerkkommunikation kann zusätzliche Latenz einführen
  4. Sicherheitsüberlegungen: Sorgfältige Behandlung von Tool-Berechtigungen und Authentifizierungsinformationen erforderlich

Fazit

Das MCP-Modul von AutoGen bietet entscheidende Unterstützung für den Aufbau leistungsstarker Multi-Agent-Systeme. Durch standardisierte Tool-Schnittstellen können Entwickler verschiedene externe Tools und Services einfach in Agentensysteme integrieren, wodurch der Funktionsumfang der Agenten erheblich erweitert wird.

Von einfachen Dateioperationen bis hin zu komplexer Web-Browser-Automatisierung ermöglicht MCP Agenten reichhaltigere Interaktionen mit der realen Welt. Diese Fähigkeit ist entscheidend für den Aufbau wirklich nützlicher AI-Anwendungen, da sie es AI-Systemen ermöglicht, nicht nur die Absichten der Benutzer zu verstehen, sondern auch konkrete Maßnahmen zu ergreifen, um diese Absichten zu verwirklichen.

Mit der kontinuierlichen Entwicklung von AutoGen und MCP können wir erwarten, dass mehr innovative Multi-Agent-Anwendungen auftauchen werden, die Benutzern in verschiedenen Bereichen intelligentere und effizientere Services bieten.

Referenzressourcen