Model Context Protocol und OpenAI Agents: Praxisleitfaden für agentenbasierte KI-Workflows

Workflows auf Basis großer Sprachmodelle haben sich von einer optionalen Erweiterung zu einem wichtigen Bestandteil moderner agentenbasierter KI-Systeme entwickelt. Agenten müssen Informationen erfassen, Aktionen ausführen und über verschiedene Webdienste hinweg Zusammenhänge bewerten können. Das OpenAI Agents SDK bietet dafür eine flexible Grundlage, legt jedoch nicht vollständig fest, wie externe Werkzeuge eingebunden werden sollten. Genau an dieser Stelle setzt das Model Context Protocol an.

MCP ist ein aufkommender offener Standard, der Werkzeuge und kontextbezogene Daten über eine einheitliche Schnittstelle für LLMs verfügbar macht. In diesem ausführlichen Leitfaden erfahren Sie, was MCP ist, weshalb es relevant ist und wie es zusammen mit dem OpenAI Agents SDK eingesetzt werden kann. Außerdem werden die Architektur des Protokolls, die Einrichtung, bewährte Vorgehensweisen, Sicherheitsaspekte, praktische Einsatzbereiche und die künftige Entwicklung agentenbasierter Integrationen erläutert.

Wichtige Kernaussagen

• MCP als standardisierte Brücke: Ein einzelnes Protokoll auf Basis von JSON-RPC ermöglicht es Agenten, Werkzeuge zu erkennen und aufzurufen sowie Daten zu lesen oder zu schreiben, ohne für jeden Dienst eigene Integrationen entwickeln zu müssen.
• Plugin-ähnliche Erweiterungen für OpenAI Agents: Durch die Anbindung von MCP-Servern, beispielsweise für GitHub, Datenbanken, Slack, Fetch- oder Dateisystemfunktionen, erhält ein Agent direkten Zugriff auf die dort bereitgestellten Werkzeuge.
• Einfachere Skalierung: MCP reduziert das klassische N×M-Integrationsproblem. Neue Funktionen lassen sich durch weitere MCP-Server ergänzen, ohne den Client-Code ständig anpassen zu müssen.
• Mehr Transparenz und Sicherheit: Typisierte Schemas und strukturierte Tool-Aufrufe erleichtern Auditierung, Debugging, Nachverfolgung und Governance in professionellen Umgebungen.
• Zukunftsfähige Architektur: Da MCP zunehmend von großen Anbietern unterstützt wird, entwickelt es sich zu einem wahrscheinlichen Standard für interoperable Multi-Agent-Workflows.

Was ist das Model Context Protocol?

Das Model Context Protocol ist ein offener Standard zur Verbindung von KI-Anwendungen mit externen Systemen. Es definiert eine einheitliche Schnittstelle, über die KI-Agenten wie ChatGPT, Claude oder vergleichbare Assistenten Werkzeuge entdecken, aufrufen und Daten über eine standardisierte API abrufen können. MCP arbeitet als JSON-RPC-basierte Kommunikationsschicht, die das KI-Modell von den individuellen proprietären APIs einzelner Dienste entkoppelt. Anthropic stellte den MCP-Standard Ende 2024 vor, seitdem wird er zunehmend als neue Integrationsschicht für KI-Anwendungen diskutiert.

MCP als universeller Anschluss für KI-Agenten

MCP als universeller Anschluss für KI-Agenten, bedeutet, dass dieser Anschluss über eine standardisierte JSON-RPC-Verbindung mit mehreren MCP-Servern verbunden ist. Jede Verbindung passt reale Ressourcen an eine gemeinsame Schnittstelle an: ein agentenseitiger Zugang, viele austauschbare Werkzeuge.

Zentrale Komponenten von MCP

MCP-Server: Ein MCP-Server ist ein Programm, das Werkzeuge, Daten oder Funktionen in einem standardisierten Format für einen KI-Agenten bereitstellt. Ein Server ist in der Regel mit einem bestimmten Backend verbunden. Ein GitHub-MCP-Server könnte einem Agenten beispielsweise ermöglichen, Issues oder Pull Requests über die GitHub-API abzufragen. Der Server teilt dem Agenten außerdem mit, welche Werkzeuge verfügbar sind, einschließlich Name, Beschreibung sowie Eingabe- und Ausgabeschema. Dies geschieht üblicherweise während eines Discovery-Schritts.

