MCP und Connectors: Verbindung externer Dienste
Auf dieser Seite
Aktualisiert am 2. November 2026 — Agent Builder. Am 3. Juni 2026 kündigte OpenAI den Ausstieg aus dem Agent Builder an, der für den 30. November 2026 geplant ist; ChatKit bleibt weiterhin verfügbar. Ab jetzt weisen OpenAI-Benutzer auf das Agents SDK oder die Agenten im ChatGPT-Workspace hin. Seit dem 10. September 2026 bietet OpenAI eine öffentliche Beta-Version der Agents API an, die die Agenten-Orchestrierung hostet (siehe ChatGPT im Jahr 2026, Lektion 10).
MCP und Connectors: Verbindung externer Dienste
Das Model Context Protocol (MCP) ist ein offener Standard, der es Ihrem Agenten ermöglicht, sich mit externen Diensten auf standardisierte Weise zu verbinden. Anstatt für jeden Dienst eigene Integrationen zu schreiben, schließen Sie einfach einen MCP-Server an, und Ihr Agent erhält sofort neue Werkzeuge. Wo Sie früher möglicherweise dreihundert Zeilen Code für einen GitHub-Client geschrieben hätten, benötigen Sie nun lediglich eine einzige Server-Deklaration.
Was ist MCP?
MCP ist ein offener Standard, der definiert, wie ein Client – Ihr Agent – mit einem Server, also einem externen Dienst, kommuniziert. Jeder MCP-Server stellt Werkzeuge bereit, die Ihr Agent verwenden kann. Das Protokoll übernimmt Transport, Serialisierung und die Entdeckung von Werkzeugen. Letzteres ist für den täglichen Arbeitsablauf am wertvollsten: Der Agent fragt den Server ab, um zu sehen, was er kann, sodass Sie keine Liste manuell pflegen müssen. Das Agents SDK verfügt über native MCP-Unterstützung und verbindet sich mit jedem kompatiblen Server.
Verbindung eines MCP-Servers
Das SDK stellt die Klasse MCPServerStdio für lokale Server bereit, die über stdin/stdout kommunizieren – in der Regel ein Node-Prozess, der mit npx gestartet wird.
from agents import Agent, Runner
from agents.mcp import MCPServerStdio
# Lokaler MCP-Server (kommuniziert über stdin/stdout)
file_server = MCPServerStdio(
name="Datei-Manager",
command="npx",
args=["-y", "@modelcontextprotocol/server-filesystem", "/pfad/zum/ordner"],
)
async def main():
async with file_server:
agent = Agent(
name="Datei-Agent",
instructions="Sie verwalten Dateien für den Benutzer.",
mcp_servers=[file_server],
)
result = await Runner.run(agent, "Listen Sie die Dateien im Hauptordner auf.")
print(result.final_output)
Der async with-Block ist nicht nur Dekoration: Er startet den Server-Prozess, entdeckt seine Werkzeuge und beendet ihn sauber, sobald der Block verlassen wird. Ein Agent, der außerhalb dieses Kontexts erstellt wird, verfügt über keine Werkzeuge.
Remote-MCP-Server über SSE
Für gehostete Server verwenden Sie MCPServerSse und den SSE (Server-Sent Events)-Transport. Die Logik bleibt gleich; nur die URL und die Authentifizierungs-Header ändern sich.
from agents.mcp import MCPServerSse
github_server = MCPServerSse(
name="GitHub",
url="https://mcp.github.com/sse",
headers={"Authorization": "Bearer ghp_your_token"},
)
async def main():
async with github_server:
agent = Agent(
name="DevOps-Agent",
instructions="Sie verwalten GitHub-Repositories.",
mcp_servers=[github_server],
)
result = await Runner.run(
agent,
"Erstellen Sie ein Issue im Repository my-project mit dem Titel 'Critical Bug'"
)
print(result.final_output)
OpenAI Connectors
Neben MCP bietet OpenAI Connectors an, die direkt auf der Plattform verwaltet werden. Sie integrieren sich in den Agent Builder und bleiben über das SDK nutzbar, ohne dass Sie einen Server hosten müssen.
from agents import Agent, Runner
# Connectors, die im Agent Builder konfiguriert wurden, sind automatisch verfügbar
agent = Agent(
name="CRM-Agent",
instructions="""Sie sind ein CRM-Assistent. Verwenden Sie die Connectors,
um Zugriff auf Salesforce, HubSpot und Google Workspace zu erhalten.""",
model="gpt-5.6-terra",
# Connectors sind mit der Agenten-Konfiguration auf der Plattform verknüpft
)
Das Fehlen eines mcp_servers-Parameters ist sinnvoll: Connectors sind an die Agenten-Konfiguration auf der Plattform gebunden. Sie übernehmen die OAuth-Authentifizierung, Paginierung und die Begrenzung der Anfragehäufigkeit (Rate Limiting) für Sie – drei Bereiche, die bei manueller Handhabung erhebliche Zeit in Anspruch nehmen.
Kombination von MCP und Funktionswerkzeugen
Sie müssen sich nicht entscheiden. Ein einzelner Agent kann einen MCP-Server für den Datenzugriff und Ihre eigenen Funktionen für geschäftliche Logiken verwenden, die Sie nicht delegieren möchten.
from agents import Agent, Runner, function_tool
from agents.mcp import MCPServerStdio
@function_tool
def calculate_invoice(amount_excl_tax: float, vat_rate: float = 20.0) -> str:
"""Berechnet den Gesamtbetrag einschließlich Steuer für eine Rechnung."""
amount_incl_tax = amount_excl_tax * (1 + vat_rate / 100)
return f"Auskl. MwSt: €{amount_excl_tax}, MwSt {vat_rate}%: €{amount_excl_tax * vat_rate / 100:.2f}, Inkl. MwSt: €{amount_incl_tax:.2f}"
db_server = MCPServerStdio(
name="Datenbank",
command="npx",
args=["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"],
)
async def main():
async with db_server:
agent = Agent(
name="Buchhaltungs-Agent",
instructions="""Sie bearbeiten die Buchhaltung.
Verwenden Sie die Datenbank für Kundendaten
und die Berechnungsfunktion für Rechnungen.""",
tools=[calculate_invoice],
mcp_servers=[db_server],
)
result = await Runner.run(
agent,
"Rufen Sie Bestellungen für den Kunden Alice ab und berechnen Sie die Gesamtrechnung"
)
print(result.final_output)
Die Mehrwertsteuerberechnung bleibt in Ihrem Code, wo sie testbar und überprüfbar ist; die Abrufung von Bestellungen erfolgt über den PostgreSQL-MCP-Server. Das ist die Aufteilung, auf die Sie abzielen sollten.
Filtern von MCP-Werkzeugen
Ein MCP-Server kann Dutzende von Werkzeugen bereitstellen, von denen die meisten für Ihren Anwendungsfall irrelevant sind – und jedes davon verbraucht Kontext und erhöht das Risiko eines unangemessenen Aufrufs. Beginnen Sie damit, zu prüfen, was tatsächlich verfügbar ist.
server = MCPServerStdio(
name="GitHub",
command="npx",
args=["-y", "@modelcontextprotocol/server-github"],
)
# Sie können beim Verbinden filtern
async with server:
tools = await server.list_tools()
# Verfügbare Werkzeuge inspizieren
for tool in tools:
print(f"- {tool.name}: {tool.description}")
Handhabung von MCP-Fehlern
Ein MCP-Server ist ein Prozess oder ein externer Dienst: Er kann beim Start versagen, die Verbindung verlieren oder ein abgelaufenes Token aufweisen. Planen Sie einen degradierten Modus vor, anstatt dass die Ausnahme an den Benutzer weitergegeben wird.
from agents.mcp import MCPServerStdio
async def create_agent_with_mcp():
server = MCPServerStdio(
name="Externer Dienst",
command="npx",
args=["-y", "my-mcp-server"],
)
try:
async with server:
agent = Agent(
name="Mein Agent",
instructions="Verwenden Sie den externen Dienst.",
mcp_servers=[server],
)
result = await Runner.run(agent, "Führen Sie die Aufgabe aus.")
return result.final_output
except Exception as e:
# Fallback ohne MCP
fallback_agent = Agent(
name="Mein Agent (degradierte Modus)",
instructions="Der externe Dienst ist nicht verfügbar. Informieren Sie den Benutzer.",
)
result = await Runner.run(fallback_agent, "Der Dienst ist nicht verfügbar.")
return result.final_output
Der Fallback-Agent gibt nicht vor zu funktionieren: Er kündigt die Nichtverfügbarkeit an. Ein Agent, der eine Antwort erfindet, wenn seine Datenquelle ausgefallen ist, kostet weit mehr als einer, der zugibt, dass er nicht weitermachen kann.
Kernaussagen
- MCP ist ein offenes Protokoll zur Verbindung externer Dienste mit Ihrem Agenten
- Verwenden Sie
MCPServerStdiofür lokale Server undMCPServerSsefür Remote-Server - OpenAI Connectors sind verwaltete Integrationen auf der Plattform
- Sie können Funktionswerkzeuge und MCP-Server im selben Agenten kombinieren
- Handhaben Sie Verbindungsfehler von MCP mit einem degradierten Modus