AgentGrade
EnglishEspañolDeutsch日本語中文
← Wissensdatenbank

MCP — Model Context Protocol

Was ist MCP?

MCP (Model Context Protocol) ist der offene Standard, um KI-Assistenten mit externen Tools, Datenquellen und Services zu verbinden. Dein Server exponiert „Tools“ — benannte Funktionen mit Beschreibungen und Input-Schemas — und das KI-Modell entscheidet mitten im Gespräch, wann es sie aufruft. Ende 2024 von Anthropic geschaffen und inzwischen von Claude, ChatGPT, IDE-Plugins und einer wachsenden Liste von Agent-Frameworks unterstützt, spielt MCP für KI dieselbe Rolle wie USB für Hardware: ein Kabel, jedes Gerät.

Warum MCP wichtig ist

Vor MCP verband sich jeder KI-Assistent mit jedem externen Service über maßgeschneiderten „Plugin“- oder „Function Calling“-Code. Jeder KI-Anbieter hatte sein eigenes Format. Jede Tool-Integration musste pro Anbieter neu geschrieben werden — einmal für Claude, nochmal für ChatGPT, nochmal für Cursor, nochmal für einen Custom Agent.

MCP standardisiert die Schnittstelle. Ein einziger MCP-Server funktioniert mit jedem MCP-kompatiblen Client. Das bedeutet:

Es ist der Unterschied zwischen proprietären Druckertreibern und dem IP-Standard. Das Protokoll ist langweilig. Sich darauf zu standardisieren erschließt ein Ökosystem.

So funktioniert es

Die gesamte Kommunikation läuft über JSON-RPC 2.0 per HTTP POST an einen einzigen Endpoint (z. B. /mcp):

  1. Der Client sendet initialize, um die Session aufzubauen
  2. Der Server antwortet mit Name, Version und Capabilities
  3. Der Client sendet tools/list, um verfügbare Tools zu entdecken
  4. Der Server gibt eine Liste von Tools mit Beschreibungen und Input-Schemas zurück
  5. Der Client sendet tools/call mit Tool-Namen und Argumenten
  6. Der Server führt das Tool aus und liefert das Ergebnis

MCP vs. Alternativen

AspektOpenAI Function CallingOpenAPI / SwaggerMCP
AnbieterbindungEin AnbieterAnbieterneutralAnbieterneutral
Entworfen fürLLM-Tool-AufrufeREST-APIsKI-Agenten
DiscoveryIm Client hartkodiertStatische Spec-DateiZur Laufzeit via tools/list
StreamingEingeschränktNativ keinsEingebaut (SSE / Streamable HTTP)
Zustandsbehaftete SessionsNeinNeinJa (initialize → Aufrufe)
AuthClient-seitige KeysAPI-Keys, OAuthOAuth, Bearer, custom
ÖkosystemNur OpenAIReif, breitNeu, wächst schnell

OpenAPI beschreibt eine REST-API zur Designzeit. MCP beschreibt eine lebendige Tool-Oberfläche zur Laufzeit. Beide ergänzen sich — viele MCP-Server kapseln bestehende OpenAPI-Services und exponieren sie als agent-aufrufbare Tools.

Implementierungsbeispiel