MCP-Client: Der MCP-Client ist eine Komponente innerhalb der KI-Host-Anwendung, also etwa des Agenten oder Assistenten. Er verbindet sich mit einem MCP-Server, verwaltet die Sitzung, sendet Anfragen, empfängt Antworten und stellt die Ergebnisse dem KI-Modell zur Verfügung.

Werkzeuge und Schemas: In MCP wird jede verfügbare Aktion als Werkzeug bezeichnet. Ein Werkzeug besitzt einen Namen, eine Beschreibung seiner Funktion und ein JSON Schema für seine Eingabeparameter. Optional kann auch ein erwartetes Ausgabeformat definiert werden. Das Schema hilft dem Sprachmodell zu verstehen, wie das Werkzeug korrekt aufgerufen wird und welche Art von Ergebnis zu erwarten ist. Ein Werkzeug wie get_weather könnte beispielsweise einen Ortsnamen als Zeichenkette annehmen und strukturierte Wetterdaten zurückgeben. Werkzeuge werden über einen standardisierten tools/list-Aufruf entdeckt, bei dem der Server eine JSON-Liste der Tool-Definitionen zurückliefert. Eine vereinfachte Definition könnte so aussehen:

{
  "name": "get_weather",
  "title": "Weather Information Provider",
  "description": "Get current weather information for a location",
  "inputSchema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City name or zip code"
      }
    },
    "required": ["location"]
  },
  "outputSchema": { ... }
}

Dieses JSON-Beispiel beschreibt eine einfache Werkzeugdefinition für einen Wetterdienst. Der Agent erkennt, dass er get_weather mit einem Standortparameter aufrufen kann, um Wetterdaten abzurufen.

Ressourcen und Prompts: MCP-Server können mehr als nur Werkzeuge bereitstellen. Sie können auch Ressourcen wie Dokumente oder Daten anbieten, die das Modell abrufen kann, sowie Prompts in Form wiederverwendbarer Prompt-Vorlagen. Ein Server könnte beispielsweise den Inhalt einer Datei als Ressource bereitstellen oder eine vordefinierte Vorlage für Codegenerierung anbieten.

Warum ist MCP wichtig?

In klassischen Setups bedeutete das Hinzufügen neuer Fähigkeiten oft, die Schnittstelle zwischen KI-Assistent und neuer API manuell zu programmieren – inklusive eigener Prompts und Antwortverarbeitung. Dieser Ansatz skaliert schlecht, weil er das **N×M-Integrationsproblem** erzeugt: Jede neue Kombination aus Tool und Agent benötigt zusätzlichen Verbindungscode.

MCP löst dieses Problem durch eine standardisierte Schnittstelle. Sobald ein Agent MCP unterstützt, kann er sich mit jedem MCP-kompatiblen Tool-Service verbinden, ohne dass neue Integrationslogik geschrieben werden muss.

Was sind OpenAI Agents und wie funktionieren sie?

OpenAI Agents, erstellt mit dem OpenAI Agents SDK, bilden ein Framework für LLM-gestützte Agenten, die strukturiert planen, entscheiden und Werkzeuge verwenden können. Das Agents SDK bietet eine übergeordnete Methode zur Definition solcher Agenten und enthält unter anderem folgende Funktionen:

• Werkzeuge und Function Calls: Einem Agenten kann eine Liste von Werkzeugen zugewiesen werden, etwa Python-Funktionen, API-Aufrufe oder externe Skills. Das LLM des Agenten entscheidet, wann ein Werkzeug zur Beantwortung einer Nutzeranfrage eingesetzt werden sollte. Im Hintergrund können OpenAI-Modelle die Chat Completions API mit Function Calling oder die neuere Responses API verwenden, um diesen Ablauf zu unterstützen.
• Planung und mehrstufiges Reasoning: Das OpenAI Agents SDK unterstützt Abläufe mit mehreren Schritten, Verzweigungen und Übergaben an andere Agenten. Ein Agent kann beispielsweise zunächst ein Rechenwerkzeug verwenden, anschließend ein Suchwerkzeug einsetzen und abschließend eine vollständige Antwort formulieren.
• Anbieterunabhängigkeit und Multi-LLM-Unterstützung: Das SDK ist nicht auf einen einzelnen Modellanbieter beschränkt. Es unterstützt OpenAI-APIs, darunter die Responses API und die klassische Chat Completions API, sowie Integrationspakete für weitere LLM-Anbieter.
• Integrierte Guardrails und Tracing: Das SDK enthält Eingabe- und Ausgabe-Guardrails, Tracing, automatische Protokollierung von Entscheidungen und Werkzeugaufrufen sowie Debugging-Funktionen. OpenAI stellt außerdem einen Trace Viewer bereit, der zeigt, welche Schritte der Agent ausgeführt hat, welches Werkzeug aufgerufen wurde, wie lange es gedauert hat und welches Ergebnis zurückgegeben wurde.

