Model Context Protocol ist der offene Standard, den Anthropic im November 2024 veroeffentlicht hat, um externe Faehigkeiten fuer KI-Clients zu vereinheitlichen. Kern: ein Server schreiben, von Claude Desktop, Cursor oder jedem MCP-Client verbinden — LLM wechseln ohne Tool-Layer neu zu bauen.

┌────────────────────┐         ┌─────────────────────┐
│   MCP Client       │ ◄─────► │   MCP Server        │
│  (Claude / Cursor) │  JSON   │  (Sie bauen dies)   │
│                    │  -RPC   │                     │
└────────────────────┘         └─────────────────────┘
                                        │
                          ┌─────────────┼─────────────┐
                          ▼             ▼             ▼
                       Tools       Resources      Prompts
                    (Aktionen)    (Daten lesen)  (Vorlagen)

Wire-Format: JSON-RPC 2.0. Lebenszyklus: Initialize-Handshake → Capability-Negotiation → Request/Response-Schleife → Graceful Shutdown. Zwei Transportmodi dominieren: stdio (lokaler Subprozess, keine Netzwerk-Deps) und HTTP + SSE (remote, Multi-Client, teamgeteilt).

Ein laufender MCP Server in unter zehn Minuten. Python mit FastMCP ist der empfohlene Einstieg; TypeScript spiegelt dieselben Konzepte mit @modelcontextprotocol/sdk.

python -m venv .venv
source .venv/bin/activate
pip install mcp

npm init -y
npm install @modelcontextprotocol/sdk

Empfohlenes Projekt-Layout:

my-mcp-server/
├── server.py
├── tools/
│   ├── calculator.py
│   └── web_search.py
├── resources/
│   └── file_reader.py
├── prompts/
│   └── templates.py
├── tests/
│   └── test_tools.py
└── pyproject.toml

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-first-server")

@mcp.tool()
def say_hello(name: str) -> str:
    return f"Hello, {name}! This is your first MCP tool."

if __name__ == "__main__":
    mcp.run()

Starten und mit dem offiziellen MCP Inspector pruefen:

python server.py
npx @modelcontextprotocol/inspector python server.py

Client-Anbindung: Server-Startbefehl in Claude Desktop claude_desktop_config.json oder Cursor mcp.json. Nach Neustart Tool in der Client-Liste pruefen und Testaufruf ausfuehren.

Ein Produktions-Server registriert Tools fuer Aktionen, Resources fuer lesbare Daten und Prompts fuer wiederverwendbare Vorlagen. Funktionssignaturen und Docstrings werden KI-Dokumentation — kein separates OpenAPI noetig.

Tool-Struktur: Name aus Funktion, Parameter aus Type Hints, Beschreibung aus Docstring. Pydantic-Modelle fuer komplexe Inputs:

from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search keywords")
    max_results: int = Field(default=5, description="Max results")
    language: str = Field(default="en", description="Result language")

@mcp.tool()
def web_search(input: SearchInput) -> list[dict]:
    ...

import httpx

@mcp.tool()
async def fetch_url(url: str) -> str:
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.get(url)
        response.raise_for_status()
        return response.text

Fehlerbehandlung: strukturierte Error-Dicts fuer recoverable Failures; raise nur bei unrecoverable States. Timeouts auf I/O-Tools. Berechtigungen vor Dateisystem- oder DB-Zugriff pruefen.

Resources unterscheiden sich von Tools: Resources liefern Daten per URI, Tools fuehren Aktionen aus. Statische Resources mit festen URIs; dynamische mit Pfadparametern.

@mcp.resource("config://app-settings")
def get_app_settings() -> str:
    return json.dumps({"version": "1.0", "env": "production"})

@mcp.resource("user://{user_id}/profile")
def get_user_profile(user_id: str) -> str:
    user = db.query_user(user_id)
    return json.dumps(user)

Ein Filesystem-Resource-Server listet Verzeichnisse, liest Dateien und kann Change-Events subscriben. Prompts liefern vorgebaute Gespraechsvorlagen mit dynamischer Parameter-Injektion:

from mcp.types import PromptMessage, TextContent

