MCP-Integration in Open Agent SDK: So integrieren Entwickler externe Tools

Die Fähigkeiten eines KI-Agenten werden maßgeblich durch die verfügbaren Werkzeuge bestimmt. Während das Open Agent SDK bereits 34 eingebaute Funktionen wie Dateizugriff, Bash-Befehle und Code-Suche bietet, stößt es bei individuellen Anforderungen an Grenzen. Externe Systeme wie Datenbanken, Unternehmens-APIs oder proprietäre Software benötigen eine standardisierte Schnittstelle – genau hier setzt das Model Context Protocol (MCP) an.

Der Open Agent SDK nutzt MCP, um diese Lücke zu schließen und Entwicklern eine flexible Methode zur Integration externer Tools zu bieten. Die Technologie ermöglicht die Kommunikation zwischen KI-Modellen und beliebigen Datenquellen oder Diensten, ohne dass Anpassungen am Agenten-Code erforderlich sind. Stattdessen werden externe MCP-Server über eine einzige Konfigurationszeile eingebunden.

Das Model Context Protocol: Grundlagen und Funktionsweise

Das MCP ist ein offener Standard, der von Anthropic entwickelt wurde, um die Interaktion zwischen Sprachmodellen und externen Tools zu standardisieren. Die Architektur besteht aus zwei Hauptkomponenten:

• MCP-Server: Stellt Tools mit definierten Namen, Beschreibungen und Eingabeschemata bereit. Diese Server können in verschiedenen Programmiersprachen implementiert werden und werden über eine standardisierte JSON-RPC-Schnittstelle angesprochen.
• MCP-Client: Erkennt die verfügbaren Tools, führt sie aus und verarbeitet die Ergebnisse. Der Client ist Teil des Agenten und kommuniziert über austauschbare Transportprotokolle mit den Servern.

Ein zentraler Vorteil von MCP liegt in seiner Modularität: Entwickler können eigene MCP-Server erstellen – etwa für spezifische Datenbanken oder interne APIs – und diese ohne Änderungen am Agenten-Code integrieren. Der Open Agent SDK unterstützt dabei zwei Integrationspfade:

• Externe MCP-Server: Verbindung zu bestehenden MCP-Servern über verschiedene Transportmethoden wie Stdio, HTTP oder SSE.
• In-Prozess-MCP-Server: Direkte Integration von SDK-Tools als MCP-Server ohne Protokolloverhead, ideal für maximale Performance.

Fünf Transportmethoden für MCP-Server: Ein Überblick

Der Open Agent SDK bietet eine einheitliche Konfiguration für alle Transportoptionen über die McpServerConfig-Enum. Jede Methode eignet sich für unterschiedliche Szenarien:

public enum McpServerConfig: Sendable, Equatable {
    case stdio(McpStdioConfig)          // Kommunikation über Kindprozess-Standardein-/ausgabe
    case sse(McpTransportConfig)        // Server-Sent Events für langlebige Verbindungen
    case http(McpTransportConfig)       // Standard-HTTP für Anfrage-Antwort-Zyklen
    case sdk(McpSdkServerConfig)        // Direkte Integration ohne Protokolloverhead
    case claudeAIProxy(McpClaudeAIProxyConfig)  // Spezifische Verbindung zu ClaudeAI-Proxys
}

Stdio: Kindprozesse für lokale und entfernte Server

Die Stdio-Methode startet einen Kindprozess und nutzt dessen Standard-Ein- und Ausgabekanäle für die JSON-RPC-Kommunikation. Besonders geeignet für MCP-Server in Node.js oder Python. Ein typisches Beispiel zeigt die Konfiguration:

let servers: [String: McpServerConfig] = [
    "filesystem": .stdio(McpStdioConfig(
        command: "npx",
        args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
    )),
    "git": .stdio(McpStdioConfig(
        command: "uvx",
        args: ["mcp-server-git"],
        env: ["GIT_REPO_PATH": "/my/repo"]
    ))
]

Die Implementierung nutzt Apples Process-Klasse für die Prozessverwaltung und FileDescriptor für effiziente I/O-Operationen. Wichtige Details zur Stdio-Integration umfassen:

• Befehlsauflösung: Relative Pfade werden über das Systemkommando which aufgelöst. Falls nicht gefunden, wird der Pfad direkt als Datei interpretiert.
• Nachrichtenabgrenzung: Jede JSON-RPC-Nachricht wird durch Zeilenumbrüche getrennt, wobei CRLF-Unterstützung für Kompatibilität sorgt.
• Sicherheitsfilterung: Standardmäßig werden Umgebungsvariablen wie CODEANY_API_KEY nicht an Kindprozesse weitergegeben, es sei denn, sie werden explizit in der Konfiguration angegeben.
• Wiederverbindungslogik: Der Client versucht bis zu zwei automatische Wiederverbindungen mit exponentiellem Backoff, beginnend bei einer Sekunde und maximal bis zu zehn Sekunden.

