Das Model Context Protocol (MCP) ist ein offener Standard, der Modellen wie Anthropics Claude und Entwicklerwerkzeugen wie Claude Code erlaubt, auf externe Tools, Datenquellen und Prompts sicher und standardisiert zuzugreifen.
Dieser Leitfaden führt Sie durch den Aufbau eines eigenen MCP-Servers von Grund auf, sodass Claude Code auf benutzerdefinierte Funktionen zugreifen und seine Fähigkeiten weit über die eingebauten Features hinaus erheblich erweitern kann.
Was ist das Model Context Protocol (MCP)?
MCP (Model Context Protocol) ist eine offene Spezifikation, die standardisiert, wie Sprachmodell-Clients (wie Claude, Claude Code oder andere LLM-Frontends) eine Verbindung zu Tool-Servern und Datenquellen herstellen. Denken Sie MCP als „USB-C-Anschluss für LLMs“: Es definiert einen Transport/JSON-RPC-Schema und eine gemeinsame Methode, über die Server drei Arten von Fähigkeiten veröffentlichen:
- Ressourcen — dateiartige oder dokumentartige Daten, die ein Client lesen kann (z. B. eine Datenbankzeile, eine Textdatei, ein JSON-Payload).
- Tools — aufrufbare Funktionen, die das Modell den Host ausführen lassen kann (mit Benutzerfreigabe).
- Prompts — wiederverwendbare Prompt-Vorlagen oder Workflows, die vom Modell/Client aufgerufen werden können.
MCP unterstützt mehrere Transports (stdio, HTTP, SSE) und stellt Schema, SDKs sowie Beispielserver bereit, sodass Sie das Drahtformat nicht selbst erfinden müssen. Das Protokoll wird öffentlich gepflegt (Spec + SDKs) und bietet Tutorials sowie eine Galerie von Beispielservern, um die Einführung zu beschleunigen.
Wie ist MCP aufgebaut?
Die Architektur von MCP ist bewusst einfach und modular: Die Kernbestandteile sind MCP-Server, MCP-Clients und Transports, die JSON-RPC-gerahmte Nachrichten zwischen ihnen übertragen. Im Folgenden sind die Hauptkomponenten beschrieben, mit denen Sie beim Aufbau eines Servers für Claude Code (oder andere MCP-Clients) interagieren.
Server, Client und das Protokoll
- MCP-Server — Ein Dienst, der Tools, Ressourcen und Prompts veröffentlicht. Tools können Seiteneffekte ausführen oder Daten abrufen; Ressourcen stellen lesezugängliche Inhalte bereit; Prompts sind wiederverwendbare Prompt-Vorlagen, die der Client das Modell abfragen lassen kann.
- MCP-Client (Host) — Typischerweise Teil des LLM-Hosts (z. B. Claude Code, VS-Code-Plugin, ein Browser-Client). Er entdeckt verfügbare Server, präsentiert dem Modell Toolbeschreibungen und leitet modellinitiierte Aufrufe an Server weiter.
- Protokoll — Nachrichten werden als JSON-RPC codiert; die Spezifikation definiert Lebenszyklusereignisse, Tool-Erkennung, Aufrufe, Completions/Sampling und wie strukturierte Ergebnisse an Client und Modell zurücktransportiert werden.
Kommunikationsmuster (was passiert, wenn ein Tool verwendet wird)
- Der Client sendet die Benutzernachricht an das Modell.
- Das Modell analysiert den Kontext und entscheidet, ein vom MCP exponiertes Tool aufzurufen (oder mehrere Tools).
- Der Client leitet den Tool-Aufruf über den gewählten Transport an den MCP-Server weiter.
- Der Server führt das Tool aus und liefert Ergebnisse zurück.
- Das Modell erhält die Tool-Ausgabe und verfasst die finale Antwort an den Benutzer.
Implementierungsgrundlagen
- JSON-RPC-Nachrichten folgen dem MCP-Schema.
- Tool-Definitionen werden in den Discovery-Antworten des Servers veröffentlicht, damit Clients sie in der UI präsentieren können.
- Ressourcen werden vom Client über die
@source:path-Syntax referenziert (z. B.@postgres:...), sodass Modelle auf externe Inhalte verweisen können, ohne große Daten in den Prompt einzubetten.
Warum Claude Code mit MCP-Servern integrieren?
Claude Code ist Anthropics Angebot für code- und entwicklerzentrierte Workflows (Editor/IDE-Integration, Codeverständnis etc.). Wenn Sie Ihre internen Tools (Source-Suche, CI-Runner, Ticketsysteme, private Registries) über MCP-Server exponieren, kann Claude Code sie als erstklassige Tools innerhalb von Coding-Gesprächen und Agenten-Flows aufrufen.
Die Integration von Claude Code mit MCP-Servern schaltet praktische, produktionsrelevante Fähigkeiten für einen Coding-Agenten frei:
1. Das Modell auf echten Systemen handeln lassen
Claude Code kann einen MCP-Server bitten, Issue-Tracker abzufragen, Datenbankabfragen auszuführen, große Dokumente zu lesen oder GitHub-PRs zu erstellen — und ermöglicht so End-to-End-Automatisierung direkt innerhalb der Coding-Session. Dies wird von den Claude-Code-Dokumenten explizit unterstützt (Beispiele: Abfragen von Postgres, Sentry oder Erstellen von PRs).
2. Große Datenmengen und spezialisierte Logik auslagern
Anstatt jede Datenquelle in den Prompt einzubetten (was Tokens verbraucht), veröffentlichen Sie Daten und Tools über MCP. Das Modell ruft das Tool auf, erhält eine strukturierte Antwort und arbeitet mit dieser weiter — das reduziert den Tokenverbrauch und erlaubt es Servern, schwere Arbeiten zu übernehmen (DB-Queries, lange Dateilesen, Auth).
3. Sicherheit und Governance
MCP zentralisiert Zugriffskontrollen und Auditing auf der Serverebene und erlaubt Organisationen, zugelassene Server zu whitelisten, verfügbaren Tools zu steuern und Ausgaben zu begrenzen. Claude Code unterstützt zudem Enterprise-MCP-Konfiguration und Zustimmung pro Scope.
4. Wiederverwendbarkeit und Ökosystem
MCP-Server sind über Clients und Teams hinweg wiederverwendbar. Einmal entwickelt, können viele Claude-/LLM-Clients dieselben Dienste nutzen (oder Implementierungen austauschen).
Was benötigen Sie vor dem Start?
Mindestanforderungen
- Eine Entwicklungsmaschine mit Python 3.10+ (im Beispiel nutzen wir Python). Alternativ werden Node/andere Sprachen durch MCP-SDKs unterstützt.
uv(Astrals Tool) oder ein gleichwertiger Runner zum Ausführen von MCP-stdio-Servern (das MCP-Tutorial nutztuv). Installationsschritte siehe unten.- Claude Code installiert oder Zugriff auf einen Claude-Client (Desktop oder CLI), um Ihren Server zu registrieren und zu testen; oder jeden MCP-fähigen Client. Claude Code unterstützt HTTP, SSE und lokale stdio-Server.
- Sicherheitshinweis: Fügen Sie in Team- oder Enterprise-Umgebungen nur vertrauenswürdige MCP-Server zu Claude Code hinzu — MCP gewährt Servern Zugriff auf sensible Daten, und Prompt-Injection-Risiken bestehen, falls ein Server bösartige Inhalte zurückgibt.
So installieren und überprüfen Sie die Claude Code CLI
Dies ist der Claude Code Installation and Usage Guide.
1) Kurzzusammenfassung — empfohlene Installationsmethoden
Verwenden Sie den nativen Installer (empfohlen) oder Homebrew unter macOS/Linux. NPM ist verfügbar, falls Sie eine Node-basierte Installation benötigen. Windows erhält PowerShell-/CMD-Installer. Quelle: offizielle Claude-Code-Dokumente & GitHub.
2) Voraussetzungen
- macOS 10.15+, Ubuntu 20.04+/Debian 10+, oder Windows 10+ (unter Windows wird WSL empfohlen).
- Node.js 18+ ist nur erforderlich für die NPM-Installationsmethode.
3) Installationsbefehle (einen auswählen)
Native (empfohlen — keine Node-Abhängigkeit), macOS / Linux / WSL:
curl -fsSL https://claude.ai/install.sh | bash
# optional: install latest explicitly
curl -fsSL https://claude.ai/install.sh | bash -s latest
# or install a specific version
curl -fsSL https://claude.ai/install.sh | bash -s 1.0.58
Windows PowerShell:
irm https://claude.ai/install.ps1 | iex
# or for latest: & (::Create((irm https://claude.ai/install.ps1))) latest
(Dies sind die offiziellen nativen Installer-Skripte).
NPM (falls Sie eine Node-basierte globale Installation möchten):
# requires Node.js 18+
npm install -g @anthropic-ai/claude-code
Verwenden Sie nicht sudo npm install -g — warnen Sie vor sudo-Globalinstallationen (Berechtigungs-/Sicherheitsprobleme). Wenn Berechtigungsfehler auftreten, nutzen Sie nvm oder korrigieren Sie Ihr npm-globales Prefix statt sudo zu verwenden.
4) Überprüfen, dass die Binärdatei installiert wurde (Basischecks)
Führen Sie folgende Befehle unmittelbar nach der Installation lokal aus:
# is the command on PATH?
which claude
# version (or -v)
claude --version
# or
claude -v
# help (sanity check)
claude --help
Erwartet: which zeigt einen Pfad (z. B. /usr/local/bin/claude oder ~/.nvm/.../bin/claude), und claude --version gibt eine semver-ähnliche Zeichenfolge aus. Die Docs und das README zeigen claude als primären CLI-Entry-Point.
5) Installationszustand und Konfiguration prüfen (empfohlen)
a) claude doctor — ausführen:
claude doctor
Diese integrierte Diagnose prüft Ihren Installationstyp, häufige Probleme (z. B. npm-Berechtigungsprobleme), Abhängigkeiten wie ripgrep und schlägt Korrekturen vor. Die Dokumentation empfiehlt ausdrücklich, claude doctor nach der Installation auszuführen.
b) Smoke-Test ausführen (nicht interaktiv)
Im Projektverzeichnis:
cd /path/to/your/project
claude -p "Explain this project in 3 sentences"
Dies verwendet den Print-Modus (-p), um einen einzelnen Prompt zu senden und dann zu beenden; gut für CI oder schnelle Funktionschecks.
c) Authentifizierungsprüfung (stellen Sie sicher, dass die CLI Anthropic erreichen kann)
Claude Code unterstützt mehrere Auth-Flows (Console OAuth, API-Key, Provider-Integrationen). Übliche Prüfungen:
- Bei Verwendung eines API-Keys (CI / Headless / lokale Umgebungsvariable):
export ANTHROPIC_API_KEY="sk-..."
# then
claude auth status
claude auth whoami # or `claude auth whoami` / `claude whoami` depending on version
Sie können den API-Schlüssel von CometAPI verwenden, um Claude Code zu nutzen. Die Verwendung der Claude-API über CometAPI gewährt einen 20% Rabatt.
- Wenn Sie OAuth über die Konsole verwendet haben — führen Sie aus:
claude auth status
claude auth whoami
Sie sollten Konto-/Planinformationen sehen oder eine Bestätigung, dass Sie authentifiziert sind.
Schrittweise Vorbereitung der Umgebung
Nachfolgend finden Sie konkrete Schritte zur Vorbereitung zweier häufiger Entwickler-Stacks (TypeScript und Python), gefolgt von kurzen Checks zur Funktionsprüfung.
H3 — A. TypeScript-/Node-Einrichtung (schnellster Weg)
- Projekt erstellen und SDK installieren:
mkdir mcp-demo && cd mcp-demo
npm init -y
npm install @modelcontextprotocol/sdk express zod
npm install --save-dev typescript tsx @types/node @types/express
server.tserstellen. (Ein vollständiges Beispiel finden Sie im Abschnitt „Wie man schnell einen MCP-Server baut…“.)- Ausführen:
npx -y tsx server.ts
- Lokal mit dem MCP Inspector testen oder zu Claude Code hinzufügen:
npx @modelcontextprotocol/inspector
# or (for Claude Code)
claude mcp add --transport http my-server http://localhost:3000/mcp
(Inspector und Claude-Befehle erlauben die Validierung von Discovery und das Ausführen von Tools.)
Wie baut man schnell einen MCP-Server für Claude Code?
Kurze Checkliste
- Starten Sie Ihren Server (Streamable HTTP empfohlen):
node server.tsoderuvicorn server:app. - Von Ihrer Entwicklungsmaschine aus entweder:
- Verwenden Sie den MCP Inspector zur Validierung (
npx @modelcontextprotocol/inspector) und bestätigen Sietools/listundresources/list; oder - Fügen Sie den Server zu Claude Code hinzu:
claude mcp add --transport http <name> http://<host>:<port>/mcp(oder folgen Sie den Web-UI-Flows, falls Ihr Client Remote-MCP unterstützt).
Wenn Sie Anthrophics Messages-API-Connector für Remote-MCP nutzen möchten (kein separater Client), lesen Sie die Claude-Dokumentation — möglicherweise ist ein Beta-Header erforderlich (prüfen Sie die Dokumentation für den genauen Header und den aktuellen Unterstützungsstatus).
Nachfolgend zwei vollständige, aber kompakte Serverbeispiele, die Sie kopieren, ausführen und mit Claude Code (oder dem MCP Inspector) verbinden können. Das TypeScript-Beispiel verwendet Express + das TypeScript-SDK; das Python-Beispiel demonstriert ein FastAPI-Mounting.
Hinweis: Der untenstehende Code folgt den öffentlichen SDK-Beispielen und ist absichtlich minimal gehalten. Für Produktion fügen Sie Authentifizierung, Logging, Rate-Limiting und Eingabevalidierung über die SDK-Defaults hinaus hinzu.
Beispiel 1: TypeScript + Express (Streamable HTTP)
Erstellen Sie server.ts (komplett):
// server.ts
import express from "express";
import * as z from "zod/v4";
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
const server = new McpServer({ name: "claude-code-demo", version: "0.1.0" });
// Register a simple tool: add two numbers
server.registerTool(
"add",
{
title: "Add",
description: "Add two numbers a and b",
inputSchema: { a: z.number(), b: z.number() },
outputSchema: { result: z.number() }
},
async ({ a, b }) => {
const output = { result: a + b };
return {
content: ,
structuredContent: output
};
}
);
// Register a resource: greet user (dynamic)
server.registerResource(
"greeting",
new ResourceTemplate("greeting://{name}", { list: undefined }),
{ title: "Greeting", description: "Return a greeting for the name" },
async (uri, params) => {
return {
contents:
};
}
);
// Express + Streamable HTTP transport
const app = express();
app.use(express.json());
app.post("/mcp", async (req, res) => {
const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
// Close transport when connection closes
res.on("close", () => transport.close());
await server.connect(transport);
await transport.handleRequest(req, res, req.body);
});
const port = parseInt(process.env.PORT || "3000", 10);
app.listen(port, () => console.log(`MCP server listening: http://localhost:${port}/mcp`));
Ausführen:
npm install
npx -y tsx server.ts
Dann in Claude Code verbinden (Beispiel):
# Add the remote server to your Claude Code MCP list (local dev)
claude mcp add --transport http my-demo http://localhost:3000/mcp
Dieses Beispiel ist aus dem offiziellen TypeScript-SDK-Quickstart adaptiert und zeigt, wie Tools und Ressourcen registriert und anschließend über Streamable HTTP exponiert werden.
Beispiel 2: Python + FastAPI (FastMCP + Streamable HTTP)
Erstellen Sie server.py (komplett):
# server.py
from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP
app = FastAPI()
mcp = FastMCP("claude-python-demo", stateless_http=True)
# tool: simple sum
@mcp.tool()
def add(a: int, b: int) -> dict:
"""Add two integers"""
return {"result": a + b}
# resource: simple greeting resource template
@mcp.resource("greeting://{name}")
def greeting(name: str):
return {"contents": }
# mount the streamable-http MCP endpoint (FastMCP exposes an ASGI app)
app.mount("/mcp", mcp.streamable_http_app())
# optional endpoint to demonstrate other API routes
@app.get("/")
async def root():
return {"status": "OK"}
Ausführen:
uvicorn server:app --reload --port 8000
Mit dem Inspector verbinden:
npx @modelcontextprotocol/inspector
# In Inspector select Streamable HTTP and enter http://localhost:8000/mcp
Die Python-SDK-Beispiele und FastMCP-Hilfsfunktionen erleichtern die Registrierung von mit @mcp.tool() und @mcp.resource() dekorierten Funktionen, die das LLM entdecken und aufrufen kann.
Wie ruft Claude Code Ihre Tools tatsächlich auf?
Wenn ein LLM beschließt, ein Tool zu verwenden, sendet der Client einen JSON-RPC-Aufruf an den MCP-Server. Der Server führt das angeforderte Tool aus (beispielsweise eine DB-Abfrage, Tests oder einen externen API-Call) und liefert strukturierte Inhalte sowie darstellbare Inhalte zurück. Der Client (Claude Code) kann die strukturierte Ausgabe dann in den Kontext des Modells einfügen, damit das Modell mit diesen zuverlässigen Daten weiterargumentieren kann — nicht nur mit der Textausgabe des Servers. Das TypeScript-SDK unterstützt die Registrierung von inputSchema und outputSchema (zod), sodass Argumente und Ausgaben validiert und maschinen-typisiert werden.
Welche Test- und Debugging-Tools sollten Sie verwenden?
MCP Inspector
Der MCP Inspector ist das offizielle visuelle Entwicklerwerkzeug zum Testen von MCP-Servern. Er erlaubt die Verbindung zu einem Server (stdio, SSE oder Streamable-HTTP), das Auflisten von Tools, deren manuellen Aufruf sowie die Inspektion des Lebenszyklus von JSON-RPC-Nachrichten — unbezahlbar während der Entwicklung. Starten Sie ihn mit npx @modelcontextprotocol/inspector.
Lokales vs. Remote-Testing
- Lokal (stdio) — schnelle Iterationszyklen für Desktop-Apps und Offline-Debugging.
- Streamable HTTP — testen Sie mit dem Inspector oder verbinden Sie sich mit Claude Code über die
claude mcp add-CLI oder den MCP-Connector in der Messages-API für Remote-Tests. Stellen Sie sicher, dass Sie alle erforderlichen Auth-Header für Ihren Server bereitstellen.
Fazit
MCP ist die praktische Brücke zwischen modernen LLMs und den Systemen, die tatsächlich Daten halten und Aktionen ausführen. Für Code-Workflows bietet die Integration von Claude Code mit einem MCP-Server dem Modell strukturierten, auditierbaren Zugriff auf Repositories, CI, Issue-Tracker und kundenspezifische Tools — was zu präziserer Automatisierung und sichereren Seiteneffekten führt. Mit offiziellen SDKs in TypeScript und Python, Streamable HTTP für Remote-Hosting und Tools wie dem MCP Inspector können Sie in Minuten einen minimalen Server bauen und in Richtung Produktion iterieren.
Entwickler können über CometAPI auf die Claude Sonnet 4.5 API und Claude Opus 4.1 API usw. zugreifen; die neueste Modellversion wird stets mit der offiziellen Website synchron gehalten. Beginnen Sie im Playground, um die Fähigkeiten des Modells zu erkunden, und konsultieren Sie den API guide für detaillierte Anleitungen. Stellen Sie vor dem Zugriff sicher, dass Sie sich bei CometAPI angemeldet und einen API-Schlüssel erhalten haben. CometAPI bietet Preise, die deutlich unter den offiziellen Preisen liegen, um Ihre Integration zu unterstützen.
Bereit? → Jetzt bei CometAPI anmelden!
Wenn Sie mehr Tipps, Leitfäden und News zu KI wissen möchten, folgen Sie uns auf VK, X und Discord!