MCP-Protokoll erklärt — Model Context Protocol

MCP (Model Context Protocol) ist 2026 zum de-facto Standard für die Anbindung von AI-Modellen an externe Datenquellen geworden. Entwickelt von Anthropic, mittlerweile von OpenAI, Google und vielen anderen unterstützt.

Was ist MCP?

MCP ist ein offenes Protokoll, das standardisiert, wie AI-Anwendungen auf Datenquellen und Tools zugreifen. Es ist wie USB-C für AI — ein universeller Anschluss, der jedes Modell mit jeder Datenquelle verbindet.

Vor MCP

Jede AI-Anwendung brauchte eigene Integrationen für jede Datenquelle:

ChatGPT + Google Drive → proprietäre Integration

Claude + GitHub → proprietäre Integration

Gemini + Slack → proprietäre Integration

= N × M Integrationen

Mit MCP

Ein MCP-Server pro Datenquelle, ein MCP-Client pro AI-Anwendung:

= N + M Integrationen

Architektur

``
┌─────────────────┐ JSON-RPC ┌─────────────────┐
│ MCP Client │ ←──────────────→ │ MCP Server │
│ (AI-Anwendung) │ über stdio/ │ (Datenquelle) │
│ │ SSE/TCP │ │
└─────────────────┘ └─────────────────┘
│ │
│ ├── Tools
│ ├── Resources
│ └── Prompts
│
┌───┴───┐
│ LLM │
└───────┘
`

Komponenten

| Komponente | Rolle |
|-----------|-------|
| MCP Client | Die AI-Anwendung (Claude Desktop, Cursor, etc.) |
| MCP Server | Verbindet eine Datenquelle (GitHub, Drive, etc.) |
| Transport | stdio (lokal), SSE (Web), TCP (Network) |
| Protocol | JSON-RPC 2.0 |

Drei Ressourcen-Typen

Tools — Funktionen, die das LLM aufrufen kann (z.B. "Search GitHub Issues")

Resources — Statische Daten, die das LLM lesen kann (z.B. "Liste aller Dateien")

Prompts — Vorlagen für häufige Aufgaben (z.B. "Code Review Template")

Verfügbar MCP-Server 2026

Offizielle Server

GitHub — Repos, Issues, PRs, Code Search

Google Drive — Dateien suchen und lesen

Slack — Channels lesen und schreiben

Notion — Pages lesen und bearbeiten

PostgreSQL — Datenbankabfragen

SQLite — Lokale Datenbanken

Filesystem — Lokale Dateien lesen/schreiben

Brave Search — Web-Suche

Memory — Persistenter Memory für Agenten

Puppeteer — Browser-Automation

Community Server

Linear — Project Management

Jira — Issue Tracking

Figma — Design Files

AWS — Cloud Services

Docker — Container-Management

MCP-Client bauen (einfach)

`python
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

Server-Parameter definieren

server_params = StdioServerParameters(
command="python",
args=["-m", "mcp_server_github"],
env={"GITHUB_TOKEN": "ghp_xxx"}
)

Verbindung herstellen

async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
# Server initialisieren
await session.initialize()

# Verfügbare Tools anzeigen
tools = await session.list_tools()
print(tools)

# Tool aufrufen
result = await session.call_tool(
"search_repositories",
arguments={"query": "langchain"}
)
print(result)
`

Eigenen MCP-Server bauen

`python
from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.server.stdio
import asyncio

server = Server("my-server")

@server.list_tools()
async def list_tools() -> list[Tool]:
return [
Tool(
name="get_weather",
description="Gibt das Wetter für eine Stadt zurück",
inputSchema={
"type": "object",
"properties": {
"city": {"type": "string", "description": "Stadtname"}
},
"required": ["city"]
}
)
]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
if name == "get_weather":
city = arguments["city"]
# Hier echte Wetter-API aufrufen
return [TextContent(
type="text",
text=f"Wetter in {city}: 22°C, sonnig"
)]

async def main():
async with mcp.server.stdio.stdio_server() as (read, write):
await server.run(read, write, server.create_initialization_options())

asyncio.run(main())
`

MCP mit Claude Desktop nutzen

Claude Desktop App öffnen

Settings → Developer → Edit Config

MCP-Server hinzufügen:

`json
{
"mcpServers": {
"github": {
"command": "python",
"args": ["-m", "mcp_server_github"],
"env": {
"GITHUB_TOKEN": "ghp_your_token"
}
},
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
}
}
}
``

Claude neu starten

Claude kann nun auf GitHub und Ihr Dateisystem zugreifen

Sicherheit

| Aspekt | Empfehlung |
|--------|-----------|
| Authentifizierung | API-Keys als Environment Variables, nie hardcoded |
| Berechtigungen | Minimal Principle — nur benötigte Tools exponieren |
| Netzwerk | Lokale Server über stdio (kein Netzwerk nötig) |
| Logging | Alle Tool-Calls loggen für Audit |
| Sandbox | Code-Ausführung nur in isolierten Containern |

FAQ

Ist MCP nur für Claude?

Nein. MCP wurde von Anthropic entwickelt, ist aber offen. OpenAI, Google und andere unterstützen es zunehmend. Jede AI-Anwendung kann MCP-Clients implementieren.

Brauche ich MCP, wenn ich schon LangChain nutze?

MCP und LangChain ergänzen sich: MCP definiert die Schnittstelle zu Datenquellen, LangChain orchestriert den Agenten. LangChain kann MCP-Server als Tools einbinden.

Ist MCP langsam?

Nein. Der Overhead ist minimal (<1 ms pro Call). Die Latenz hängt von der Datenquelle ab, nicht vom Protokoll.

Wie unterscheidet sich MCP von OpenAI Function Calling?

Function Calling ist proprietär (OpenAI). MCP ist ein offener Standard, der mit jedem LLM funktioniert. Function Calling definiert, wie das LLM Tools aufruft. MCP definiert, wie die Tools exponiert werden.

Fazit

MCP ist 2026 der Standardweg, um AI-Modelle mit der Welt zu verbinden. Es reduziert Integrationsaufwand drastisch und ermöglicht interoperable AI-Anwendungen. Wenn Sie AI-Agenten bauen, sollten Sie MCP für Datenquellen-Anbindungen nutzen — es spart Wochen an Integrationsarbeit und ist zukunftssicher.