SSE und HTTP: Verbindung zu entfernten Diensten

Für entfernte MCP-Server bieten sich zwei Transportmethoden an, die beide auf HTTP basieren, aber unterschiedliche Kommunikationsmuster nutzen:

• SSE (Server-Sent Events): Ideal für Szenarien, die serverseitiges Push benötigen, etwa Echtzeit-Updates von Tools. Die Konfiguration erfolgt über eine langlebige Verbindung:

let sseServer: [String: McpServerConfig] = [
    "remote-tools": .sse(McpTransportConfig(
        url: "
        headers: ["Authorization": "Bearer token123"]
    ))
]

• HTTP: Standard-Anfrage-Antwort-Mechanismus für einfache Interaktionen ohne Echtzeitanforderungen:

let httpServer: [String: McpServerConfig] = [
    "api-tools": .http(McpTransportConfig(
        url: "
    ))
]

Hinter den Kulissen nutzt der SDK sowohl für SSE als auch HTTP dieselbe HTTPClientTransport-Implementierung. Der Unterschied liegt im streaming-Parameter, der bei SSE aktiviert wird. Die Konfigurationen McpSseConfig und McpHttpConfig sind dabei nur Aliase für McpTransportConfig.

SDK: In-Prozess-Integration mit minimalem Overhead

Die In-Prozess-Integration eliminiert den Netzwerk-Overhead vollständig, indem die Tools des SDK direkt als MCP-Server registriert werden. Diese Methode eignet sich besonders für Performance-kritische Anwendungen und wird in einem separaten Abschnitt detailliert behandelt.

ClaudeAI Proxy: Spezifische Verbindung zu ClaudeAI

Für Entwickler, die eine Verbindung zu ClaudeAI herstellen möchten, bietet der SDK eine spezielle Proxy-Konfiguration:

let proxyServer: [String: McpServerConfig] = [
    "claude-tools": .claudeAIProxy(McpClaudeAIProxyConfig(
        url: "
        id: "server-abc-123"
    ))
]

Intern handelt es sich hierbei um eine HTTP-Verbindung mit einem zusätzlichen Header X-ClaudeAI-Server-ID zur Authentifizierung.

Von der Konfiguration zur Tool-Auswahl: Der Verbindungsprozess

Die Integration externer MCP-Tools in den Agenten erfolgt in mehreren Schritten, die in der Funktion assembleFullToolPool() dokumentiert sind. Der Prozess lässt sich wie folgt zusammenfassen:

1. Trennung der Konfigurationen: Die Funktion processMcpConfigs() separiert SDK-spezifische Konfigurationen (.sdk) von externen Konfigurationen (Stdio, SSE, HTTP). SDK-Konfigurationen werden direkt in Tools umgewandelt, während externe Konfigurationen für die spätere Verbindung vorbereitet werden.

1. Verbindung zu externen Servern: Der MCPClientManager – ein asynchroner Akteur – stellt Verbindungen zu allen externen Servern her. Dabei nutzt er withTaskGroup, um mehrere Verbindungen parallel zu verwalten. Nach erfolgreicher Verbindung werden die verfügbaren Tools abgefragt und in das Tool-Pool des Agenten integriert.

1. Zusammenführung aller Tools: Alle verfügbaren Tools – sowohl die eingebauten des SDKs als auch die externen MCP-Tools – werden in einem zentralen Tool-Pool zusammengeführt. Dieser Pool berücksichtigt dabei auch Einschränkungen durch erlaubte oder verbotene Tools, um die Sicherheit und Konsistenz zu gewährleisten.

Die Integration externer Tools über MCP eröffnet Entwicklern neue Möglichkeiten, die Funktionalität von KI-Agenten deutlich zu erweitern. Durch die Standardisierung der Kommunikation und die flexible Transportauswahl lässt sich der Agent an nahezu jedes Szenario anpassen – sei es für den Zugriff auf Unternehmensdaten, die Steuerung interner Systeme oder die Nutzung spezialisierter Dienste. Mit der Unterstützung von MCP positioniert sich der Open Agent SDK als mächtiges Framework für die nächste Generation intelligenter Anwendungen, die nahtlos mit der realen Welt interagieren können.

Die kommenden Versionen werden voraussichtlich weitere Transportoptionen und verbesserte Sicherheitsmechanismen bieten, um die Integration noch robuster und performanter zu gestalten.