OpenAI Agents standardisieren das Tool-Using-Muster von KI-Systemen, das durch Frameworks wie LangChain und AutoGPT bekannt wurde. Entwickler müssen keine manuellen Schleifen oder komplexen Prompt-Ketten schreiben. Das Agents SDK stellt eine einfache, Python-nahe Schnittstelle bereit. Ein sehr einfacher Agent kann beispielsweise so erstellt werden:

from agents import Agent, Runner

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant that can use tools."
    # (tools can be added here)
)
result = Runner.run_sync(agent, "Who won the World Cup in the year I graduated high school?")
print(result.final_output)

Wenn diesem Agenten ein Werkzeug bereitgestellt wird, beispielsweise eine Websuche oder eine Wissensdatenbank, kann er selbstständig entscheiden, dieses Werkzeug zur Ermittlung der benötigten Informationen zu verwenden. Der Entwickler muss nicht jeden Schritt manuell vorgeben. Stattdessen werden die Werkzeuge und das übergeordnete Ziel definiert.

Wie arbeiten Agents und MCP zusammen?

Ein Agent kann sich mit einem oder mehreren MCP-Servern verbinden und automatisch Zugriff auf die von diesen Servern bereitgestellten Werkzeuge erhalten. Anstatt für jede externe API eigene Python-Funktionen zu entwickeln, lässt sich ein MCP-Server starten oder anbinden, der diese APIs verfügbar macht. Der Agent entdeckt anschließend die verfügbaren Werkzeuge und ruft sie bei Bedarf auf, ähnlich wie integrierte Funktionen.

Dadurch erweitert sich der Handlungsspielraum des Agenten deutlich. Er kann auf Live-Daten, private Unternehmenssysteme, Cloud-Dienste und weitere Ressourcen zugreifen, statt ausschließlich auf Trainingsdaten und wenige manuell definierte Werkzeuge angewiesen zu sein. Außerdem ermöglicht dies stärkere Workflow-Automatisierung, weil der Agent Werkzeuge aus mehreren MCP-Servern innerhalb einer Aufgabe kombinieren kann.

Warum MCP mit OpenAI Agents integrieren?

Die Kombination von MCP mit einem OpenAI Agent bietet mehrere wichtige Vorteile:

• Skalierbarkeit und Standardisierung: OpenAI Agents in Verbindung mit MCP reduzieren Integrationscode und schaffen eine besser skalierbare Architektur. Statt für jeden Dienst eigene Anbindungsschichten zu schreiben, wird die MCP-Schnittstelle einmal integriert.
• Interoperabilität und Zugriff auf ein wachsendes Ökosystem: MCP eröffnet dem Agenten Zugang zu einer wachsenden Connector-Landschaft, darunter Dienste wie Google Drive, Slack, GitHub und Datenbanken. Anthropic hat zudem Beispielserver für Werkzeuge wie Google Drive, Git, Postgres und weitere Systeme veröffentlicht.
• Erweiterte Fähigkeiten durch Echtzeitdaten und Aktionen: Ein MCP-fähiger Agent kann Aufgaben übernehmen, die ein einfaches LLM nicht ausführen kann. Er kann Echtzeitdaten oder private Daten abrufen, Kalendereinträge erstellen, Nachrichten senden, Berechnungen ausführen und weitere Aktionen im Auftrag des Nutzers durchführen.
• Einfachere Wartung und bessere Beobachtbarkeit: Wenn Tool-Nutzung über MCP läuft, entsteht ein einheitlicher Weg zur Protokollierung und Überwachung des Agentenverhaltens. Das Tracing des OpenAI Agents SDK kann MCP-Tool-Aufrufe und deren Ergebnisse einschließen. Wenn etwas fehlschlägt, lässt sich prüfen, ob der Agent ein Schema falsch interpretiert hat oder ob der Server ein ungültiges Ergebnis zurückgegeben hat. Da jeder Tool-Aufruf strukturiert ist, kann er auch für Compliance-Zwecke auditiert werden.
• Zukunftssichere Architektur: MCP ist ein offener Standard mit zunehmender Branchenrelevanz. Die OpenAI-Plattform unterstützt MCP in gehosteten Tools innerhalb der Responses API, Anthropic Claude unterstützt MCP ebenfalls, und Google hat MCP als vielversprechenden Ansatz für Tool-Integration beschrieben. Die Nutzung von MCP richtet die Agentenarchitektur an einem breiteren Trend zu standardisierter Agent-Tool-Kommunikation aus.

