Model Context Protocol (MCP) für Entwickler: Server, Clients, Sicherheit
Wer KI-Agenten an eigene Systeme anbindet, schreibt dieselbe Anbindung schnell mehrfach: einmal als Tool für Claude, einmal für das OpenAI Agents SDK, einmal für LangChain. Das Model Context Protocol (MCP) löst das auf Protokollebene. Dieser Leitfaden richtet sich an Entwickler und IT-Leitung und zeigt, wie MCP technisch funktioniert, wie Sie Server bauen und was Sie bei der Sicherheit beachten müssen. Stand: November 2026, Spezifikation in der Revision 2026-07-28.
Was ist MCP und wofür wird es eingesetzt?
MCP ist ein offenes Protokoll, das festlegt, wie eine KI-Anwendung mit externen Datenquellen und Werkzeugen spricht. Ein MCP-Server stellt Fähigkeiten bereit, jeder MCP-fähige Client kann sie nutzen. Damit wird die Anbindung an ein ERP, ein Ticketsystem oder eine Dokumentenablage zu einer wiederverwendbaren Komponente statt zu Framework-Code.
Die Spezifikation nennt als Vorbild ausdrücklich das Language Server Protocol: So wie LSP die Unterstützung von Programmiersprachen über viele Editoren hinweg vereinheitlicht hat, vereinheitlicht MCP die Anbindung von Kontext und Werkzeugen an KI-Anwendungen.
Die Begriffsdefinition und die Bedeutung für Entscheider finden Sie im Lexikoneintrag Model Context Protocol (MCP): Definition und Bedeutung für Unternehmen. Dieser Artikel geht einen Schritt weiter: Er erklärt die Protokollmechanik, die Transporte, den Bau eines Servers und die Sicherheitsanforderungen aus Entwicklersicht. Wer dagegen wissen will, wie MCP-Server im Unternehmen an SAP, Microsoft 365 oder das CRM angebunden und betrieben werden, findet das im Leitfaden MCP-Server: KI-Agenten standardisiert an Systeme anbinden. Dort steht die Systemsicht im Vordergrund, hier die Protokoll- und Framework-Sicht.
Typische Einsatzfälle:
- Lesender Zugriff auf Fachdaten: Ein Agent fragt Artikelstammdaten, offene Tickets oder Lieferscheine ab.
- Schreibende Aktionen: Ein Agent legt einen Angebotsentwurf an oder kommentiert ein Ticket – idealerweise mit Bestätigung durch einen Menschen.
- Entwicklerwerkzeuge: Coding-Agenten greifen über MCP auf Issue-Tracker, Datenbanken oder interne Dokumentation zu.
- Gemeinsame Schicht für mehrere Agenten: Vertriebs-, Service- und Wissensagenten nutzen denselben Server für dasselbe Quellsystem.
Wie funktioniert MCP technisch?
MCP überträgt Nachrichten im Format JSON-RPC 2.0 zwischen drei Rollen: Host, Client und Server. Der Host ist die KI-Anwendung, der Client ist der Verbinder im Host, der Server liefert Fähigkeiten. Seit der Revision 2026-07-28 ist das Protokoll zustandslos: Jede Anfrage trägt Protokollversion und Client-Fähigkeiten selbst mit.
Rollen
Die Spezifikation unterscheidet:
- Host: die Anwendung, die Verbindungen aufbaut, etwa eine Chat-Oberfläche, eine IDE oder Ihr eigener Agent.
- Client: der Verbinder innerhalb des Hosts, der mit genau einem Server spricht.
- Server: der Dienst, der Kontext und Fähigkeiten bereitstellt.
Bausteine auf der Serverseite
Ein Server bietet drei Arten von Fähigkeiten an:
- Tools sind Funktionen, die das Modell aufruft. Sie werden mit
tools/listgefunden und mittools/callausgeführt. Eingaben beschreibt ein JSON Schema (inputSchema), optional auch die Ausgabe (outputSchemamitstructuredContent). - Resources sind Daten und Kontext, etwa eine Datei oder ein Datensatz, adressiert über eine URI.
- Prompts sind vorgefertigte Nachrichten-Vorlagen und Abläufe, die der Nutzer auswählt.
Die Spezifikation beschreibt Tools ausdrücklich als „model-controlled": Das Modell entscheidet anhand des Kontexts, welches Tool es aufruft. Ressourcen und Prompts steuern eher Anwendung oder Nutzer.
Was sich mit der Revision 2026-07-28 geändert hat
Wer ältere Tutorials liest, stößt auf Begriffe, die es so nicht mehr gibt. Laut Changelog gilt seit 2026-07-28:
- Der
initialize-Handshake ist entfallen. Jede Anfrage trägt in_metadie Protokollversion und die Client-Fähigkeiten. - Server müssen die Methode
server/discoveranbieten, mit der Clients Versionen und Fähigkeiten vorab abfragen können. - Protokoll-Sessions und der Header
Mcp-Session-Idsind entfernt. Braucht ein Server Zustand über mehrere Aufrufe, gibt er ein eigenes Handle zurück, das als normales Tool-Argument weitergereicht wird. - Server senden keine eigenen Anfragen mehr an den Client. Braucht ein Server Rückfragen, etwa eine Eingabe des Nutzers, antwortet er mit einem
InputRequiredResult; der Client wiederholt die ursprüngliche Anfrage mit den Antworten (Multi Round-Trip Requests). - Roots, Sampling und Logging sind als veraltet markiert. Neue Implementierungen sollen sie nicht mehr einbauen.
- Tasks für lang laufende Vorgänge sind aus dem Kern in eine offizielle Erweiterung gewandert.
Für Sie als Entwickler heißt das: Ein MCP-Server verhält sich heute eher wie eine zustandslose HTTP-API als wie eine dauerhafte Sitzung. Das passt gut zu Load Balancern und mehreren Server-Instanzen, weil keine Sitzung an einer Instanz hängt.
Welche Transporte gibt es: stdio oder Streamable HTTP?
Die Spezifikation definiert zwei Standard-Transporte. Bei stdio startet der Client den Server als Unterprozess und tauscht zeilenweise JSON-RPC über Standardein- und -ausgabe aus. Bei Streamable HTTP läuft der Server als eigener Dienst mit einem einzigen HTTP-Endpunkt. Lokal passt stdio, für geteilte und entfernte Server Streamable HTTP.
stdio
stdio eignet sich für Werkzeuge auf dem Rechner des Nutzers, etwa Zugriff auf ein lokales Repository. Der Server sieht nur seinen Client, ist nicht über das Netz erreichbar und bekommt Zugangsdaten aus Umgebungsvariablen. Die Security Best Practices empfehlen stdio ausdrücklich für lokal laufende Server, weil damit nur der startende Client Zugriff hat.
Streamable HTTP
Für Server, die mehrere Nutzer oder mehrere Agenten bedienen, ist Streamable HTTP der Standard. Laut Transport-Spezifikation gilt:
- Der Server stellt genau einen MCP-Endpunkt bereit, zum Beispiel
https://example.com/mcp, der POST annimmt. - Jede Nachricht ist ein eigener POST. Die Antwort kommt als einzelnes JSON-Objekt oder als Server-Sent-Events-Strom, der zu genau dieser Anfrage gehört.
- Jede Anfrage trägt die Header
MCP-Protocol-Version,Mcp-Methodund bei Tool-AufrufenMcp-Name. Damit können Gateways und Load Balancer routen, ohne den Body zu parsen. Der Server muss prüfen, dass Header und Body übereinstimmen. - Änderungsbenachrichtigungen, etwa eine geänderte Tool-Liste, abonniert der Client über
subscriptions/listen.
Streamable HTTP wurde mit der Protokollversion 2025-03-26 eingeführt und ersetzt den HTTP+SSE-Transport von 2024-11-05, der inzwischen als veraltet eingestuft ist. Neue Server sollten ihn nicht mehr anbieten.
Warum ein MCP-Server in vielen Agenten-Frameworks funktioniert
Der Kernnutzen von MCP liegt in der Wiederverwendung: Ein Server, den Sie einmal bauen, binden Claude, das OpenAI Agents SDK, LangChain und CrewAI über ihre eigenen MCP-Clients an. Die Anbindungslogik lebt dann an einer Stelle, nicht in jedem Framework neu. Unterschiede gibt es bei Transporten und unterstützten Bausteinen.
Wie die Frameworks MCP einbinden, laut jeweiliger Dokumentation (geprüft im November 2026):
| Client | Einbindung | Transporte | Hinweis |
|---|---|---|---|
| Claude Code | claude mcp add | stdio, HTTP | SSE als veraltet markiert |
| Claude API | MCP-Connector (Beta) | nur öffentliches HTTP | nur Tool-Aufrufe |
| OpenAI Agents SDK | MCPServerStdio, MCPServerStreamableHttp, HostedMCPTool | stdio, Streamable HTTP | Tool-Filter und Freigaben |
| LangChain | MCPAdapter aus langchain.mcp | stdio, Streamable HTTP | ab langchain[mcp] 1.4.0, Beta |
| CrewAI | Feld mcps am Agenten, MCPServerAdapter | stdio, SSE, Streamable HTTP | vor allem Tools |
Einige Details, die beim Bau eines Servers zählen:
- Claude Code speichert Server in drei Geltungsbereichen:
local,projectunduser. Projektweite Server stehen in einer.mcp.jsonim Repository und lassen sich so im Team teilen; laut Claude-Code-Dokumentation fragt Claude Code vor der Nutzung solcher projektweiten Server nach Freigabe. - Der MCP-Connector der Claude API verbindet entfernte Server direkt aus der Messages API, ohne eigenen Client. Laut Dokumentation werden derzeit nur Tool-Aufrufe unterstützt, und der Server muss öffentlich per HTTP erreichbar sein.
- Das OpenAI Agents SDK bietet laut Dokumentation statische und dynamische Tool-Filter sowie
require_approval, um einzelne Tools nur nach Freigabe auszuführen. MitHostedMCPToolruft die Responses API den entfernten Server selbst auf. - LangChain hat MCP mit Version 1.4.0 in das Paket
langchain.mcpübernommen; das früherelangchain-mcp-adaptersist laut LangChain-Dokumentation der Weg vor 1.4.0. - CrewAI integriert laut Dokumentation über den Adapter vor allem Tools; Prompts und Ressourcen werden nicht als CrewAI-Komponenten übernommen.
Welches Framework insgesamt zu Ihrem Team passt, behandelt der Vergleich der KI-Agenten-Frameworks; für MCP zählt vor allem, dass alle fünf denselben Server nutzen können.
Die praktische Folge: Legen Sie alles, was ein Agent zwingend braucht, als Tool an. Ressourcen und Prompts sind nützliche Ergänzungen für Clients, die sie unterstützen, aber kein verlässlicher gemeinsamer Nenner. Für fachliche Agenten, etwa im Vertrieb oder im technischen Service, ist ein gut geschnittener MCP-Server damit die Schicht, die mehrere Agenten gemeinsam nutzen.
Welche Voraussetzungen braucht ein MCP-Projekt?
Sie brauchen ein Quellsystem mit einer stabilen Schnittstelle, einen klaren Zuschnitt der Aktionen und ein Berechtigungskonzept. Technisch genügen ein offizielles SDK und eine Laufzeitumgebung. Organisatorisch muss feststehen, wer den Server betreibt, wer Tools freigibt und wer Zugriffe protokolliert.
Technik:
- Eine API, Datenbank oder Dateiablage, die der Server ansprechen darf – mit eigenem Dienstkonto oder delegierten Rechten.
- Ein offizielles SDK. Laut SDK-Übersicht gelten TypeScript, Python, C#, Go, Rust und Ruby als Tier 1, Java als Tier 2, Swift, PHP und Kotlin als Tier 3. Die SDKs übernehmen neue Protokollrevisionen nach eigenem Zeitplan; prüfen Sie daher in der jeweiligen Doku, welche Revision unterstützt wird.
- Für entfernte Server: HTTPS, ein Identitätsanbieter mit OAuth 2.1 und ein Betriebsort mit Logging.
Organisation:
- Ein fachlicher Eigentümer je Server, der entscheidet, welche Aktionen erlaubt sind.
- Eine Regel, welche Tools nur mit menschlicher Bestätigung laufen.
- Eine Freigabeliste, welche externen MCP-Server überhaupt genutzt werden dürfen.
Wie bauen Sie einen MCP-Server in Schritten?
Bauen Sie zuerst einen kleinen lesenden Server mit zwei bis drei Tools, testen Sie ihn lokal über stdio und erweitern Sie dann um Schreibaktionen, HTTP-Transport und Autorisierung. Entscheidend ist der Zuschnitt der Tools: wenige, klar benannte Aktionen mit präzisen Beschreibungen statt eines generischen Abfrage-Tools.
Schritt 1: Aktionen fachlich schneiden
Schreiben Sie auf, welche Fragen und Aktionen der Agent braucht, etwa „offene Tickets eines Kunden abrufen" oder „Angebotsentwurf anlegen". Jede Aktion wird ein Tool mit sprechendem Namen. Die Tools-Spezifikation empfiehlt Namen mit 1 bis 128 Zeichen aus Buchstaben, Ziffern, Unterstrich, Bindestrich und Punkt. Ein generisches run_sql ist bequem, gibt dem Modell aber deutlich mehr Spielraum als nötig.
Schritt 2: Server mit dem SDK aufsetzen
Das Python-SDK (Paket mcp, Version 2.3.0 auf PyPI, Stand November 2026) zeigt in seinem README einen minimalen Server mit der Klasse MCPServer:
from mcp.server import MCPServer
mcp = MCPServer("Demo")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Addiert zwei Zahlen."""
return a + b
@mcp.resource("greeting://{name}")
def greeting(name: str) -> str:
"""Begrüßt eine Person mit Namen."""
return f"Hello, {name}!"
Ein eigenes JSON Schema schreiben Sie dafür nicht: Laut README sind die Typannotationen a: int, b: int das Schema. Pflegen Sie den Docstring trotzdem sorgfältig – die Tool-Beschreibung ist das, was das Modell liest, und sie entscheidet, ob und wie es das Tool aufruft.
Schritt 3: Lokal testen
Laut README starten Sie den Server mit dem MCP Inspector zum Testen und alternativ über Streamable HTTP:
pip install "mcp[cli]"
uv run mcp dev server.py
uv run mcp run server.py --transport streamable-http
Danach binden Sie ihn in einen echten Client ein, etwa in Claude Code mit claude mcp add --transport http <name> <url> und der URL Ihres lokalen Endpunkts.
Schritt 4: Fehler sauber zurückgeben
Die Spezifikation unterscheidet zwei Fehlerarten. Protokollfehler (unbekanntes Tool, falsch geformte Anfrage) sind JSON-RPC-Fehler. Fachliche Fehler, etwa ein Datum in der Vergangenheit, gibt das Tool als Ergebnis mit isError: true zurück – mit einer Meldung, aus der das Modell lernen und den Aufruf korrigieren kann.
Schritt 5: Zustand über Handles abbilden
Braucht ein Ablauf Zustand, etwa einen Warenkorb oder einen Entwurf über mehrere Schritte, gibt ein Tool ein zufälliges, nicht erratbares Handle zurück, das folgende Aufrufe als Argument mitgeben. Der Server prüft bei jedem Aufruf, ob der Aufrufer zu diesem Handle berechtigt ist.
Schritt 6: Autorisierung und Betrieb
Für den entfernten Betrieb kommt OAuth dazu (siehe nächster Abschnitt), dazu Rate Limits, Protokollierung jedes Tool-Aufrufs und eine deterministische Reihenfolge in tools/list, die laut Spezifikation das Caching auf Client-Seite erleichtert.
Wie sichern Sie MCP-Server ab?
Behandeln Sie jeden Tool-Aufruf wie fremden Code mit Zugriff auf Ihre Systeme. Die Spezifikation verlangt Eingabeprüfung, Zugriffskontrolle, Rate Limits und bereinigte Ausgaben auf Serverseite. Entfernte Server sichern Sie mit OAuth 2.1 ab, wobei Tokens ausschließlich für genau diesen Server ausgestellt sein dürfen.
Autorisierung für HTTP-Server
Die Autorisierungs-Spezifikation ist für HTTP-Transporte gedacht; stdio-Server sollen ihr nicht folgen, sondern Zugangsdaten aus der Umgebung beziehen. Die wichtigsten Pflichten:
- Der MCP-Server ist ein OAuth-2.1-Resource-Server und muss Protected Resource Metadata nach RFC 9728 anbieten, damit Clients den Autorisierungsserver finden.
- Clients müssen Resource Indicators nach RFC 8707 senden, also im
resource-Parameter festlegen, für welchen MCP-Server das Token gilt. - Server müssen prüfen, dass ein Token für sie als Empfänger ausgestellt wurde, und dürfen keine anderen Tokens annehmen oder durchreichen.
- Tokens gehören in den
Authorization-Header, nie in die URL. - Für die Client-Registrierung sind Client ID Metadata Documents vorgesehen; Dynamic Client Registration ist seit 2026-07-28 als veraltet markiert.
Typische Angriffe und Gegenmaßnahmen
Die Security Best Practices beschreiben unter anderem:
- Token Passthrough: Ein Server reicht ein Client-Token ungeprüft an eine nachgelagerte API weiter. Folge: Kontrollen und Audit-Spur werden umgangen. Abhilfe: nur eigene, korrekt adressierte Tokens akzeptieren.
- Confused Deputy: Proxy-Server, die mit einer statischen Client-ID bei einer Dritt-API anfragen, können ohne eigene Zustimmungsseite pro Client missbraucht werden.
- Übernahme von Zustands-Handles: Wer ein Handle errät, darf damit nicht auf fremde Daten zugreifen. Handles an den authentifizierten Nutzer binden.
- SSRF: Ein bösartiger Server kann Clients über OAuth-Metadaten-URLs auf interne Adressen lenken. Clients sollen HTTPS erzwingen und private Adressbereiche blockieren.
- Kompromittierte lokale Server: Ein Startbefehl in der Client-Konfiguration ist ausführbarer Code. Clients mit Ein-Klick-Einrichtung müssen vorher den vollständigen Befehl anzeigen und eine Bestätigung einholen.
- Zu breite Scopes: Mit wenigen Basis-Scopes starten und weitere Rechte erst bei Bedarf anfordern.
Für lokale HTTP-Server kommt laut Transport-Spezifikation hinzu: den Origin-Header prüfen, um DNS-Rebinding abzuwehren, und nur an 127.0.0.1 statt an alle Schnittstellen binden.
Tool-Beschreibungen sind nicht vertrauenswürdig
Die Spezifikation stellt klar, dass Tool-Annotationen als nicht vertrauenswürdig gelten, solange sie nicht von einem vertrauenswürdigen Server stammen. Zudem soll immer ein Mensch Tool-Aufrufe ablehnen können. Praktisch: Nutzen Sie nur Server aus einer geprüften Liste, lassen Sie schreibende Tools bestätigen und rechnen Sie damit, dass Inhalte, die ein Server aus dem Internet holt, Prompt Injection enthalten können – darauf weist auch die Claude-Code-Dokumentation hin.
Grenzen und Risiken von MCP
MCP standardisiert die Verbindung, nicht die Qualität der Anbindung. Schlecht geschnittene Tools, fehlende Berechtigungen oder ein instabiles Quellsystem bleiben Probleme, egal welches Protokoll sie transportiert. Dazu kommen die schnelle Weiterentwicklung der Spezifikation und Unterschiede zwischen Clients.
- Bewegliche Spezifikation: Die Revision 2026-07-28 hat Handshake, Sessions und servergesteuerte Anfragen entfernt. Server, die gegen 2025-11-25 gebaut wurden, brauchen Rückwärtskompatibilität oder eine Migration. Planen Sie Updates fest ein.
- Ungleiche Client-Unterstützung: Nicht jeder Client kann Ressourcen, Prompts oder Rückfragen an den Nutzer. Testen Sie jeden Ziel-Client einzeln.
- Kontextlast: Jedes angebotene Tool landet mit Beschreibung im Kontext des Modells. Viele Server mit vielen Tools machen Auswahl und Kosten schlechter. Tool-Filter, wie sie das OpenAI Agents SDK anbietet, helfen.
- Wann MCP nicht passt: Für eine einzelne Funktion in genau einem Agenten, die sich nie ändert, ist ein direkt im Framework definiertes Tool einfacher. MCP lohnt sich, sobald mehrere Agenten oder Frameworks dieselbe Anbindung brauchen.
- Betrieb: Ein entfernter Server ist ein produktiver Dienst mit Monitoring, Updates und Zugriffsprotokoll – kein Skript, das man einmal startet.
Wie fangen Sie mit MCP an?
Beginnen Sie mit einem lesenden Server für ein System, das mehrere Agenten brauchen, binden Sie ihn lokal in zwei verschiedene Clients ein und vergleichen Sie das Verhalten. Erst wenn Zuschnitt und Beschreibungen tragen, kommen Schreibaktionen, HTTP-Betrieb und OAuth hinzu.
Ein pragmatischer Ablauf:
- Ein Quellsystem auswählen, das für mehrere Anwendungsfälle zählt, etwa die Dokumentenablage oder das Ticketsystem.
- Drei lesende Tools bauen und mit dem MCP Inspector testen.
- In zwei Clients einbinden, zum Beispiel Claude Code und einen Agenten mit dem OpenAI Agents SDK, um die Wiederverwendung zu prüfen.
- Schreibende Tools mit Bestätigung ergänzen und jeden Aufruf protokollieren.
- Auf Streamable HTTP umstellen, OAuth 2.1 mit Ihrem Identitätsanbieter einrichten und Scopes eng schneiden.
- Spezifikations-Changelog verfolgen und SDK-Versionen regelmäßig aktualisieren.
Ein bewährter Grundsatz: MCP-Server nach Quellsystem schneiden, nicht nach Agent. Ein Server pro System, den alle Agenten teilen, bleibt wartbar; ein Server pro Agent führt zu doppelter Logik. Wie solche Anbindungen in fachliche Agenten münden, zeigt die Übersicht zu KI-Agenten für Unternehmen.
Häufige Fragen
Welche MCP-Version ist aktuell?
Stand November 2026 ist die Spezifikation in der Revision 2026-07-28 aktuell. Sie hat MCP zustandslos gemacht: kein initialize-Handshake und keine Session-IDs mehr.
Brauche ich für einen MCP-Server OAuth?
Für lokale stdio-Server nicht – dort kommen Zugangsdaten aus der Umgebung. Für entfernte HTTP-Server mit geschützten Daten sieht die Spezifikation OAuth 2.1 vor, wobei der MCP-Server die Rolle des Resource Servers übernimmt.
Kann ich einen lokalen stdio-Server direkt über die Claude API nutzen?
Nein. Der MCP-Connector der Messages API verlangt einen öffentlich per HTTP erreichbaren Server; lokale stdio-Server binden Sie über einen eigenen MCP-Client oder über Claude Code an.
Unterstützen alle Clients Ressourcen und Prompts?
Nein. Der MCP-Connector der Claude API und der CrewAI-Adapter verarbeiten nach eigener Dokumentation vor allem Tools. Was jeder Agent braucht, gehört deshalb in ein Tool.
In welcher Sprache baue ich am besten einen MCP-Server?
Nehmen Sie die Sprache Ihres Teams. TypeScript, Python, C#, Go, Rust und Ruby haben offizielle Tier-1-SDKs; Java ist Tier 2.
Quellen
- Model Context Protocol – Specification (Revision 2026-07-28) modelcontextprotocol.io
- MCP Specification – Key Changes 2026-07-28 modelcontextprotocol.io
- MCP Specification – Streamable HTTP modelcontextprotocol.io
- MCP Specification – Authorization modelcontextprotocol.io
- MCP – Security Best Practices modelcontextprotocol.io
- MCP Specification – Tools modelcontextprotocol.io
- MCP – Official SDKs modelcontextprotocol.io
- MCP Python SDK (GitHub) github.com
- Claude Code – Connect Claude Code to tools via MCP code.claude.com
- Claude API – MCP connector platform.claude.com
- OpenAI Agents SDK – Model Context Protocol openai.github.io
- LangChain – Model Context Protocol docs.langchain.com
- CrewAI – MCP Servers as Tools docs.crewai.com