MCP Server von Grund auf entwickeln:
Vollständiger Entwicklerleitfaden

LLMs sind starke Reasoner, aber schwache Ausführer. Der erste Fix war OpenAI Function Calling (Juni 2023): JSON-Schemas definieren, das Modell strukturierte Aufrufe emittieren lassen, Ihr Code führt aus. Es funktionierte — aber nur innerhalb der OpenAI-API. Jedes andere Modell brauchte einen separaten Adapter.

ChatGPT Plugins (März 2023) versuchten ein Marktplatzmodell: jedes Plugin war ein individueller REST-Wrapper mit eigenem Manifest. Discovery war zentral im OpenAI-Store, nicht runtime-dynamisch. Als Anthropic Tool Use lieferte und LangChain Agent-Frameworks popularisierte, hatte die Branche drei inkompatible Tool-Schemas und keine portable Server-Schicht.

Anthropics Design spiegelt USB-C: den Anschluss standardisieren, nicht jedes Kabel. MCP ersetzt REST-APIs nicht — es wrappt sie hinter eine einheitliche Discovery- und Invocations-Schicht, damit KI-Clients nicht mehr kümmern müssen, welcher Vendor oder welches Framework auf der anderen Seite sitzt. Bis Q2 2026 wechselte die Governance zur Linux Foundation AAIF; OpenAI, Google und Microsoft liefern native MCP-Client-Unterstützung.

MCP läuft auf JSON-RPC 2.0 mit bidirektionaler Messaging. Ein Host (Cursor, Claude Desktop) embeddet einen oder mehrere MCP Clients. Jeder Client pflegt eine 1:1-Session mit einem MCP Server, der echte Systeme anbindet.

Server exponieren drei Fähigkeitstypen: Tools (ausführbare Aktionen mit Nebenwirkungen), Resources (schreibgeschützte Daten mit URI-Identifikation) und Prompts (wiederverwendbare Template-Strings, die der Client vorab füllen kann). Zentrale RPC-Methoden: tools/list, tools/call, resources/list, resources/read, prompts/list und prompts/get.

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "query_database",
    "arguments": { "sql": "SELECT id, email FROM users LIMIT 10" }
  },
  "id": 42
}

STDIO-Transport: Host startet Server als Subprozess; Nachrichten fließen über stdin/stdout. Null Netzwerk-Abhängigkeiten, starke Prozess-Isolation, ideal für lokale Entwicklung. Lebenszyklus: spawn → Initialize-Handshake → Capability-Negotiation → persistente Session → Subprozess-Ende bei Disconnect.

HTTP + SSE / streamable-http: Server läuft als lang lebender HTTP-Dienst. Client öffnet SSE-Stream für Server-Push-Events; Tool-Aufrufe gehen per POST. Ermöglicht Remote-Deploy, team-geteilte Server, horizontale Skalierung — erfordert aber Session-Affinität für SSE und Auth am Edge. Die 2026-Spezifikation fügt streamable-http als empfohlenen Remote-Transport hinzu und ersetzt Legacy-SSE-only-Muster.

SDK-Stack wählen: Python mit mcp + FastMCP für schnellste Iteration, oder TypeScript mit @modelcontextprotocol/sdk für Node-native HTTP-Server. Empfohlenes Projekt-Layout:

my-mcp-server/
  pyproject.toml
  src/
    server.py          # FastMCP-Einstieg
    tools/             # Tool-Module
    resources/         # Resource-Handler
    prompts/           # Prompt-Templates
  tests/
    test_tools.py
  Dockerfile

Installation: pip install mcp oder npm install @modelcontextprotocol/sdk. Debug mit MCP Inspector (npx @modelcontextprotocol/inspector) — verbindet mit STDIO- oder HTTP-Endpunkten und zeigt live tools/list-Output. In Cursor: Einstellungen → MCP → Server-Config hinzufügen; Claude Desktop über claude_desktop_config.json.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("hello-mcp")

@mcp.tool()
def greet(name: str) -> str:
    return f"Hello, {name}!"

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

Tools mit Pydantic-Input: FastMCP leitet JSON Schema aus Type Hints und Pydantic-Modellen automatisch ab. Unten: fünf praktische Tools — Rechner, Datei-I/O, HTTP-Fetch, DB-Query und Zeit — mit Async-Support und strukturierten Fehlerrückgaben.

import asyncio
import httpx
from datetime import datetime, timezone
from pathlib import Path
from pydantic import BaseModel, Field
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("utility-server")

class CalcInput(BaseModel):
    expression: str = Field(description="Math expression e.g. 2 + 3 * 4")

@mcp.tool()
def calculate(input: CalcInput) -> str:
    try:
        allowed = set("0123456789+-*/(). ")
        if not all(c in allowed for c in input.expression):
            return "Error: invalid characters in expression"
        return str(eval(input.expression, {"__builtins__": {}}, {}))
    except Exception as e:
        return f"Error: {e}"

@mcp.tool()
def read_file(path: str) -> str:
    try:
        target = Path(path).resolve()
        if not target.is_file():
            return f"Error: {path} is not a file"
        return target.read_text(encoding="utf-8", errors="replace")[:50000]
    except Exception as e:
        return f"Error: {e}"

