Inhaltsverzeichnis

01 · Einführung: warum ein eigener MCP Server?

Community-Server decken GitHub, Postgres und Dateisysteme ab — passen aber selten zu internen Entitlement-APIs, proprietären Abrechnungsregeln oder DSGVO-Pseudonymisierung. Ein eigener Server exponiert genau die Operationen, die Agenten brauchen, erzwingt read-only-Defaults und versioniert die Integration gemeinsam mit Ihren Backend-Services.

1. Integrationsfläche explodiert. Ohne MCP braucht jeder Host einen eigenen Adapter: Cursor ein Python-Skript, Claude Desktop ein anderes, CI ein drittes. Ein MCP Server kollabiert das zu einer gepflegten Oberfläche.

2. Sicherheit und Scope Creep. Generische Server registrieren zu viele Tools; Modelle wählen falsche Aktionen. Ein kuratierter Server mit JSON-Schema, scoped Tokens und Audit-Logging reduziert Credential-Sprawl — relevant für Art. 32 DSGVO (technische Schutzmaßnahmen).

3. Credential-Kontamination lokal. MCP Server laufen mit Host-Prozessrechten. Filesystem- oder Keychain-Wrapper auf dem Daily-Driver riskieren SSH-Keys oder Produktions-OAuth. Validieren Sie auf Hardware, die Sie löschen können — analog zu Agent-Skill-Tests.

Grundlagen lesen Sie in unserem MCP-Protokollüberblick. Hier geht es hands-on mit Python, FastMCP, stdio zuerst, dann HTTP für Teams.

02 · MCP-Architektur, JSON-RPC und Transports

Anthropic open-sourced Model Context Protocol im November 2024; 2026 steht es unter Linux-Foundation-Governance. MCP definiert, wie AI-Hosts externe Fähigkeiten per Standard-Wire-Format entdecken und aufrufen — eine agentenoptimierte Fassade, kein REST-Ersatz.

Drei Rollen

Host — Cursor, Claude Desktop, OpenClaw: besitzt die Session, rendert Freigabedialoge.
Client — im Host eingebettet; JSON-RPC-Session, tools/list, tools/call.
Server — Ihr Code: Tools (mutierend), Resources (read-only URIs), Prompts (Vorlagen).

                        // Client → Server: initialize

                        { "jsonrpc": "2.0", "id": 1, "method": "initialize",

                          "params": { "protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": { "name": "cursor", "version": "1.0" } } }

Transports: stdio (lokal, null Netzwerk), SSE over HTTP (Legacy), Streamable HTTP (Produktionsstandard 2026, bidirektionales JSON-RPC hinter OAuth/TLS).

03 · Entscheidungsmatrix: REST, Function Calling, MCP

Dimension	REST API	Function Calling	MCP Server
Discovery	Statische OpenAPI	Im Prompt eines Hosts	Runtime `tools/list`
Portabilität	Universal HTTP	Framework-gebunden	Cursor, Claude, OpenClaw
DSGVO-Audit	Eigenes Logging	Host-spezifisch	Einheitliche `tools/call`-Traces
Best Fit	CRUD, Mobile	Einzel-App-Prototyp	Agent-Toolchains

Das Muster 2026: REST innen, MCP außen. Behalten Sie REST für Services; der MCP Server wrappt drei bis sieben Agent-Operationen mit Redaction und engeren Scopes.

Kennzahl 1: Teams mit MCP berichten 38–55 % weniger Input-Tokens bei wiederholten Ops-Aufgaben gegenüber eingefügten API-Docs. Kennzahl 2: FastMCP reduziert Boilerplate um 60–70 % vs. rohes SDK. Kennzahl 3: Öffentliche Registries listen 10.000+ MCP Server (Stand Juni 2026).

04 · Entwicklungsumgebung

                        mkdir my-mcp-server && cd my-mcp-server

                        uv init && uv venv && source .venv/bin/activate

                        uv add "mcp[cli]" fastmcp httpx pydantic

                        python -c "import fastmcp; print(fastmcp.__version__)"

Voraussetzungen: Python 3.11+, optional Node 20+ für MCP Inspector, ein Host (Cursor/Claude Desktop). Setup-Zeit für einen stdio-Server: unter 20 Minuten mit FastMCP (vs. ~90 Min. manuelles Schema).

05 · Hello World

                        from fastmcp import FastMCP

                        mcp = FastMCP("hello-mcp")

                        @mcp.tool()

                        def greet(name: str) -> str:

                          """Begrüßung für den angegebenen Namen."""

                          return f"Hallo, {name}! MCP läuft."

                        if __name__ == "__main__":

                          mcp.run()

In Cursor oder Claude Desktop registrieren, Host neu starten, Tool greet aufrufen. Häufige Fehler: falscher Python-Pfad, print() auf stdout (korrupt stdio-Frames — Logging auf stderr).

06 · Tools: fünf Produktionsmuster

