Claude Code war von Anfang an mächtig. Aber seit Anthropic das Model Context Protocol (MCP) als offenen Standard verabschiedet hat, ist aus einem guten CLI-Tool ein echtes Integrations-Ökosystem geworden. MCP-Server verwandeln Claude Code von einem Coding-Assistenten in eine universelle Schnittstelle zu fast jedem externen System — Datenbanken, APIs, Dateisystem, Browser, GitHub, Slack und mehr.
In diesem Artikel zeigen wir dir, was MCP technisch ist, wie du fertige Server einbindest, wie du eigene baust und welche Best Practices 2026 gelten.
1. Was ist MCP? Model Context Protocol Grundlagen
MCP steht für Model Context Protocol — ein von Anthropic entwickeltes, offenes Protokoll, das Large Language Models eine standardisierte Schnittstelle zu externen Tools und Datenquellen gibt. Denk daran wie USB-C für KI-Integrationen: ein Stecker, der überall passt.
Das Problem vor MCP
Früher musste jeder AI-Anbieter und jedes AI-Tool seine eigene Integration für jede externe API schreiben. OpenAI-Function-Calling sah anders aus als Anthropic Tool Use, das sich wiederum von LangChain-Tools unterschied. Das führte zu einem Ökosystem aus inkompatiblen Adaptern.
Konzept
MCP-Architektur auf einen Blick
- MCP Host: Die KI-Anwendung (z.B. Claude Code), die Tools aufruft
- MCP Client: Die Komponente im Host, die mit MCP-Servern kommuniziert
- MCP Server: Ein Prozess (lokal oder remote), der Tools und Ressourcen bereitstellt
- Transport: stdio (lokale Prozesse) oder HTTP+SSE (Remote-Server)
Wie Claude Code Tools aufruft
Wenn du in Claude Code arbeitest und einen MCP-Server aktiviert hast, läuft folgender Ablauf ab:
Claude Code startet
→
MCP-Server-Prozess spawnen
→
Tool-Katalog abfragen
→
Tools im Kontext verfügbar
→
Claude ruft Tool auf
→
Ergebnis in Kontext
Claude entscheidet selbstständig, wann ein Tool nützlich ist. Du musst nicht explizit sagen "benutze das Filesystem-Tool" — Claude erkennt anhand deiner Anfrage, welches Tool geeignet ist.
MCP vs. Function Calling — wo ist der Unterschied?
| Eigenschaft |
Anthropic Function Calling |
MCP |
| Standardisierung |
Proprietär (Anthropic-only) |
Offener Standard |
| Tool-Definition |
Im API-Call inline |
Im MCP-Server-Prozess |
| Wiederverwendung |
Muss jedes Mal neu definiert werden |
Server einmal schreiben, überall nutzen |
| Ressourcen |
Nur Tools |
Tools + Ressourcen + Prompts |
| Community-Ökosystem |
Keins |
Hunderte von Community-Servern |
| Kompatibilität |
Nur Claude |
Claude, GPT-4, Gemini, lokale Modelle |
MCP ist Function Calling + Standardisierung + Community. Die Killer-Feature ist die Wiederverwendbarkeit: Ein MCP-Server für deinen Datenbankzugriff funktioniert mit Claude Code, mit Claude.ai Desktop und theoretisch mit jedem anderen MCP-kompatiblen LLM-Client.
2. MCP-Server einrichten in Claude Code
MCP-Server werden in Claude Code über die Datei .claude/settings.json konfiguriert. Diese Datei liegt im Projektverzeichnis (projekt-lokal) oder in ~/.claude/settings.json (global für alle Projekte).
Die settings.json Grundstruktur
// .claude/settings.json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/home/user/projects"
]
},
"github": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-github"
],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
}
}
},
"allowedTools": [
"filesystem__read_file",
"filesystem__write_file",
"github__create_issue",
"github__list_pull_requests"
]
}
Die wichtigsten Konfigurationsfelder
config
mcpServers — das Herzstück
- command: Das Programm, das den MCP-Server startet (
npx, node, python, uvx)
- args: Array von Argumenten — Paketname + eventuelle Pfade/Flags
- env: Umgebungsvariablen für den Server-Prozess (API-Keys, DB-URLs)
- cwd: Arbeitsverzeichnis des Server-Prozesses (optional)
- disabled:
true deaktiviert den Server temporär ohne ihn zu löschen
npx vs. lokale Installation
Bei "command": "npx" mit "-y" wird das npm-Paket bei Bedarf heruntergeladen und gecacht. Das ist ideal für den schnellen Einstieg, hat aber zwei Nachteile:
- Beim ersten Start gibt es eine kurze Download-Verzögerung
- Du hast keine Kontrolle über die exakte Version
Für Produktivumgebungen empfehlen wir lokale Installation:
# Global installieren (einmalig)
npm install -g @modelcontextprotocol/server-filesystem
# Dann in settings.json:
{
"mcpServers": {
"filesystem": {
"command": "mcp-server-filesystem",
"args": ["/home/user/projects"]
}
}
}
Tipp: Globale vs. lokale Konfiguration
Nutze ~/.claude/settings.json für Server, die du in allen Projekten brauchst (z.B. Filesystem, GitHub). Projektspezifische Server (z.B. deine eigene Datenbank) kommen in .projectroot/.claude/settings.json. Projektlokal überschreibt global.
Server per CLI hinzufügen
Alternativ zur manuellen JSON-Bearbeitung kannst du MCP-Server direkt über den Claude Code CLI verwalten:
# MCP-Server auflisten
claude mcp list
# Server hinzufügen (schreibt in settings.json)
claude mcp add filesystem npx @modelcontextprotocol/server-filesystem ~/projects
# Server entfernen
claude mcp remove filesystem
# Server-Status prüfen
claude mcp status
3. Beliebte MCP-Server im Überblick
Das MCP-Ökosystem ist 2026 explodiert. Hier sind die wichtigsten offiziellen Server von Anthropic plus Community-Favoriten:
tool
@modelcontextprotocol/server-filesystem
Der Klassiker. Gibt Claude Zugriff auf dein lokales Dateisystem — Lesen, Schreiben, Verzeichnisse auflisten, Dateien verschieben. Du kannst den Zugriff auf bestimmte Pfade beschränken.
- Tools: read_file, write_file, list_directory, create_directory, move_file, delete_file
- Use Case: Dateien lesen ohne Copy-Paste, Claude schreibt direkt in Codedateien
- Install:
npx @modelcontextprotocol/server-filesystem /allowed/path
tool
@modelcontextprotocol/server-github
GitHub-Integration auf Steroiden. Claude kann Issues erstellen, PRs reviewen, Code in Repos suchen und Commits analysieren — alles ohne Browser.
- Tools: create_issue, list_pull_requests, get_file_contents, search_code, create_pull_request
- Voraussetzung: GitHub Personal Access Token mit Repo-Scopes
- Use Case: "Analysiere alle offenen Issues und erstelle einen Priorisierungsplan"
tool
@modelcontextprotocol/server-puppeteer
Browser-Automatisierung direkt aus Claude Code. Screenshots, Web-Scraping, Formular-Ausfüllen — alles via Puppeteer unter der Haube.
- Tools: puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate
- Use Case: Visuelles Testing, Web-Scraping für Recherchen, UI-Debugging
- Hinweis: Benötigt Chromium — auf Headless-Servern
PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=false
tool
Postgres MCP Server (Community)
Direkter PostgreSQL-Zugriff für Claude. Schema lesen, Queries ausführen, Datenbank-Probleme debuggen — ohne ständig SQL-Snippets zu kopieren.
- Package:
@crystaldba/postgres-mcp
- Tools: query, list_tables, describe_table, list_databases
- Use Case: "Was sind die 10 langsamsten Queries in meiner DB?" — Claude analysiert direkt
tool
@modelcontextprotocol/server-slack
Slack-Integration: Nachrichten lesen und senden, Channel-Historien durchsuchen, Benutzerprofile abfragen. Ideal für automatisierte Reporting-Workflows.
- Tools: slack_post_message, slack_get_channel_history, slack_search_messages
- Voraussetzung: Slack Bot Token + App mit Scopes
- Use Case: Deployment-Berichte automatisch in #deployments posten
tool
@modelcontextprotocol/server-brave-search
Web-Suche direkt in Claude Code via Brave Search API. Claude kann aktuelle Informationen zu Libraries, Fehlerursachen oder Technologien suchen.
- Tools: brave_web_search, brave_local_search
- Voraussetzung: Brave Search API Key (kostenlos bis 2.000 Requests/Monat)
- Use Case: "Suche nach der aktuellen Syntax für das neue Next.js 15 Feature"
Community MCP Registry
Die Community pflegt eine wachsende Liste von MCP-Servern auf github.com/modelcontextprotocol/servers. Dort findest du Server für AWS, Docker, Jira, Linear, Notion, Sentry, Stripe und viele mehr. Bevor du einen eigenen Server baust, lohnt es sich immer, dort zu schauen.
4. Eigenen MCP-Server bauen
Das Schöne an MCP ist, dass du in unter einer Stunde einen eigenen Server bauen kannst, der genau das tut, was dein Projekt braucht. Das offizielle SDK unterstützt TypeScript/JavaScript und Python.
TypeScript-Beispiel: Ein einfacher API-Tool-Server
Stellen wir uns vor, du hast eine interne REST-API für dein Deployment-System und willst Claude erlauben, Deployments zu triggern und Status abzufragen.
// deploy-mcp-server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
const API_BASE = process.env.DEPLOY_API_URL ?? "http://localhost:8080";
const API_TOKEN = process.env.DEPLOY_API_TOKEN ?? "";
// Server-Instanz erstellen
const server = new Server(
{ name: "deploy-server", version: "1.0.0" },
{ capabilities: { tools: {} } }
);
// Tool-Liste definieren
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: [
{
name: "deploy_service",
description: "Deployed einen Service in die Staging- oder Production-Umgebung.",
inputSchema: {
type: "object",
properties: {
service: {
type: "string",
description: "Name des Services (z.B. 'api', 'frontend', 'worker')",
},
environment: {
type: "string",
enum: ["staging", "production"],
description: "Zielumgebung für das Deployment",
},
},
required: ["service", "environment"],
},
},
{
name: "get_deployment_status",
description: "Gibt den aktuellen Status des letzten Deployments zurück.",
inputSchema: {
type: "object",
properties: {
service: {
type: "string",
description: "Name des Services",
},
},
required: ["service"],
},
},
],
}));
// Tool-Handler implementieren
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
if (name === "deploy_service") {
const { service, environment } = args as {
service: string;
environment: "staging" | "production";
};
const response = await fetch(`${API_BASE}/deploy`, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${API_TOKEN}`,
},
body: JSON.stringify({ service, environment }),
});
const data = await response.json();
return {
content: [
{
type: "text",
text: `Deployment gestartet: ${service} → ${environment}\nJob-ID: ${data.jobId}\nStatus: ${data.status}`,
},
],
};
}
if (name === "get_deployment_status") {
const { service } = args as { service: string };
const response = await fetch(`${API_BASE}/status/${service}`, {
headers: { Authorization: `Bearer ${API_TOKEN}` },
});
const data = await response.json();
return {
content: [
{
type: "text",
text: `Service: ${service}\nStatus: ${data.status}\nVersion: ${data.version}\nLetzte Änderung: ${data.updatedAt}`,
},
],
};
}
throw new Error(`Unbekanntes Tool: ${name}`);
});
// Server starten (stdio transport)
async function main() {
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Deploy MCP Server läuft auf stdio");
}
main();
package.json und tsconfig für den Server
// package.json
{
"name": "deploy-mcp-server",
"version": "1.0.0",
"type": "module",
"main": "dist/index.js",
"scripts": {
"build": "tsc",
"start": "node dist/index.js",
"dev": "tsx deploy-mcp-server.ts"
},
"dependencies": {
"@modelcontextprotocol/sdk": "^1.0.0"
},
"devDependencies": {
"@types/node": "^22.0.0",
"tsx": "^4.0.0",
"typescript": "^5.0.0"
}
}
Den eigenen Server in settings.json einbinden
// .claude/settings.json
{
"mcpServers": {
"deploy": {
"command": "node",
"args": ["/home/user/tools/deploy-mcp-server/dist/index.js"],
"env": {
"DEPLOY_API_URL": "https://api.mycompany.com",
"DEPLOY_API_TOKEN": "${DEPLOY_TOKEN}"
}
}
}
}
Python-Alternative mit FastMCP
Das Python SDK hat mit fastmcp einen Decorator-basierten Ansatz bekommen, der besonders elegant ist. Mit @mcp.tool() registrierst du Funktionen als Tools — ähnlich wie FastAPI. Installieren mit pip install fastmcp.
5. Datenbank-Tools via MCP
Einer der populärsten Use Cases für MCP ist der Datenbankzugriff. Anstatt mühsam SQL-Schemas zu kopieren und Queries manuell zu erklären, kann Claude direkt mit deiner Datenbank kommunizieren — und dabei trotzdem in einem sicheren, read-only Modus bleiben.
Supabase MCP Server
Supabase hat einen offiziellen MCP-Server, der besonders gut mit Claude Code harmoniert:
# Installation
npm install -g @supabase/mcp-server-supabase
# settings.json
{
"mcpServers": {
"supabase": {
"command": "mcp-server-supabase",
"env": {
"SUPABASE_URL": "${SUPABASE_URL}",
"SUPABASE_SERVICE_ROLE_KEY": "${SUPABASE_SERVICE_KEY}"
}
}
}
}
tool
Was der Supabase MCP Server kann
- Tabellen-Schema und Spaltentypen automatisch lesen
- SQL-Queries ausführen (SELECT, INSERT, UPDATE, DELETE)
- Row-Level-Security Policies einsehen
- Storage-Buckets und Dateien verwalten
- Edge Functions auflisten und Logs lesen
- Realtime-Subscriptions debuggen
Prisma MCP — Schema-First Datenbankzugriff
Für Projekte die Prisma als ORM nutzen, gibt es einen MCP-Server der das Prisma-Schema direkt liest und typsichere Queries generiert:
// .claude/settings.json mit Prisma MCP
{
"mcpServers": {
"prisma": {
"command": "npx",
"args": ["-y", "prisma-mcp"],
"cwd": "/home/user/myproject",
"env": {
"DATABASE_URL": "${DATABASE_URL}"
}
}
}
}
Direkter DB-Zugriff: Was Claude damit macht
Mit einem Datenbank-MCP-Server kannst du Claude folgende Aufgaben geben, die sonst stundenlange manuelle Arbeit bedeuten würden:
- "Analysiere unsere
users-Tabelle und finde alle Felder, die noch nicht indexiert sind aber häufig in WHERE-Clauses vorkommen."
- "Finde alle Queries die länger als 500ms dauern und schlage Optimierungen vor."
- "Überprüfe ob unsere RLS-Policies korrekt sind — kein User sollte auf Daten anderer User zugreifen können."
- "Erstelle eine Migration die die
products-Tabelle um ein stripe_price_id-Feld erweitert."
Wichtig: Service Role Key vs. Anon Key
Für den MCP-Server solltest du überlegen, ob du den Service Role Key (voller Zugriff, umgeht RLS) oder den Anon Key (eingeschränkt durch RLS) verwendest. Für Entwicklung und Debugging ist der Service Key praktisch, aber in geteilten Projekten erhöht er das Risiko versehentlicher Datenänderungen. Nutze read-only Database Roles wo möglich.
6. Best Practices für den MCP-Einsatz
Sicherheit: allowedTools richtig setzen
Das allowedTools-Array in settings.json ist dein erster Sicherheits-Layer. Anstatt Claude Zugriff auf alle Tools eines Servers zu geben, kannst du genau steuern, welche Tools verfügbar sind:
// Restriktive Konfiguration — nur Lese-Tools erlaubt
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/src"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}" }
}
},
"allowedTools": [
// Filesystem: nur lesen, nicht schreiben
"filesystem__read_file",
"filesystem__list_directory",
// GitHub: Issues + PRs lesen, keine Schreib-Rechte
"github__list_issues",
"github__get_pull_request",
"github__search_code"
]
}
Secrets sicher verwalten
config
Secrets nie hardcoden — immer aus Environment
MCP-Server-Konfigurationen können in Git committed werden. Deshalb NIEMALS API-Keys, Datenbankpasswörter oder Tokens direkt in settings.json schreiben. Nutze stattdessen Environment-Variable-Referenzen mit ${VAR_NAME}-Syntax:
"GITHUB_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}" — liest aus der Shell-Umgebung- Setze Variablen in
~/.bashrc, ~/.zshrc oder via direnv projekt-lokal
- Für Team-Projekte:
.env-Datei + dotenv-Integration oder CI/CD-Secrets
MCP-Server debuggen
Wenn ein MCP-Server nicht funktioniert, sind das die häufigsten Ursachen und ihre Diagnose:
# 1. Server-Prozess manuell starten und testen
npx @modelcontextprotocol/server-filesystem /tmp/test
# 2. Claude Code mit Debug-Output starten
CLAUDE_MCP_DEBUG=1 claude
# 3. MCP Inspector für interaktives Testen
npx @modelcontextprotocol/inspector npx @modelcontextprotocol/server-filesystem /tmp
# 4. Logs prüfen (stderr des Server-Prozesses)
claude mcp logs filesystem --tail 50
Logging in eigenen MCP-Servern
Ein wichtiger Punkt: MCP-Server kommunizieren über stdout mit dem MCP-Client. Alle Debug-Ausgaben müssen auf stderr gehen, sonst bricht das Protokoll:
// RICHTIG: Debug-Output auf stderr
console.error("[deploy-mcp] Tool aufgerufen:", name, args);
// FALSCH: console.log geht auf stdout → bricht MCP-Protokoll!
// console.log("debug") — NIEMALS in MCP-Servern!
// Structured Logging mit Kontext
function log(level: "info" | "warn" | "error", msg: string, data?: unknown) {
console.error(JSON.stringify({ timestamp: new Date().toISOString(), level, msg, data }));
}
Performance: Server-Startup-Zeit
Claude Code startet MCP-Server beim Start und lässt sie laufen. Trotzdem lohnen sich einige Optimierungen:
- Lokale Installation bevorzugen:
npx lädt das Paket jedes Mal neu wenn der Cache leer ist. Globale oder lokale node_modules-Installation ist schneller.
- Lazy Loading im Server: Teure Initialisierungen (DB-Verbindungen, API-Clients) erst beim ersten Tool-Call aufbauen, nicht beim Start.
- Timeout konfigurieren: Setze angemessene Timeouts für externe API-Calls (nicht zu kurz — Claude wartet geduldig, nicht zu lang — sonst hängt alles).
- Unnötige Server deaktivieren: Mit
"disabled": true kannst du Server temporär ausschalten ohne sie zu löschen.
MCP im Production-Einsatz
custom
Production-Checklist für MCP-Server
- Alle Secrets via Environment-Variablen — nie hardcoded
allowedTools explizit definiert — Principle of Least Privilege- Input-Validierung in jedem Tool-Handler (böse Inputs kommen vor)
- Error-Handling: niemals unbehandelte Exceptions nach oben geben
- Rate Limiting für externe API-Calls implementieren
- Logging auf stderr mit Structured JSON (searchbar in Log-Aggregatoren)
- Read-only Datenbankrollen für DB-Server nutzen
- MCP-Server-Version in package.json pinnen (
"^1.0.0" → "1.2.3")
Team-Konfiguration und gemeinsame Settings
Wenn mehrere Entwickler im Team Claude Code nutzen, gibt es zwei Ansätze für geteilte MCP-Konfigurationen:
# Ansatz 1: settings.json in Git committen (ohne Secrets)
# .claude/settings.json — committed, Secrets als ${ENV_VAR}
# .claude/settings.local.json — gitignored, enthält echte Werte
# .gitignore
.claude/settings.local.json
# Ansatz 2: direnv pro Entwickler
# .envrc im Projektverzeichnis (gitignored)
export GITHUB_TOKEN=ghp_yourtoken
export DATABASE_URL=postgresql://localhost/mydb
export SUPABASE_SERVICE_KEY=eyJhbGciOi...
# settings.json (committed) referenziert nur die Variablen
# "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}" }
Remote MCP-Server (HTTP+SSE Transport)
Neben lokalen Prozessen (stdio) unterstützt MCP auch Remote-Server über HTTP mit Server-Sent Events. Das ermöglicht zentrale MCP-Server im Unternehmen — z.B. ein interner Deployment-Server den alle Entwickler nutzen ohne lokale Installation. Die Konfiguration: "url": "https://mcp.internal.company.com/deploy" statt command + args.
Dein eigenes MCP-Ökosystem aufbauen
Wir helfen dir, MCP-Server für dein spezifisches Tech-Stack zu designen und zu implementieren — von Datenbankzugriff bis CI/CD-Integration. Mit einem kostenlosen Trial testen, kein Credit Card erforderlich.
Kostenlos starten