@mcp.tool()
async def http_get(url: str) -> str:
    try:
        async with httpx.AsyncClient(timeout=15.0) as client:
            resp = await client.get(url)
            return resp.text[:10000]
    except Exception as e:
        return f"Error: {e}"

@mcp.tool()
async def db_query(sql: str) -> str:
  try:
    import aiosqlite
    async with aiosqlite.connect("app.db") as db:
      cursor = await db.execute(sql)
      rows = await cursor.fetchall()
      return str(rows[:100])
  except Exception as e:
    return f"Error: {e}"

@mcp.tool()
def current_time(tz: str = "UTC") -> str:
    return datetime.now(timezone.utc).isoformat()

Resources: Statische URIs mappen auf feste Dateien; dynamische URIs akzeptieren Parameter. Ein Filesystem-Resource-Server exponiert Projektdocs, die der Agent ohne Tool-Nebenwirkungen lesen kann.

from mcp.server.fastmcp import FastMCP
from pathlib import Path

mcp = FastMCP("fs-resources")
DOCS = Path("./docs")

@mcp.resource("docs://index")
def docs_index() -> str:
    files = [f.name for f in DOCS.glob("*.md")]
    return "\n".join(files)

@mcp.resource("docs://{filename}")
def read_doc(filename: str) -> str:
    path = DOCS / filename
    if not path.exists():
        return f"Error: {filename} not found"
    return path.read_text(encoding="utf-8")

Prompts: Wiederverwendbare Templates mit Argument-Slots. Ein Code-Review-Prompt füllt Kontext vor, damit der Agent Ihre Team-Checkliste befolgt.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("review-prompts")

@mcp.prompt()
def code_review(file_path: str, language: str) -> str:
    return f"""Review {file_path} ({language}) for:
1. Security vulnerabilities (injection, auth bypass)
2. Performance bottlenecks
3. Error handling gaps
4. Test coverage holes
Provide severity-rated findings with fix suggestions."""

Streamable-HTTP-Transport ist der 2026-Standard für Remote-MCP-Server. FastMCP mit mcp.run(transport="streamable-http") starten oder TypeScript-SDK StreamableHTTPServerTransport nutzen. Sicherheit am Edge schichten:

Debug-Workflow: Zuerst MCP Inspector, dann Client-Logs, dann Unit-Tests. Inspector zeigt rohes JSON-RPC, Schema-Validierungsfehler und Timing pro Call.

import pytest
from server import calculate, CalcInput

def test_calculate_valid():
    result = calculate(CalcInput(expression="2 + 3"))
    assert result == "5"

def test_calculate_invalid_chars():
    result = calculate(CalcInput(expression="import os"))
    assert result.startswith("Error:")

Sechs-Schritte-Runbook von Assessment bis produktionsreifer MCP Server:

Produktionspfade: Mit Docker paketieren (python:3.12-slim-Base, Non-Root-User, Health-Check auf HTTP-Port). Plattform-Optionen:

Monitoring: Request-Latenz und Tool-Call-Counter nach Prometheus exportieren; Exceptions nach Sentry mit MCP-Method-Name-Tags. SDK-Versionen in pyproject.toml / package.json pinnen und Docker-Images pro Release taggen — MCP-Spec-Revisionen 2026 liefern noch breaking Transport-Changes.

Capstone: persönliche Wissensbasis-MCP. ChromaDB-Vektorspeicher, Embedding-Modell (lokal Ollama oder API) und Semantic-Search-Tool kombinieren:

import chromadb
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("knowledge-base")
client = chromadb.PersistentClient(path="./chroma_data")
collection = client.get_or_create_collection("notes")

@mcp.tool()
def semantic_search(query: str, n: int = 5) -> str:
    results = collection.query(query_texts=[query], n_results=n)
    docs = results.get("documents", [[]])[0]
    return "\n---\n".join(docs) if docs else "No matches found."

@mcp.tool()
def ingest_note(text: str, source: str) -> str:
    collection.add(documents=[text], metadatas=[{"source": source}], ids=[source])
    return f"Indexed: {source}"

Ökosystem-Server 2026 zum Studieren: mcp-server-filesystem (offizielle Referenz), GitHub MCP (Repo/PR/Issue-Ops), Brave Search MCP (Web-Retrieval), Postgres MCP (SQL mit Schema-Introspection), Slack MCP (Channel-Messaging). Trends H2 2026: OAuth 2.1 als standardisierte Auth, unified Server-Registries, Multi-Tenant-hosted MCP-Marketplaces und Agent-to-Agent (A2A)-Orchestrierung über MCPs Tool-Schicht.

Für Teams, die MCP Server neben Cursor-Agenten, ChromaDB-Ingestion und iOS-CI auf einem always-on-Knoten betreiben, ist MESHLAUNCH Cloud-Mac-Mini-Miete meist der bessere Produktions-Host: dediziertes Apple Silicon, keine Sleep-Disconnects, flexible Tages-/Wochen-/Monatsabrechnung und ein stabiler Ort, an dem Tool-Definitionen zu portablen Team-Assets statt pro-Developer-Laptop-Configs werden. Specs unter Mietpreise.