Tool	Zweck	Schlüssel
`lookup_account`	Sync-Lookup	Validierung, read-only
`fetch_weather`	Async HTTP	httpx + Timeout
`query_tickets`	DB-Query	Limit max 50
`write_note`	Datei schreiben	Path-Traversal-Block
`summarize_metrics`	Batch	Max 10 Services

                        SAFE_ROOT = Path("/safe/workspace").resolve()

                        @mcp.tool()

                        def write_note(filename: str, content: str) -> str:

                          target = (SAFE_ROOT / filename).resolve()

                          if not str(target).startswith(str(SAFE_ROOT)):

                            raise PermissionError("Path traversal blockiert")

Regel: unter 10–15 kuratierte Tools. Mehr als zwanzig Tools erhöht messbar die Fehlwahlrate in Produktions-Logs.

07 · Resources: read-only Kontext

                        @mcp.resource("config://app/settings")

                        def app_settings() -> str:

                          return json.dumps(load_public_settings(), indent=2)

Resources werden oft ohne explizite User-Freigabe geladen — keine Secrets, keine personenbezogenen Rohdaten (DSGVO-Minimierung). Aggregierte Summaries statt DB-Dumps.

08 · Prompts: wiederverwendbare Workflows

                        @mcp.prompt()

                        def triage_ticket(ticket_id: str) -> str:

                          return f"""Ticket {ticket_id} triagieren: Details laden, Hypothese, keine Prod-Mutation ohne Freigabe."""

Ergänzt Agent Skills (prozedural) und Tools (Live-Daten).

09 · HTTP-Transport für Remote-Hosts

                        if __name__ == "__main__":

                          mcp.run(transport="streamable-http", host="0.0.0.0", port=8080)

Checkliste: TLS am Reverse-Proxy, Rate-Limit 60 req/min pro Token, wöchentliche Token-Rotation, Audit jedes tools/call. Niemals stdio-Server vom Laptop ins Internet tunneln.

10 · Debugging und Tests

MCP Inspector: npx @modelcontextprotocol/inspector python server.py
Logging auf stderr, nie print() auf stdout in stdio-Modus.
pytest mit MCP-Client für tools/call-Regressionen.
Host-Smoke: read-only Lookup, bounded Write, Freigabe-Dialog testen.

11 · Produktions-Deploy: sieben Schritte

Dependencies pinnen (mcp, fastmcp).
Secrets via Vault/Env, nie im Image.
systemd/K8s mit Restart=always, Budget 256 MB RAM.
/health getrennt von MCP-Route.
Prometheus: Fehlerrate Alert bei >5 % über 5 Min.
OAuth-Scopes minimal halten (DSGVO Zweckbindung).
Staging auf isoliertem Mac vor DNS-Cutover — siehe OpenClaw MCP Integration.

12 · Wissensbasis-Projekt

Capstone: Team-Wiki mit ChromaDB/sqlite-fts5, Tools search_docs, get_doc, Resource kb://doc/{path}. Index ~180 MB für 2.000 Wiki-Seiten, Suche p95 <200 ms auf Apple M4.

                        @mcp.tool()

                        async def search_docs(query: str, limit: int = 5) -> list[dict]:

                          hits = await index.search(query, top_k=min(limit, 20))

                          return [{"path": h.path, "snippet": h.snippet[:500]} for h in hits]

13 · Ökosystem

SDKs: Python (mcp + FastMCP), TypeScript (@modelcontextprotocol/sdk), Go/Rust für Gateways. MCP ergänzt Agent Skills und A2A — nicht verwechseln. Nächste Schritte: internes ADR, Cursor-Template, quartalsweise Tool-Pruning.

14 · Fazit: auf löschbarer Hardware bauen

Sie haben den Pfad von Hello World bis Wissensbasis-Server: typisierte Tools, Resources, Prompts, HTTP, Tests, Härtung. Custom MCP Server kuratieren Fähigkeiten statt ganze REST-APIs in den Kontext zu werfen.

Auf dem Daily-MacBook erben stdio-Server Keychain, TCC und Produktions-OAuth. Docker auf Linux übt keine macOS-only Wrapper (Keychain, osascript, Xcode-Parser). Cloud-VMs verfälschen stdio-Latenz für Kapazitätsplanung. Wartungskosten steigen, wenn experimentelle Server die Maschine teilen, die App-Store-Builds signiert.

Für Sprint-MCP-Entwicklung — besonders write-fähige Tools — ist ein isolierter Mac mini M4 die sichere Default-Option: bare-metal Apple Silicon, sauberer User ohne Produktions-Credentials, SSH/VNC für GUI-Freigaben, Zero-Residue-Wipe vor Rückgabe. Tagesmiete passt zu ein- bis zweiwöchigen MCP-Piloten ohne CapEx.

MacDate · MCP-Entwicklung

MCP Server auf einem Mac testen, den Sie löschen können — nicht auf dem Laptop mit Signing Keys.

MacDate vermietet Mac mini M4 und Mac Studio mit SSH/VNC, Tagesabrechnung und Checklisten für Agent-Teams. Cursor oder OpenClaw installieren, FastMCP mit Test-Tokens entwickeln, Inspector und Host-Smoke-Tests fahren, dann wipe — ohne Keychain oder Developer-Zertifikate auf dem Daily-Driver.

Bare-Metal-Preise · Tagesmiete-FAQ (SSH/VNC)

MCP Server
von Null