MCP mit OpenAI Agents Schritt für Schritt einrichten

In diesem Abschnitt wird erklärt, wie MCP in einer OpenAI-Agents-Umgebung aktiviert werden kann. Behandelt werden Voraussetzungen, die Konfiguration von MCP-Servern, die Agentenkonfiguration und ein einfaches Praxisbeispiel.

Voraussetzungen

Vor der Integration von MCP sollte folgende Umgebung vorhanden sein:

• Python 3.9 oder neuer: Das OpenAI Agents SDK ist in Python geschrieben, daher wird eine aktuelle Python-3-Umgebung benötigt.
• OpenAI API Key: Es wird ein gültiger API-Schlüssel mit Zugriff auf die gewünschten Modelle benötigt. Speichern Sie ihn als Umgebungsvariable OPENAI_API_KEY oder in einer .env-Datei. Wenn eine .env-Datei für Geheimnisse wie OpenAI-Schlüssel oder Tool-Tokens verwendet wird, kann sie etwa mit python-dotenv geladen werden. Das Agents SDK liest OPENAI_API_KEY standardmäßig aus der Umgebung.
• OpenAI Agents SDK: Installieren Sie das SDK mit pip:

pip install --upgrade openai-agents

• Node.js 18 oder neuer und npm: Dies ist optional, aber empfohlen. Node.js und npm erleichtern das Ausführen gängiger MCP-Serverpakete. Stellen Sie sicher, dass npx über die Kommandozeile gestartet werden kann.
• MCP SDK oder Erweiterung, falls erforderlich: Das OpenAI Agents SDK enthält in aktuellen Versionen integrierte MCP-Unterstützung. Ältere Versionen können eine Erweiterungsbibliothek benötigen. Das Paket openai-agents-mcp kann beispielsweise MCP-Unterstützung für frühere Versionen des Agents SDK ergänzen. In diesem Fall aktiviert die Installation und der Import von Agent aus agents_mcp die Funktion mcp_servers. Mit dem aktuellen SDK kann agents.mcp direkt verwendet werden.
• Hinweis zu MCPServerStdio: In aktuellen Versionen des OpenAI Agents SDK kann MCPServerStdio mit from agents.mcp import MCPServerStdio importiert werden. Diese Klasse verwaltet den Lebenszyklus eines MCP-Servers über stdio und eignet sich besonders für lokale Entwicklung und Tests. Wenn diese Klasse im SDK verfügbar ist, wird das Erweiterungspaket nicht benötigt.
• Zugangsdaten für Tools oder Server: Je nach gewünschtem MCP-Server können Zugriffstokens, API-Schlüssel oder andere Anmeldedaten für die verbundenen Dienste erforderlich sein.
• Entwicklungsumgebung: Es empfiehlt sich, ein eigenes Projektverzeichnis anzulegen und eine virtuelle Python-Umgebung zu verwenden. Das System sollte außerdem asynchronen Code unterstützen, da Agenten- und MCP-Workflows häufig asyncio verwenden. In vielen Fällen wird eine async-kompatible Umgebung oder ein Wrapper wie asyncio.run(main()) benötigt, um MCP-Server ohne blockierende Ausführung anzubinden.

Einen MCP-Server konfigurieren

Der erste Schritt besteht darin, einen MCP-Server verfügbar zu machen. Sie können eine bestehende MCP-Serverimplementierung für eine gängige Datenquelle oder ein Tool verwenden oder einen eigenen MCP-Server für ein individuelles System entwickeln. Dieser Leitfaden nutzt bestehende Server, um den Ablauf zu demonstrieren.

Einen MCP-Server auswählen: Das MCP-Repository von Anthropic und Community-Beiträge enthalten Server für Dateisystemzugriff, das Abrufen von Webinhalten, Slack, GitHub, Datenbanken wie Postgres und weitere Systeme. In diesem Beispiel soll der Agent auf das lokale Dateisystem zugreifen und Webinhalte abrufen können. Dafür können der Filesystem-MCP-Server und der Fetch-MCP-Server aus der MCP-Community verwendet werden. Sie sind als Node.js-Pakete mit den Namen @modelcontextprotocol/server-filesystem und @modelcontextprotocol/server-fetch verfügbar.