app.post('/mcp', (req, res) => {
  const { method, params, id } = req.body;

  if (method === 'initialize') {
    return res.json({ jsonrpc: '2.0', id, result: {
      protocolVersion: '2024-11-05',
      capabilities: { tools: {} },
      serverInfo: { name: 'my-service', version: '1.0' }
    }});
  }

  if (method === 'tools/list') {
    return res.json({ jsonrpc: '2.0', id, result: {
      tools: [{
        name: 'search',
        description: 'Search for items',
        inputSchema: {
          type: 'object',
          properties: { query: { type: 'string' } },
          required: ['query']
        }
      }]
    }});
  }

  if (method === 'tools/call') {
    const { name, arguments: args } = params;
    return res.json({ jsonrpc: '2.0', id, result: {
      content: [{ type: 'text', text: 'Search results...' }]
    }});
  }

  res.json({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' }});
});

Transport-Optionen

MCP unterstützt drei Transporte — wähle danach, wo dein Client läuft:

Wenn ein MCP-Server mit Claude Desktop und der Claude-Web-App und ChatGPT und Cursor funktionieren soll, liefere Streamable HTTP. Fast alle sprechen es inzwischen.

CORS — Pflicht für browserbasierte Agenten

Eine wachsende Klasse von MCP-Clients läuft im Browser: Claude.ai im Web, ChatGPT im Browser, Browser-Extensions und eingebettete Chat-Widgets. Wenn JavaScript auf claude.ai fetch('https://yourdomain.com/mcp') aufruft, macht der Browser zwei Dinge von sich aus:

  1. Er sendet den Request tatsächlich an deinen Server.
  2. Er weigert sich, die Antwort an das anfragende JavaScript zurückzugeben — es sei denn, die Antwort deines Servers enthält einen Access-Control-Allow-Origin-Header, der claude.ai (oder *) nennt.

Ohne CORS-Header läuft dein Server also einwandfrei und liefert 200, aber der MCP-Client im Browser-Tab sieht einen Netzwerkfehler und kann den Body nie lesen. Das ist der Browser, der Nutzer davor schützt, dass eine Site stillschweigend authentifizierte Requests an eine andere sendet. Server-seitige Clients wie Claude Desktop oder die MCP-CLI unterliegen dem nicht — kein Browser kontrolliert die Antwort — weshalb ein Endpoint in Desktop funktionieren und im Web scheitern kann.

Um browserbasierte MCP-Clients zu unterstützen, sende diese Header bei jeder /mcp-Antwort und behandle den OPTIONS-Preflight:

app.use('/mcp', (req, res, next) => {
  res.set('Access-Control-Allow-Origin', '*');
  res.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  res.set('Access-Control-Allow-Headers', 'Content-Type, Accept, Authorization');
  if (req.method === 'OPTIONS') return res.sendStatus(204);
  next();
});

Wildcard vs. spezifischer Origin

Access-Control-Allow-Origin: * ist für öffentliche, read-only MCP-Endpoints in Ordnung. Wenn dein MCP-Endpoint Authentifizierung erfordert oder Tool-Aufrufe kostenpflichtig sind, gib einen spezifischen Origin zurück (oder spiegle den Origin-Header des Requests gegen eine Allowlist) und setze Access-Control-Allow-Credentials: true. Wildcard-Origins können laut CORS-Spezifikation nicht zusammen mit Credentials verwendet werden.

Warum der Preflight wichtig ist

Bei einem „einfachen“ Request — ein schlichtes GET oder ein POST mit Content-Type: text/plain — sendet der Browser ihn einfach, und nur die Antwort wird blockiert. Aber MCP nutzt POST mit Content-Type: application/json, was der Browser für riskant genug hält, um vorher nachzufragen. Vor dem eigentlichen POST sendet der Browser also einen OPTIONS-Request an deinen Server: „Akzeptierst du ein POST von diesem Origin mit diesen Headern?“

Antwortet dein Server auf das OPTIONS nicht mit einem 2xx-Status und den richtigen CORS-Headern, bricht der Browser das POST komplett ab — es erreicht deinen Server nie. Deshalb muss CORS-Middleware beides behandeln: den OPTIONS-Preflight und das eigentliche POST.

Authentifizierung

Für öffentliche Read-only-Server ist keine Auth in Ordnung. Für private oder kostenpflichtige Tools unterstützt MCP:

OAuth ist der richtige Default, wenn Menschen für sich selbst autorisieren. Bearer-Tokens passen für Service-zu-Service. x402 passt, wenn Aufrufe kostenpflichtig und zustandslos sind.

Wer MCP nutzt

AgentGrade veröffentlicht seinen eigenen MCP-Server (com.agentgrade/mcp-server) für Agenten, die Sites aus einem MCP-fähigen Client heraus scannen wollen.

Häufige Fehler und Debugging

Zentrale Konzepte

Häufig gestellte Fragen

Ist MCP ein Anthropic-Protokoll oder ein offener Standard?

Es wurde von Anthropic geschaffen und ist als offene Spezifikation veröffentlicht. Die Referenzimplementierungen sind MIT-lizenziert. OpenAI, IDE-Anbieter und Agent-Frameworks haben es unabhängig von Anthropic übernommen — es ist inzwischen ein Community-Standard, kein Ein-Anbieter-Protokoll.

Wie unterscheidet sich MCP von OpenAIs Function Calling?

Function Calling ist ein Feature der API eines Anbieters. MCP ist ein Protokoll auf Transportebene, das jeder Client sprechen kann. Bei Function Calling leben Modell und Tool-Definition im selben OpenAI-Request; bei MCP lebt das Modell beim Client und die Tools bei deinem Server, und beide kommunizieren über ein definiertes Wire-Format.

Soll ich meine bestehende REST-API als MCP exponieren oder der KI einfach meine OpenAPI-Spec geben?

Beides funktioniert, zielt aber auf verschiedene Clients. Modelle mit nativem MCP-Support (Claude, Cursor) rufen Tools direkt via MCP auf. Modelle, die OpenAPI-Spezifikationen lesen, brauchen die Spec in ihrem Prompt oder Function-Call-Format. Wenn du nur Zeit für eines hast, liefere MCP — die meisten Agent-Clients bevorzugen es wegen der Laufzeit-Discovery. Wenn du bereits eine OpenAPI-Spec hast, ist das Kapseln in einen MCP-Server eine Sache von ein paar hundert Zeilen.

Braucht MCP WebSockets?

Nein. Der aktuelle Standard ist Streamable HTTP — schlichtes POST an einen Endpoint, mit optionalem SSE-Streaming darin. Frühere Entwürfe nutzten WebSockets; dieser Weg wurde aufgegeben, weil schlichtes HTTP CDNs, Load Balancer und Firmen-Firewalls ohne Konfiguration durchquert.

Können MCP-Server für Tool-Aufrufe Geld verlangen?

Ja. Das Protokoll enthält keine Zahlung, aber du kannst x402 darüberlegen: Lass deinen Server bei tools/call HTTP 402 zurückgeben, bis der Agent eine gültige Zahlungsquittung anhängt. Das ist eines der aktivsten Muster im Agent-Ökosystem.

Wie liste ich meinen MCP-Server in der Registry?

Reiche ein Manifest bei registry.modelcontextprotocol.io ein. Smithery.ai spiegelt die Registry und ergänzt Discovery-Features. Das Listing ist kostenlos und die Review-Warteschlange kurz.

Warum ist mein MCP-Server langsam?

Das Protokoll selbst ist günstig — JSON-RPC über HTTP. Langsamkeit liegt fast immer an (a) der Tool-Implementierung oder (b) einem kalten Serverless-Start. Profile den tools/call-Handler, bevor du den Transport beschuldigst.

Brauche ich einen eigenen Server pro Tool oder einen Server mit vielen Tools?

Ein Server mit vielen Tools ist die Norm. Gruppiere Tools nach logischem Service (z. B. alle GitHub-Operationen in einem Server). Clients können sich mit mehreren Servern gleichzeitig verbinden, daher lohnt sich Aufteilen nur, wenn Berechtigungen oder Hosting-Anforderungen abweichen.

Reifegrad der Spezifikation

Formale Spezifikation. MCP wird von Anthropic mit einer versionierten Spec gepflegt. Aktuelle Protokollversion: 2024-11-05. Nativ unterstützt von Claude, ChatGPT, Cursor und den meisten Agent-Frameworks. Der Streamable-HTTP-Transport ist stabil und wird von jedem großen Client genutzt.

Mehr erfahren

Verwandte Themen

Verwandt: Was ist KI-Agent-Readiness? · Jetzt testen: MCP Server Tester