MCP und Connectors: Der universelle Standard

Das Model Context Protocol (MCP) ist ein offener Standard, der es Modellen ermöglicht, über ein einheitliches Protokoll mit externen Diensten zu interagieren. OpenAI Connectors setzen diesen Standard um, um Modelle direkt mit Drittanbieter-Tools innerhalb der Responses API zu verbinden.

Das Problem, das MCP löst

Das Kernproblem ist die Vermehrung von Integrationen: Die Verbindung von N Modellen mit M Diensten erfordert N×M individuelle Integrationen, die jeweils separat entwickelt und gewartet werden müssen. Jeder neue Dienst zwingt dazu, die Arbeit für jede Anwendung zu wiederholen, und jede API-Änderung gefährdet mehrere Integrationen.

MCP wandelt dieses Produkt in eine Summe um: Der Dienst stellt seine Fähigkeiten einmal über das Protokoll bereit, und jeder kompatible Client kann sie konsumieren. Dies ist dieselbe Logik wie bei Druckertreibern oder dem Language Server Protocol (LSP) in Code-Editoren – Standardisierung macht Integrationen nicht leistungsfähiger; sie macht sie wirtschaftlich tragfähig.

# Vor MCP: manuelle Integration für jeden Dienst
tools = [
    # Funktion für Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funktion für Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funktion für Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... Dutzende von Funktionen zur Wartung
]

Mit MCP stellt jeder Dienst seine Fähigkeiten über ein standardisiertes Protokoll bereit, und das Modell konsumiert sie direkt.

MCP-Architektur

Das Protokoll definiert drei Konzepte:

MCP-Server: Ein Dienst, der Tools, Ressourcen und Prompts bereitstellt
MCP-Client: Das System, das die Fähigkeiten des Servers konsumiert
Transport: Der Kommunikationskanal zwischen Client und Server

# Ein MCP-Server stellt bereit:
# - Tools: Aktionen, die das Modell ausführen kann
# - Ressourcen: Daten, die das Modell lesen kann
# - Prompts: Vordefinierte Prompt-Vorlagen

OpenAI Connectors verwenden

Connectors sind MCP-Server, die bereits gehostet und gewartet werden: Sie deklarieren sie, authentifizieren sich und konsumieren sie. Dies ist der natürliche Einstiegspunkt – es besteht kein Bedarf, einen MCP-Server zu schreiben, um mit einem gemeinsamen Dienst zu kommunizieren, der bereits von jemandem verbunden wurde.

from openai import OpenAI

client = OpenAI()

# Konzeptionelles Beispiel: Connector zu einem externen Dienst
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Erstellen Sie einen Jira-Ticket für den Fehler auf der Startseite",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

Der Parameter require_approval steuert die menschliche Validierung:

"always": Jede Aktion erfordert eine Genehmigung
"never": Automatische Ausführung

Einen MCP-Server in Python erstellen

Das Schreiben eines eigenen Servers lohnt sich, sobald ein interner Dienst von mehreren Anwendungen erreichbar sein muss. Die Logik ist dieselbe wie bei einer internen API: Sie schreiben ihn einmal, sauber, mit eigenen Zugriffsregeln – und jede Anwendung profitiert, ohne die Integrationsschicht neu zu erfinden.

from mcp.server import Server
from mcp.types import Tool, TextContent
import json

server = Server("my-crm")

@server.tool()
async def search_client(term: str, field: str = "name") -> str:
    """Suche nach einem Kunden im internen CRM.

    Args:
        term: Der Suchbegriff (Name, E-Mail oder ID)
        field: Das Feld, in dem gesucht werden soll (Name, E-Mail, ID)
    """
    # Ihre Geschäftslogik
    results = await crm_database.search(term, field=field)
    return json.dumps([{
        "id": r.id,
        "name": r.name,
        "email": r.email,
        "company": r.company
    } for r in results])

@server.tool()
async def create_opportunity(
    client_id: str,
    title: str,
    amount: float,
    probability: int
) -> str:
    """Erstellen Sie eine Verkaufschance im CRM.

    Args:
        client_id: Kunden-Identifikator
        title: Titel der Chance
        amount: Geschätzter Betrag in Euro
        probability: Wahrscheinlichkeit des Abschlusses (0-100)
    """
    opp = await crm_database.create_opportunity(
        client_id=client_id,
        title=title,
        amount=amount,
        probability=probability
    )
    return json.dumps({"id": opp.id, "status": "created"})

MCP-Ressourcen bereitstellen

MCP unterscheidet zwischen Tools, die etwas tun, und Ressourcen, die etwas zum Lesen bereitstellen. Diese Unterscheidung ist wichtig, da sie das Risiko definiert: Eine Ressource wird konsultiert, ohne Nebenwirkungen, während ein Tool den Zustand der Welt verändern kann. Genehmigungssteuerelemente konzentrieren sich natürlicherweise auf letzteres.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Aktueller Status des Vertriebspipelines."""
    pipeline = await crm_database.get_pipeline()
    return json.dumps({
        "total_opportunities": pipeline.count,
        "total_value": pipeline.total_value,
        "by_stage": {
            "prospecting": pipeline.prospecting,
            "qualification": pipeline.qualification,
            "proposal": pipeline.proposal,
            "negotiation": pipeline.negotiation,
            "closing": pipeline.closing
        }
    })

@server.resource("crm://client/{client_id}")
async def client_profile(client_id: str) -> str:
    """Vollständiges Profil eines Kunden."""
    client = await crm_database.get_client(client_id)
    return json.dumps({
        "name": client.name,
        "email": client.email,
        "purchase_history": client.purchases,
        "satisfaction_score": client.nps
    })

Einen MCP-Server mit der Responses API verbinden

# MCP-Connector-Konfiguration im API-Aufruf
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Wie ist der Status unseres Vertriebspipelines? "
          "Erstellen Sie eine Chance für den Kunden CLI-789: "
          "Cloud-Migration, 50.000 Euro, 70 % Wahrscheinlichkeit.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Muster: Multi-Connector-Hub

Hier zeigt der Standard sein wahres Potenzial: Mehrere Server nebeneinander deklariert, wobei das Modell über sie hinweg komponiert – hier ein Ticket liest, dort einen Kunden sucht, eine Antwort anderswo schreibt. Ohne ein gemeinsames Protokoll würde dieser gleiche Fluss drei spezifische Integrationen und deren laufende Wartung erfordern.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Offene Jira-Tickets prüfen, eine Zusammenfassung an Slack senden "
          "und das Notion-Dashboard aktualisieren",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.example.com/jira",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "slack",
            "server_url": "https://mcp.example.com/slack",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "notion",
            "server_url": "https://mcp.example.com/notion",
            "require_approval": "always"
        }
    ]
)

Sicherheit und Authentifizierung

# MCP-Server verarbeiten Authentifizierung über Header
# oder Tokens in der Konfigurations-URL

# Best Practice: Verwenden Sie immer require_approval für Schreibaktionen
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Menschliche Validierung
        "allowed_tools": ["search_client", "client_profile"],  # Tools einschränken
    }
]

Kernaussagen

MCP ist ein offener Standard zur Verbindung von Modellen mit externen Diensten
OpenAI Connectors integrieren MCP direkt in die Responses API
Erstellen Sie Ihre eigenen MCP-Server, um interne Dienste bereitzustellen
Verwenden Sie require_approval, um die menschliche Validierung zu steuern
Verbinden Sie mehrere MCP-Server in einem einzigen Aufruf für übergreifende Arbeitsabläufe