Serverkonfiguration: Das OpenAI Agents SDK kann MCP-Serverprozesse automatisch starten, wenn die passende Konfiguration angegeben wird. Häufig wird diese in einer YAML-Datei mit dem Namen mcp_agent.config.yaml definiert. Das folgende Beispiel konfiguriert zwei Server namens fetch und filesystem:

mcp:
  servers:
    fetch:
      command: npx
      args: ["-y", "@modelcontextprotocol/server-fetch"]
    filesystem:
      command: npx
      args: ["-y", "@modelcontextprotocol/server-filesystem", "."]

Diese YAML-Konfiguration bedeutet:

• Der MCP-Server mit dem Namen fetch nutzt den Befehl npx und startet das Paket @modelcontextprotocol/server-fetch. Dieser Server stellt Werkzeuge zum Abrufen von Web-URLs bereit, etwa HTTP-GET-Operationen.
• Der MCP-Server mit dem Namen filesystem verwendet ebenfalls npx. Er startet @modelcontextprotocol/server-filesystem mit . als Argument, wodurch das aktuelle Verzeichnis für den Server freigegeben wird. Dieser Server kann dateibezogene Werkzeuge bereitstellen, beispielsweise zum Auflisten von Dateien oder Lesen von Dateiinhalten innerhalb des erlaubten Verzeichnisses.

Beim Start des Agenten kann das SDK diese Konfiguration verwenden, um beide Server automatisch als Subprozesse zu starten. Die Option -y weist npx an, Installationsabfragen bei Bedarf automatisch zu bestätigen.

Alternativ kann ein MCP-Server auch manuell in einem separaten Prozess oder Terminal gestartet werden. Um den Filesystem-Server beispielsweise manuell aus dem Projektverzeichnis zu starten, könnte npx @modelcontextprotocol/server-filesystem ausgeführt werden.

Den Agenten für MCP konfigurieren

Sobald ein MCP-Server verfügbar ist, lässt er sich unkompliziert mit einem OpenAI Agent verbinden. Der Agent wird zusätzlich zu normalen Werkzeugen mit einem Parameter mcp_servers initialisiert. Dieser Parameter kann Servernamen aus einer YAML-Konfiguration oder direkt im Code erzeugte Serververbindungsobjekte referenzieren.

Auf Basis der obigen Konfiguration kann der Agent die Server fetch und filesystem verwenden. Mit dem Erweiterungspaket oder einer aktuellen Version des Agents SDK kann die Einrichtung so aussehen:

from agents_mcp import Agent  # use agents_mcp extension if needed; otherwise from agents import Agent

agent = Agent(
    name="MCP Agent",
    instructions="You are a helpful assistant with access to both local tools and MCP-provided tools.",
    tools=[ /* any native tools, e.g. get_current_weather function */ ],
    mcp_servers=["fetch", "filesystem"]  # names as defined in mcp_agent.config.yaml
)

Wenn mcp_servers=["fetch", "filesystem"] angegeben wird, sucht das SDK diese Namen in der Konfigurationsdatei, startet die jeweiligen Server, führt die entsprechenden npx-Prozesse aus, wartet auf deren Bereitschaft, ruft die Tool-Discovery-Schnittstelle jedes Servers auf und ergänzt die gefundenen Werkzeuge in der Tool-Liste des Agenten.