@mcp.prompt()
def code_review_prompt(language: str, code: str) -> list[PromptMessage]:
    return [
        PromptMessage(
            role="user",
            content=TextContent(
                type="text",
                text=f"Review this {language} code for bugs, security, and performance:\n```{language}\n{code}\n```"
            )
        )
    ]

Multi-Turn-Prompts mischen user und assistant — nuetzlich fuer Interview-Simulationen, Debug-Walkthroughs und Onboarding mit konsistenter Struktur.

Lokales STDIO fuer Dev; teamgeteilte oder SaaS-Deployments brauchen HTTP + SSE. FastMCP unterstuetzt streamable-http mit minimaler Code-Aenderung.

mcp = FastMCP("remote-server", transport="streamable-http")

if __name__ == "__main__":
    mcp.run(host="0.0.0.0", port=8000)

Produktions-HTTP-Server brauchen Auth und Guardrails: Bearer Token oder API-Key-Middleware, CORS auf bekannte Client-Origins, Rate Limiting auf Tool-Endpoints mit externen APIs oder Datenbanken. EU-Teams: Datenfluss und Speicherort bei Cloud-Hosts DSGVO-konform dokumentieren.

MCP Inspector bleibt primaere Debug-UI: gegen Server-Befehl starten, Tools interaktiv aufrufen, JSON-RPC Request/Response inspizieren, Fehlerpfade simulieren vor Client-Anbindung.

import pytest
from mcp.client.session import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client

@pytest.mark.asyncio
async def test_calculator_tool():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"]
    )
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("calculate", {"expression": "2 + 2"})
            assert result.content[0].text == "4"

Vom Hello World zur Produktion: Containerisierung, Observability, Version-Negotiation und ein Referenzprojekt mit echtem Nutzen. Capstone: persoenlicher Wissensbasis-MCP Server — semantische Suche ueber lokale Markdown-Notizen in Cursor.

Deployment-Optionen: Docker isoliert Python-Deps. Railway und Render fuer One-Click-Deploys. AWS Lambda und Google Cloud Run fuer bursty Serverless. Self-hosted VPS plus Nginx fuer Teams mit bestehender Infra. Strukturiertes Logging, Prometheus-Metriken auf Tool-Calls, Sentry fuer Alerts, /health-Endpoint. MCP-Protokollversion declarieren und Capabilities beim Handshake negieren. EU-Teams: bei Cloud-Mac-Miete und Datenhaltung DSGVO-Dokumentation nicht vergessen.

Wissensbasis-Projekt: Lokales Markdown mit ChromaDB oder Qdrant indexieren, embed mit text-embedding-3-small, File-Changes via watchfiles. Drei Tools — Index, semantische Suche, Notiz schreiben/updaten — plus Resource mit indexierten Dateien. In Cursor: «Was habe ich letzte Woche ueber MCP geschrieben?» — Agent ruft Search-Tool, liefert Snippets.

2026 liefern alle grossen KI-Clients natives MCP. Marketplace-Verzeichnisse listen Tausende Server; Enterprise treibt OAuth 2.0 und Security-Audits. Naechste Schritte: Spec auf modelcontextprotocol.io, ersten Server publizieren, MCP mit Agent Skills kombinieren.

Alternativen ehrlich abwaegen. HTTP+SSE auf dem Haupt-MacBook bricht bei Deckel schliessen und OS-Updates. Serverless ohne Session-Affinitaet verliert Multi-Step-Agent-Kontext. MCP-Endpoints ohne Auth laden Prompt-Injection und unautorisierte Tool-Calls ein — ca. 1.000 ungeschuetzte Server in 2026-Audits indexiert. Fuer Teams mit Apple Silicon, 7x24 und Isolation zwischen MCP Server, iOS CI und Agent Gateway ist KVMNODE Mac Mini M4 oder M4 Pro mieten oft die bessere Antwort: flexible Tag/Woche/Monat-Tarife, launchd-Prozesse, Snapshot-Rollback. Tarife auf der Mietpreise-Seite, Setup im Hilfezentrum, Provisionierung ueber Bestellen wenn Ihr MCP-Stack einen Host braucht, der laeuft nach dem Laptop-Schliessen. EU-Teams: DSGVO-Dokumentation bei Cloud-Datenfluss und Speicherort nicht vergessen.