Wer die MCP-Server lieber direkt im Code mit den offiziellen SDK-Klassen verwaltet, kann die Serverobjekte manuell erstellen:

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# Set up an MCP server for filesystem
fs_server = MCPServerStdio(
    name="FS MCP Server",
    params={
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
)
# Set up an MCP server for fetch
fetch_server = MCPServerStdio(
    name="Fetch MCP Server",
    params={
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-fetch"]
    }
)

async with fs_server as fs, fetch_server as fetch:
    agent = Agent(
        name="OpenAI Agent w/ MCP",
        instructions="Use the tools to access files and web content as needed.",
        mcp_servers=[fs, fetch]  # pass the server instances directly
    )
    result = await Runner.run(agent, "Find a file named 'data.txt' and summarize its contents.")

In diesem Beispiel werden zwei MCPServerStdio-Objekte manuell erstellt. Sie übernehmen den Prozessstart und die stdio-Kommunikation. Der Block async with stellt sicher, dass die Serverprozesse korrekt starten und anschließend sauber beendet werden. Die aktiven Serverobjekte fs und fetch werden direkt an mcp_servers übergeben, wodurch der Agent Zugriff auf deren Werkzeuge erhält. Aus Sicht des Agenten kann die finale Tool-Liste je nach konkreter Serverimplementierung beispielsweise Werkzeuge wie read_file vom Dateisystemserver oder fetch_url vom Fetch-Server enthalten.

Tool Discovery: Nach der Einrichtung sind die über MCP bereitgestellten Werkzeuge Teil der Planungslogik des Agenten. Wenn ein Nutzer den Agenten beispielsweise bittet, den Inhalt von data.txt zusammenzufassen, kann der Agent entscheiden, ein Datei-Lesewerkzeug des Filesystem-MCP-Servers zu verwenden, den Inhalt abzurufen und daraus eine Antwort zu erstellen.

Mehrere MCP-Server: Ein Agent kann gleichzeitig mit mehreren MCP-Servern verbunden werden. So könnte ein Agent beispielsweise einen Dateisystemserver, einen Slack-Server und einen Datenbankserver gemeinsam nutzen. Die Werkzeuge aller verbundenen Server stehen dem Agenten parallel zur Verfügung.

Wenn die Einrichtung erfolgreich abgeschlossen ist, steht ein OpenAI Agent mit aktivierter MCP-Unterstützung bereit. Der nächste Abschnitt zeigt ein einfaches Beispiel.

Beispiel: MCP in einem Agenten verwenden

Um das Konzept praktisch greifbar zu machen, betrachten wir ein einfaches Szenario. Angenommen, ein Agent soll eine lokale Wissensbasis durchsuchen und Fragen dazu beantworten. Der Filesystem-MCP-Server kann dem Agenten dafür erlauben, lokale Dateien zu lesen.

Schritt 1: Daten vorbereiten

Angenommen, es gibt ein Verzeichnis docs/, das Textdateien enthält, zum Beispiel .txt– oder .md-Dokumente. In diesem Verzeichnis könnte etwa eine Datei namens docs/ProjectPlan.txt mit Projektinformationen liegen.

Schritt 2: Filesystem-MCP-Server starten

Der Agent soll ausschließlich aus dem Verzeichnis docs/ lesen dürfen. Dafür wird der Filesystem-Server mit diesem Pfad gestartet. In der YAML-Konfiguration würden die Argumente so aussehen:

args: ["-y", "@modelcontextprotocol/server-filesystem", "docs"]

Die gleiche Konfiguration kann auch direkt im Code erzeugt werden:

fs_server = MCPServerStdio(
   name="FS",
   params={"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "docs"]}
)

Schritt 3: Agenten erstellen und ausführen

Der Agent kann nun eine Verbindung zum Filesystem-Server herstellen und eine Nutzerfrage beantworten. Das folgende vollständige Beispiel kombiniert Einrichtung und Ausführung:

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async def main():
    # Launch the filesystem MCP server (serving the ./docs folder)
    async with MCPServerStdio(
        name="FS",
        params={"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "docs"]}
    ) as fs:
        # Instantiate the agent with the MCP server
        agent = Agent(
            name="DocAssistant",
            instructions="You are an assistant who can access a document repository via tools.",
            mcp_servers=[fs]
        )
        # Ask the agent a question that requires using the file-reading tool
        query = "What does the project plan say about our launch date?"
        result = await Runner.run(agent, query)
        print(result.final_output)

# Run the async main
asyncio.run(main())

In diesem Code sendet Runner.run(agent, query) die Frage What does the project plan say about our launch date? an den Agenten. Der Agent erkennt anhand seiner Tool-Liste, dass er Werkzeuge des Filesystem-Servers verwenden kann, beispielsweise ein mögliches read_file(file_path)– oder search_files(keyword)-Werkzeug, abhängig von der konkreten Serverimplementierung. Da die Frage auf einen Projektplan verweist, kann der Agent nach einer passenden Datei suchen oder ProjectPlan.txt direkt lesen. Der MCP-Server führt die Dateioperation aus und gibt den Text an den Agenten zurück. Anschließend nutzt der Agent diesen Inhalt, um eine Antwort zum geplanten Starttermin zu erzeugen. Die finale Antwort steht in result.final_output.

Wenn ProjectPlan.txt beispielsweise den Satz The launch is expected in Q4 2025, approximately October enthält, könnte der Agent antworten, dass der Projektplan den Start im vierten Quartal 2025, ungefähr im Oktober, vorsieht. Diese Antwort entsteht, nachdem der Agent die Datei über MCP gelesen hat.

Agent ausführen und testen

Zum Ausführen des Agenten wird das Python-Skript gestartet oder der Code in einem kompatiblen Notebook ausgeführt. Der erste Start kann etwas länger dauern, insbesondere wenn MCP-Serverpakete zunächst heruntergeladen werden müssen. Außerdem können Verbindungsprotokolle erscheinen, beispielsweise Hinweise darauf, dass der Filesystem-MCP-Server gestartet wurde oder welche Werkzeuge verfügbar sind.

Es ist empfehlenswert, die Verbindung zu prüfen, indem die Werkzeuge nach dem Verbindungsaufbau explizit aufgelistet werden. Mit der Low-Level-API kann ein Aufruf wie tools = await fs.list_tools() anzeigen, welche Werkzeuge der Server bereitstellt.

Tool-Aufrufe testen

Testen Sie Fragen, die Tool-Nutzung erfordern. Sie können den Agenten beispielsweise bitten, alle Dateien im Repository aufzulisten. Der Agent kann dann ein list_files-Werkzeug des Filesystem-Servers aufrufen und das Ergebnis zurückgeben. Konsolenausgaben und Logs helfen dabei zu erkennen, welche Werkzeuge tatsächlich genutzt wurden. Das Agents SDK kann Tool-Aufrufe protokollieren, insbesondere wenn Debug-Logging aktiviert ist. Für Python aktiviert die folgende Anweisung Debug-Level-Logging für das OpenAI Agents SDK:

logging.getLogger("openai.agents").setLevel(logging.DEBUG)

Tracing und Debugging

Die OpenAI-Plattform enthält außerdem einen Trace Viewer für Agentenläufe. Sie können eine Trace-ID erzeugen und den Lauf in einen Trace-Kontextmanager einschließen, um die vollständige Ausführung auf der OpenAI-Plattform nachzuvollziehen. Ein Beispiel:

from agents import gen_trace_id, trace
trace_id = gen_trace_id()
print(f"View trace: https://platform.openai.com/traces/{trace_id}")
with trace(workflow_name="MCP Demo Workflow", trace_id=trace_id):
    result = await Runner.run(agent, query)

Dadurch werden die Unterhaltung und die Tool-Aufrufe auf der OpenAI-Plattform aufgezeichnet, sodass der Ablauf Schritt für Schritt überprüft werden kann. Das ist besonders hilfreich beim Debugging komplexer Agenten-Workflows.

Best Practices und häufige Stolperfallen

MCP verleiht Agenten umfangreiche Fähigkeiten, sollte aber sorgfältig eingesetzt werden. Die folgenden Best Practices verbessern Zuverlässigkeit, Sicherheit und Wartbarkeit.

Praxisnahe Einsatzbereiche für MCP und Agents

Die folgende Tabelle ordnet typische Agentenszenarien praktischen Beispielen zu und erklärt, wie die MCP-Komponenten zusammenspielen. Die linke Spalte beschreibt den Anwendungsfall, die mittlere Spalte nennt ein kompaktes Beispiel und die rechte Spalte erläutert MCP-Server, Werkzeuge und Prozessablauf.

Sicherheits- und Governance-Aspekte

Die folgende Checkliste fasst zentrale Sicherheits- und Governance-Themen für MCP-fähige Agenten zusammen. Sie erklärt, worauf zu achten ist, warum es wichtig ist und welche Kontrollen in der eigenen Umgebung eingesetzt werden können.

Die Zukunft von MCP und Agents

Die folgende Tabelle gibt einen vereinfachten Überblick über die wahrscheinliche Entwicklung von MCP und KI-Agenten. Sie zeigt breitere Plattformakzeptanz, Agent-zu-Agent-Kommunikation, Tool-Marktplätze, Agenten als Workflow-Komponenten und anbieterübergreifende Zusammenarbeit.

Häufig gestellte Fragen

Was ist das Model Context Protocol?

MCP (Model Context Protocol) ist ein offener Standard, der KI-Anwendungen mit externen Tools, Datenquellen und Workflows verbindet. Basierend auf einer Client-Host-Server-Architektur und dem JSON-RPC-Protokoll ermöglicht MCP KI-Agenten, verfügbare Fähigkeiten dynamisch zu erkennen und Tools über eine standardisierte Schnittstelle aufzurufen.

Wie unterscheidet sich MCP vom integrierten Tool Calling des OpenAI Agents SDK?

Das Agents SDK ermöglicht Entwicklern, Python-Funktionen als Werkzeuge zu registrieren. MCP erweitert dieses Modell, indem Agenten Werkzeuge zur Laufzeit von lokalen oder entfernten Servern über ein standardisiertes Protokoll entdecken können.

Kann MCP auch mit anderen Modellen als OpenAI-Modellen verwendet werden?

Ja. MCP ist modellunabhängig. Jedes Modell oder Framework mit einem MCP-Client kann mit MCP-Servern interagieren. Auch Anthropic Claude und Google DeepMind Gemini unterstützen MCP.

Welche Hauptkomponenten gehören zu einer MCP-Architektur?

Eine MCP-Bereitstellung umfasst einen Host, der Clients und Sicherheit verwaltet, Clients, die Sitzungen mit Servern aufrechterhalten, und Server, die Werkzeuge, Prompts und Ressourcen bereitstellen.

Welche Sicherheitsrisiken bestehen bei der Nutzung von MCP?

Wichtige Risiken sind Prompt Injection, bei der schädliche Anweisungen in externen Inhalten enthalten sind, Tool Poisoning, bei dem manipulierte Tool-Metadaten den Agenten täuschen, OAuth-Schwächen und Remote Code Execution. Auch Supply-Chain-Angriffe und unsichere Serverkonfigurationen sind relevant. Starke Authentifizierung, Eingabevalidierung, Least Privilege und Monitoring helfen, diese Risiken zu reduzieren.

Wie lassen sich Tool-Aufrufe beim Einsatz von MCP mit Agents debuggen?

Das OpenAI Agents SDK enthält nützliche Tracing-Funktionen. Trace-Kontextmanager und Debug-Logging zeigen, welche Werkzeuge ausgewählt wurden, welche Eingaben gesendet und welche Ausgaben zurückgegeben wurden. Entwickler können außerdem list_tools() auf einer MCP-Verbindung aufrufen, um zu prüfen, welche Werkzeuge der Server bereitstellt.

Welche Best Practices gelten für die Versionierung von MCP-Servern?

Verwenden Sie semantische Versionierung für Server und Tool-Definitionen. Machen Sie unterstützte Funktionen und Versionen in den Metadaten klar sichtbar. Wenn Werkzeuge geändert werden, aktualisieren Sie Versionsnummer oder Tool-Name und kommunizieren Sie die Änderung an Clients. Vermeiden Sie Tool-Caching, wenn sich Definitionen häufig ändern, und nutzen Sie invalidate_tools_cache(), um die verfügbare Tool-Liste zu aktualisieren.

Fazit

Das Model Context Protocol ist ein wichtiger Baustein für leistungsfähigere KI-Agenten. Es schließt die Lücke zwischen Sprachmodellen und realen Systemen, indem es Modellen eine standardisierte Möglichkeit bietet, mit externem Kontext, Tools und Daten zu arbeiten. Um MCP zu erkunden, können Sie folgende Schritte ausprobieren:

• Mit einer kleinen Demo starten: Richten Sie mithilfe dieses Artikels einen einfachen Agenten ein, der mit einem MCP-Server verbunden ist. Ein erstes Beispiel könnte ein Agent sein, der über MCP eine lokale Datei liest.
• Bestehende MCP-Server erkunden: Durchsuchen Sie offizielle MCP-Ressourcen und Community-Repositories nach Servern für Datenbanken, Webdienste, SaaS-Plattformen oder andere nützliche Tools.
• An der Community teilnehmen: Verfolgen Sie Diskussionen auf GitHub, Chat-Plattformen oder in Foren. Da MCP noch in Entwicklung ist, ist praktisches Feedback aus realen Projekten wertvoll.
• Eigenen Use Case finden: Überlegen Sie, welches Tool, welcher Dienst oder welche Datenquelle ihren Agenten nützlicher machen würde. Erstellen Sie anschließend einen kleinen MCP-Prototyp, um die Integration zu testen.
• Sicherheit priorisieren: Behalten Sie neue Sicherheitsempfehlungen im Blick und erwägen Sie MCP-aware Monitoring, etwa für Warnungen bei ungewöhnlichen Tool-Call-Mustern.

Durch MCP erhalten OpenAI Agents eine strukturierte Möglichkeit, mit digitalen Tools und Daten in ihrer Umgebung zu interagieren. Je stärker KI-Agenten sicher im Auftrag von Nutzern handeln können, desto wichtiger dürfte MCP als Teil dieses Ökosystems bleiben.