Claude Code ist ein autonomer KI-gesteuerter Coding-Agent von Anthropic, der direkt im Terminal läuft und durch natürliche Sprache gesteuert wird. Im Gegensatz zu Autocomplete-Tools wie GitHub Copilot arbeitet Claude Code proaktiv und eigenständig: Es versteht ganze Projekte, liest und schreibt Dateien, erstellt Tests, führt Shell-Befehle und Git-Operationen aus und kommuniziert über das Model Context Protocol (MCP) mit externen Services wie Datenbanken, APIs und Issue-Trackern. Entwickler beschreiben eine Aufgabe in natürlicher Sprache, und Claude Code plant die Umsetzung, analysiert die Codebasis, schreibt den Code, führt Tests aus und erstellt Git-Commits – alles automatisch. Die Installation erfolgt über npm mit dem Befehl 'npm install -g @anthropic-ai/claude-code' und erfordert Node.js 18 oder höher. Claude Code unterstützt alle gängigen Programmiersprachen und läuft auf macOS, Linux und Windows (WSL2).

Wie unterscheidet sich Claude Code von GitHub Copilot?

Claude Code ist ein autonomer Agent, der ganze Aufgaben eigenständig erledigt – von der Dateianalyse über das Code-Schreiben bis zum Git-Commit. GitHub Copilot hingegen ist ein Autocomplete-Tool, das Inline-Code-Vorschläge innerhalb des Editors macht. Der entscheidende Unterschied liegt im Arbeitsumfang: Claude Code hat Zugriff auf das gesamte Projekt, kann Shell-Befehle ausführen, Tests starten, Git-Repositories verwalten und über MCP-Server mit externen Tools wie Datenbanken, GitHub, Jira und Slack kommunizieren. Copilot arbeitet primär innerhalb einer einzelnen Datei im Editor. Claude Code kann mehrstufige Aufgaben planen und ausführen, beispielsweise eine komplette Feature-Implementierung mit Tests, Dokumentation und Pull Request. Copilot schlägt einzelne Code-Zeilen oder Funktionen vor. Für einfache Code-Vervollständigung ist Copilot schneller, für komplexe Entwicklungsaufgaben bietet Claude Code deutlich mehr Autonomie und Projektverständnis.

Welche Abo-Modelle gibt es?

Der Claude Code Masterkurs bietet drei Abo-Modelle für jeden Bedarf: Das Monats-Abo kostet 24 EUR pro Monat und ist jederzeit flexibel kündbar – ideal zum Ausprobieren. Das Jahres-Abo kostet 229 EUR pro Jahr, was einer Ersparnis von 20 Prozent gegenüber der monatlichen Zahlung entspricht. Das Lifetime-Abo bietet für einmalig 499 EUR lebenslangen Zugriff auf alle Inhalte, einschließlich zukünftiger Updates und neuer Lektionen. Alle drei Modelle beinhalten den vollständigen Zugang zu allen 70 Lektionen von Grundlagen bis Experte, 43 Tools & Extensions Lektionen zu CLI-Werkzeugen und MCP-Servern, interaktive Quizzes zur Wissensüberprüfung, den Live-Playground zum Experimentieren, praktische Challenges und Community-Features wie Forum und Leaderboard. Der Kurs bietet außerdem eine kostenlose Vorschau der ersten Lektionen, sodass Interessierte den Kurs vor dem Kauf testen können.

Wie installiert man Claude Code?

Die Installation von Claude Code erfolgt in drei einfachen Schritten und dauert weniger als fünf Minuten. Zunächst muss Node.js in Version 18 oder höher installiert sein – dies ist die einzige Voraussetzung. Anschließend wird Claude Code global über npm installiert mit dem Befehl 'npm install -g @anthropic-ai/claude-code'. Nach der Installation navigiert man in ein beliebiges Projektverzeichnis und startet Claude Code mit dem Befehl 'claude'. Beim ersten Start wird man zur Authentifizierung aufgefordert: Entweder gibt man einen Anthropic API-Key ein oder nutzt die bequemere OAuth-Authentifizierung über die Anthropic Console im Browser. Claude Code läuft auf macOS, Linux und Windows, wobei für Windows die Nutzung von WSL2 (Windows Subsystem for Linux) empfohlen wird. Optional kann man eine CLAUDE.md Datei im Projektstamm erstellen, die Claude Code automatisch als Kontext für das jeweilige Projekt nutzt.

Was ist das Model Context Protocol (MCP)?

MCP (Model Context Protocol) ist ein offenes Protokoll von Anthropic, das Claude Code ermöglicht, sicher mit externen Tools und Services zu kommunizieren. Es funktioniert nach einem Client-Server-Modell: Claude Code ist der MCP-Client, und jeder externe Service wird über einen MCP-Server angebunden. Über MCP-Server kann Claude Code auf Datenbanken wie PostgreSQL und SQLite zugreifen, SQL-Abfragen ausführen und Schemas inspizieren. Es kann GitHub-Issues und Pull Requests verwalten, Jira-Tickets erstellen, Slack-Nachrichten senden und Brave Search für Web-Recherchen nutzen. Die Konfiguration erfolgt über eine JSON-Datei im Projekt oder global in den Claude Code Settings. Jeder MCP-Server definiert seine verfügbaren Tools, und Claude Code entscheidet eigenständig, wann welches Tool aufgerufen wird. Das Protokoll ist open-source und erweiterbar – Entwickler können eigene MCP-Server für beliebige APIs und Services schreiben und so die Fähigkeiten von Claude Code gezielt erweitern.

Was kostet Claude Code?

Claude Code selbst ist kostenlos als npm-Paket verfügbar. Die Nutzung erfordert jedoch einen Anthropic API-Key, und die Kosten richten sich nach dem tatsächlichen Tokenverbrauch. Claude Sonnet 4 kostet circa 3 US-Dollar pro Million Input-Tokens und 15 US-Dollar pro Million Output-Tokens – das ist das empfohlene Modell für die meisten Aufgaben. Claude Opus 4, das leistungsstärkere Modell für komplexe Aufgaben, kostet circa 15 US-Dollar pro Million Input-Tokens und 75 US-Dollar pro Million Output-Tokens. Ein typischer Entwicklungstag kostet je nach Nutzungsintensität zwischen 1 und 20 US-Dollar. Für Entwickler, die keine verbrauchsabhängige Abrechnung möchten, bietet Anthropic den Max Plan als monatliche Pauschale an. Damit erhält man ein festes Kontingent an Claude Code Nutzung pro Monat. Die Kosten lassen sich außerdem durch gezielte Nutzung der CLAUDE.md Datei und effizientes Prompt Engineering deutlich reduzieren.

Welche Programmiersprachen unterstützt Claude Code?

Claude Code ist vollständig sprachunabhängig und unterstützt alle gängigen Programmiersprachen, darunter Python, JavaScript, TypeScript, Rust, Go, Java, C++, C#, Ruby, PHP, Swift und Kotlin. Da Claude Code im Terminal arbeitet und nicht an eine bestimmte IDE gebunden ist, kann es mit jedem Projekt und jeder Sprache verwendet werden. Claude Code versteht nicht nur die Syntax, sondern auch die idiomatischen Patterns jeder Sprache – es schreibt pythonischen Python-Code, idiomatisches Rust mit korrektem Ownership, und typsicheres TypeScript. Besonders stark ist Claude Code bei Projekten mit mehreren Sprachen, etwa einem TypeScript-Frontend mit Python-Backend oder einem Go-Microservice mit SQL-Datenbank. Das Modell erkennt automatisch den verwendeten Tech Stack anhand der Projektdateien (package.json, Cargo.toml, pyproject.toml) und passt seine Code-Generierung entsprechend an. Auch Framework-spezifische Patterns wie React, Django, Rails oder Spring Boot werden korrekt angewendet.

Was ist eine CLAUDE.md Datei?

Die CLAUDE.md ist eine Markdown-Datei im Projektstamm, die Claude Code strukturierten Kontext über das jeweilige Projekt gibt. Sie funktioniert wie ein Briefing für den KI-Agenten und wird automatisch bei jedem Start von Claude Code eingelesen. Typische Inhalte sind eine Projektbeschreibung, die Architektur des Systems, verwendete Technologien und Frameworks, Coding-Konventionen wie Naming Standards und Formatierung, Build- und Test-Befehle sowie spezielle Anweisungen für den Umgang mit dem Code. Je detaillierter die CLAUDE.md, desto besser arbeitet Claude Code mit dem Projekt. Es gibt drei Ebenen von CLAUDE.md Dateien: die projektspezifische im Repo-Root, eine persönliche unter ~/.claude/CLAUDE.md für übergreifende Präferenzen, und optional Unterverzeichnis-spezifische CLAUDE.md Dateien für Module mit eigenen Konventionen. Best Practice ist, die CLAUDE.md mit dem Team zu teilen und im Git-Repository zu versionieren, damit alle Entwickler die gleiche KI-Erfahrung haben.

MCP Server Integration

Level 2 | 35 Minuten

Verbinde Claude Code mit externen Tools und Services über das Model Context Protocol

Lernziele

Das Model Context Protocol (MCP) verstehen
MCP Server hinzufügen und konfigurieren
Die wichtigsten MCP Server kennen
Eigene MCP Server erstellen können

Was ist MCP?

Das Model Context Protocol — kurz MCP — ist ein offener Standard der von Anthropic entwickelt wurde, um KI-Assistenten mit externen Tools und Datenquellen zu verbinden. Stell dir MCP als USB-Anschluss für KI vor: So wie USB eine standardisierte Schnittstelle ist, über die du beliebige Geräte an deinen Computer anschließen kannst, verbindet MCP beliebige externe Dienste mit Claude Code. Ohne MCP ist Claude Code auf das beschränkt, was es direkt sehen und tun kann: Dateien lesen, Code schreiben, Terminal-Befehle ausführen. Das ist bereits mächtig, aber in der realen Entwicklung brauchst du oft Zugriff auf mehr: Datenbanken abfragen, GitHub Issues lesen, Slack-Nachrichten senden, Design-Dateien aus Figma laden, oder Fehler aus Sentry analysieren. MCP löst dieses Problem elegant. Jeder MCP Server ist ein kleines Programm, das bestimmte Fähigkeiten bereitstellt. Der GitHub MCP Server gibt Claude Zugriff auf Repositories, Issues und Pull Requests. Der PostgreSQL MCP Server ermöglicht direkte Datenbankabfragen. Der Puppeteer MCP Server lässt Claude einen Browser steuern. Und es gibt hunderte weitere — von AWS bis Notion, von Jira bis Stripe. Das Besondere an MCP: Es ist ein OFFENER Standard. Das bedeutet, jeder kann MCP Server bauen und teilen. Die Community wächst rasant, und für fast jeden populären Dienst gibt es bereits einen fertigen Server. Du kannst aber auch eigene Server für deine internen Tools und APIs erstellen. Wichtig zu verstehen: MCP Server laufen LOKAL auf deinem Rechner. Deine Daten werden nicht an Dritte gesendet. Der MCP Server verbindet sich mit dem externen Dienst und stellt die Ergebnisse Claude zur Verfügung — Claude selbst kommuniziert nie direkt mit den externen Diensten. Ein Wort der Warnung: Jeder aktive MCP Server verbraucht Platz im Context Window. Zu viele gleichzeitig aktive Server können den nutzbaren Kontext erheblich reduzieren. Die Empfehlung: Maximal 10 MCP Server gleichzeitig, mit unter 80 aktiven Tools insgesamt. Tipp: Seit neueren Versionen reduziert Tool Search Lazy Loading den Context-Verbrauch durch MCP-Tools um bis zu 95%.

💡 MCP in der Praxis Mit MCP Servern kann Claude: - Direkt auf deine Datenbank zugreifen - GitHub Issues erstellen und bearbeiten - Slack Nachrichten senden - Figma Designs analysieren - Monitoring-Daten auswerten - Und vieles mehr...

MCP Server hinzufügen

MCP Server zu deinem Claude Code Setup hinzuzufügen ist überraschend einfach. Es gibt zwei Wege: über die Kommandozeile für schnelle Einzelinstallationen, oder über eine Konfigurationsdatei für dauerhafte und komplexere Setups. Beide Wege führen zum gleichen Ergebnis — der Server steht dir in jeder neuen Claude Code Session zur Verfügung. Der schnellste Weg ist der CLI-Befehl 'claude mcp add'. Du gibst dem Server einen Namen, das Transportprotokoll und den Startbefehl an. Zum Beispiel: 'claude mcp add github npx @modelcontextprotocol/server-github' installiert den offiziellen GitHub MCP Server. Nach der Eingabe ist der Server sofort verfügbar. Für die meisten offiziellen MCP Server brauchst du einen API-Key oder Token. Diesen gibst du als Umgebungsvariable mit. Der GitHub Server braucht zum Beispiel ein GITHUB_TOKEN, der PostgreSQL Server braucht eine Datenbank-URL. Die nötigen Variablen sind in der Dokumentation jedes Servers aufgelistet. Nach der Installation kannst du mit 'claude mcp list' alle konfigurierten Server sehen und mit 'claude mcp remove <name>' einen Server wieder entfernen. Der Befehl 'claude /mcp' innerhalb einer Session zeigt dir den Status aller Server — ob sie verbunden sind, welche Tools sie bereitstellen und ob Fehler aufgetreten sind. Für Teams und komplexere Setups empfiehlt sich die Konfiguration über die .mcp.json Datei oder die .claude/settings.json. Diese Dateien kannst du ins Git-Repository einchecken, sodass alle Team-Mitglieder automatisch die gleichen MCP Server nutzen. Das ist besonders wertvoll wenn das Team mit gemeinsamen Datenbanken, Issue-Trackern oder Deployment-Tools arbeitet. Ein wichtiger Tipp: Teste jeden neuen MCP Server einzeln bevor du mehrere gleichzeitig aktivierst. So kannst du Fehler leichter isolieren und sicherstellen, dass jeder Server korrekt funktioniert.

# Grundlegende Syntax
claude mcp add <name> <command>

# HTTP Server hinzufügen (Remote)
claude mcp add --transport sse weather-api https://api.weather.example.com/mcp

# Stdio Server hinzufügen (Lokal)
claude mcp add github-mcp npx @anthropic/mcp-github

# Mit Environment Variables
claude mcp add postgres-db npx @anthropic/mcp-postgres \
  --env POSTGRES_URL=postgresql://localhost:5432/mydb

# Server auflisten
claude mcp list

# Server entfernen
claude mcp remove github-mcp

Transport-Typen

MCP Server nutzen eines von zwei Transport-Protokollen um mit Claude Code zu kommunizieren: stdio (Standard Input/Output) und SSE (Server-Sent Events). Der Transport-Typ bestimmt, wie der Server gestartet wird, wie die Kommunikation abläuft und welche Einsatzszenarien sich eignen. Du musst das nicht im Detail verstehen, aber ein Grundverständnis hilft bei der Fehlersuche. Der stdio-Transport ist der Standard und funktioniert für die meisten Anwendungsfälle. Dabei startet Claude Code den MCP Server als Kindprozess auf deinem lokalen Rechner. Die Kommunikation läuft über die Standard-Ein/Ausgabe des Prozesses — der Server liest Anfragen von stdin und schreibt Antworten auf stdout. Das ist effizient, einfach und funktioniert ohne Netzwerkkonfiguration. Stell dir stdio vor wie ein Telefongespräch: Claude Code ruft den Server an, stellt eine Frage, und der Server antwortet direkt. Es gibt eine direkte Verbindung, kein Netzwerk dazwischen. Deshalb ist stdio auch der sicherere Transport — die Daten verlassen nie deinen Rechner. Der SSE-Transport (Server-Sent Events) ist für Szenarien gedacht, in denen der MCP Server bereits als eigenständiger Dienst läuft — typischerweise ein HTTP-Server auf einem bestimmten Port. Claude Code verbindet sich über HTTP zu diesem Server. Das ist nützlich wenn der MCP Server von mehreren Clients gleichzeitig genutzt wird oder wenn er auf einem anderen Rechner läuft. Stell dir SSE vor wie eine Webseite: Der Server läuft irgendwo und wartet auf Anfragen. Claude Code verbindet sich über eine URL, schickt Anfragen und empfängt Antworten. Das ermöglicht Remote-Server und gemeinsame Nutzung im Team. Für den Einstieg empfehle ich dir stdio — es ist einfacher einzurichten, braucht keine Netzwerkkonfiguration und funktioniert sofort. SSE brauchst du erst, wenn du Server im Team teilen oder Remote-Dienste anbinden willst.

MCP TRANSPORT OPTIONEN
━━━━━━━━━━━━━━━━━━━━━━

1. HTTP/SSE (Server-Sent Events)
   → Für Remote/Cloud-basierte Server
   → Empfohlen für Production
   claude mcp add --transport sse <name> <url>

2. STDIO (Standard I/O)
   → Für lokale Prozesse
   → Direkter System-Zugriff
   claude mcp add <name> <command>

3. WebSocket
   → Für bidirektionale Kommunikation
   → Real-time Updates
   claude mcp add --transport ws <name> <url>

Top 10 MCP Server für Entwickler

Die MCP-Community ist in den letzten Monaten explosionsartig gewachsen. Stand Februar 2026 gibt es hunderte verfügbare Server für jeden erdenklichen Einsatzzweck. Aus dieser Fülle die richtigen auszuwählen kann überwältigend sein. Hier sind die zehn nützlichsten MCP Server für den typischen Entwickler-Alltag — getestet und bewährt. Der GitHub MCP Server ist vermutlich der meistgenutzte: Er gibt Claude direkten Zugriff auf Repositories, Issues, Pull Requests und Code Reviews. Damit kann Claude bestehende Issues analysieren, PRs erstellen und Code Reviews durchführen — alles aus der Konversation heraus, ohne dass du zwischen Terminal und Browser wechseln musst. Der PostgreSQL MCP Server (und ähnliche für MySQL, SQLite) ermöglicht direkte Datenbankabfragen. Claude kann Schemas inspizieren, Queries schreiben und testen, und Migrationsskripte erstellen. Besonders wertvoll beim Debugging von datenbasierten Problemen. Der Filesystem MCP Server erweitert Claudes Dateizugriff über das aktuelle Projekt hinaus. Nützlich wenn du auf Konfigurationsdateien, Shared Libraries oder Dokumentation in anderen Verzeichnissen zugreifen musst. Der Puppeteer/Playwright MCP Server gibt Claude einen Browser. Damit kann es Webseiten testen, Screenshots machen, Formulare ausfüllen und UI-Bugs reproduzieren. Ein Game-Changer für Frontend-Entwickler. Weitere wichtige Server: Sentry (Fehler-Tracking und -Analyse), Slack (Team-Kommunikation via Zapier), Figma (Design-System Zugriff), Memory (persistenter Speicher zwischen Sessions), Notion (Dokumentation und Wissensmanagement) und Context7 (aktuelle Library-Dokumentation). Aber Vorsicht: Nicht alle gleichzeitig aktivieren! Jeder MCP Server fügt Tools zum Context Window hinzu, was den verfügbaren Platz für deinen eigentlichen Code reduziert. Die goldene Regel: Aktiviere nur die Server die du für den aktuellen Task wirklich brauchst. Für die meisten Projekte reichen 3-5 gleichzeitig aktive Server völlig aus.

| Server | Beschreibung | Installation |
|--------|--------------|--------------|
| GitHub | Issues, PRs, Repos | npx @anthropic/mcp-github |
| PostgreSQL | Datenbank-Zugriff | npx @anthropic/mcp-postgres |
| Filesystem | Datei-Operationen | npx @anthropic/mcp-filesystem |
| Slack | Team-Kommunikation | npx @anthropic/mcp-slack |
| Figma | Design-Integration | npx @anthropic/mcp-figma |
| Sentry | Error-Monitoring | npx @anthropic/mcp-sentry |
| Linear | Issue-Tracking | npx @anthropic/mcp-linear |
| Notion | Dokumentation | npx @anthropic/mcp-notion |
| Puppeteer | Browser-Automation | npx @anthropic/mcp-puppeteer |
| Memory | Persistenter Speicher | npx @anthropic/mcp-memory |

Konfiguration via Config-Datei

Für komplexe MCP Setups mit mehreren Servern, Umgebungsvariablen und Team-Sharing empfiehlt sich die Konfiguration über eine zentrale Config-Datei. Statt jeden Server einzeln per Kommandozeile hinzuzufügen, definierst du alles in einer JSON-Datei — übersichtlich, versionierbar und teilbar. Die Konfiguration kann an zwei Orten liegen: In der Datei .mcp.json im Projektstamm oder innerhalb der .claude/settings.json. Die .mcp.json ist die empfohlene Variante für projektspezifische Server, weil du sie ins Git-Repository einchecken und so mit dem Team teilen kannst. Die Struktur der Datei ist einfach: Unter dem Schlüssel 'mcpServers' definierst du jeden Server mit einem eindeutigen Namen, dem Startbefehl, optionalen Argumenten und Umgebungsvariablen. Der Name ist frei wählbar und dient zur Identifikation in Claude Code. Ein typisches Setup könnte so aussehen: Ein GitHub Server für Issue-Management, ein PostgreSQL Server für die Entwicklungsdatenbank, und ein Sentry Server für Fehler-Tracking. Jeder Server bekommt seine eigenen API-Keys und Konfigurationsoptionen. Wichtig: API-Keys und Secrets solltest du NIEMALS direkt in die Config-Datei schreiben wenn du sie ins Repository eincheckst. Nutze stattdessen Umgebungsvariablen: Definiere die Variable in deiner Shell-Konfiguration (.bashrc, .zshrc) oder einer .env Datei, und referenziere sie in der MCP-Config. Für Teams hat die Config-Datei noch einen weiteren Vorteil: Neue Teammitglieder bekommen automatisch das richtige MCP-Setup wenn sie das Repository klonen. Keine manuellen Installationsschritte nötig — Claude Code liest die Konfiguration beim Start und verbindet sich mit allen definierten Servern. Ein Praxis-Tipp: Beginne mit einer minimalen Konfiguration und erweitere sie schrittweise. Füge einen Server hinzu, teste ihn gründlich, und füge erst dann den nächsten hinzu. Das vermeidet Konflikte und macht Debugging einfacher.

// ~/.claude/mcp_servers.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@anthropic/mcp-github"],
      "env": {
        "GITHUB_TOKEN": "$GITHUB_TOKEN"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["@anthropic/mcp-postgres"],
      "env": {
        "POSTGRES_URL": "postgresql://localhost:5432/myapp"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["@anthropic/mcp-filesystem", "/Users/me/projects"]
    }
  }
}

Eigenen MCP Server erstellen

Wenn kein bestehender MCP Server deine spezifischen Anforderungen erfüllt, kannst du deinen eigenen bauen. Das klingt kompliziert, ist aber einfacher als du denkst. Ein MCP Server ist im Kern ein Programm, das über ein standardisiertes Protokoll Tools bereitstellt — ähnlich wie eine REST API, aber speziell für die Kommunikation mit KI-Assistenten optimiert. Warum würdest du einen eigenen Server bauen? Typische Gründe sind: Du hast interne APIs die kein öffentlicher Server kennt. Du brauchst Zugriff auf proprietäre Datenquellen. Du willst einen bestimmten Workflow automatisieren der spezifisch für dein Unternehmen ist. Oder du möchtest ein bestehendes Tool um KI-Fähigkeiten erweitern. Das Anthropic-Team stellt SDKs für TypeScript und Python bereit, die den Großteil der Arbeit für dich erledigen. Du definierst deine Tools als Funktionen, gibst ihnen Namen und Beschreibungen, und das SDK kümmert sich um die gesamte MCP-Protokoll-Kommunikation. Ein Tool in einem MCP Server besteht aus drei Teilen: Einem Namen der beschreibt was es tut (z.B. 'get_customer_orders'), einer Beschreibung die Claude erklärt wann und wie es das Tool nutzen soll, und einem Input-Schema das die erwarteten Parameter definiert. Claude liest diese Informationen und entscheidet selbst, wann ein Tool relevant ist. Der einfachste MCP Server hat vielleicht 50 Zeilen Code: Du erstellst eine Server-Instanz, registrierst ein oder mehrere Tools mit ihren Handler-Funktionen, und startest den Server mit stdio-Transport. Das Ganze läuft als Node.js oder Python Skript. Beim Design deiner Tools ist die Beschreibung der wichtigste Teil. Claude nutzt die Beschreibung um zu entscheiden ob und wann es ein Tool aufruft. Eine klare, spezifische Beschreibung führt zu besseren Ergebnissen als eine vage. Erkläre nicht nur WAS das Tool tut, sondern WANN es genutzt werden sollte.

// my-mcp-server/index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-custom-server",
  version: "1.0.0",
}, {
  capabilities: {
    tools: {},
  },
});

// Tool definieren
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "get_weather",
    description: "Holt Wetterdaten für eine Stadt",
    inputSchema: {
      type: "object",
      properties: {
        city: { type: "string", description: "Stadtname" }
      },
      required: ["city"]
    }
  }]
}));

// Tool implementieren
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "get_weather") {
    const city = request.params.arguments.city;
    // API-Call oder Logik hier
    return { content: [{ type: "text", text: Wetter in ${city}: Sonnig, 22°C }] };
  }
});

// Server starten
const transport = new StdioServerTransport();
await server.connect(transport);

🔒 Sicherheit MCP Security Best Practices: 1. Nutze Environment Variables für Secrets 2. Beschränke Dateisystem-Zugriff auf nötige Pfade 3. Prüfe MCP Server vor Installation 4. Nutze read-only Permissions wo möglich 5. Logge MCP-Aktivitäten für Audit

Praktisches Beispiel: GitHub + PostgreSQL

Die wahre Stärke von MCP entfaltet sich wenn du mehrere Server kombinierst. Jeder Server allein ist nützlich, aber zusammen ermöglichen sie Workflows die sonst manuelles Hin-und-Her zwischen verschiedenen Tools erfordern würden. Dieses Beispiel zeigt, wie GitHub und PostgreSQL MCP Server zusammenarbeiten. Stell dir folgendes Szenario vor: Ein Kunde meldet über GitHub Issues einen Bug — 'Bestellhistorie zeigt falsche Summen'. Ohne MCP müsstest du: Das Issue auf GitHub öffnen, den relevanten Code finden, die Datenbank manuell abfragen, den Bug identifizieren und fixe, einen PR erstellen, und das Issue schließen. Das sind mindestens 6 verschiedene Tools und Fenster. Mit GitHub + PostgreSQL MCP geht das alles in einer Claude Code Session: Du sagst Claude 'Schau dir Issue #42 an und finde den Bug'. Claude liest das Issue über den GitHub MCP Server, findet den betroffenen Code, fragt über den PostgreSQL MCP Server die echten Daten ab um den Bug zu reproduzieren, identifiziert das Problem (vielleicht eine falsche JOIN-Bedingung), implementiert den Fix, schreibt einen Test, erstellt einen PR mit Referenz zum Issue, und postet einen Kommentar auf dem Issue. Diese Integration spart nicht nur Zeit, sondern reduziert auch Kontextwechsel. Du bleibst die ganze Zeit in einer einzigen Umgebung und behältst den Überblick. Claude sieht alle relevanten Informationen gleichzeitig und kann bessere Entscheidungen treffen. Für das Setup brauchst du: Einen GitHub Personal Access Token mit den richtigen Berechtigungen, eine PostgreSQL Verbindungs-URL zu deiner Entwicklungsdatenbank, und die Konfiguration beider Server in deiner .mcp.json. Die genaue Konfiguration siehst du im folgenden Code-Beispiel. Ein Sicherheitshinweis: Verbinde den PostgreSQL MCP Server NIEMALS mit einer Produktionsdatenbank. Nutze immer eine Entwicklungs- oder Staging-Umgebung. Claude könnte versehentlich Daten ändern oder löschen.

# 1. GitHub MCP Server hinzufügen
export GITHUB_TOKEN="ghp_your_token_here"
claude mcp add github npx @anthropic/mcp-github

# 2. PostgreSQL MCP Server hinzufügen
claude mcp add mydb npx @anthropic/mcp-postgres \
  --env POSTGRES_URL="postgresql://user:pass@localhost:5432/myapp"

# 3. Claude starten und nutzen
claude

# Jetzt kannst du sagen:
> "Zeige mir alle offenen GitHub Issues und erstelle
   für jedes eine Zeile in der issues-Tabelle"

# Claude wird:
# - GitHub API nutzen um Issues zu laden
# - PostgreSQL nutzen um Daten einzufügen
# - Dir das Ergebnis zeigen

MCP Debugging

Wenn ein MCP Server nicht funktioniert, kann das frustrierend sein — besonders wenn die Fehlermeldungen kryptisch sind. Die gute Nachricht: Die meisten MCP-Probleme haben eine handvoll typischer Ursachen, und mit systematischem Debugging findest du den Fehler meist in wenigen Minuten. Die drei häufigsten Fehlerquellen sind: Erstens ein falscher Pfad oder fehlende Abhängigkeiten — der MCP Server kann nicht gestartet werden weil das angegebene Programm nicht gefunden wird oder eine Dependency fehlt. Zweitens fehlende oder falsche Umgebungsvariablen — der Server startet, kann sich aber nicht mit dem externen Dienst verbinden weil der API-Key fehlt oder abgelaufen ist. Drittens Timeout-Probleme — der Server braucht zu lange zum Starten oder Antworten. Dein erstes Debug-Werkzeug ist der /mcp Befehl innerhalb einer Claude Code Session. Er zeigt dir den Status aller konfigurierten Server: Grün bedeutet verbunden, Rot bedeutet Fehler. Bei einem Fehler wird oft schon eine hilfreiche Fehlermeldung angezeigt. Für tieferes Debugging nutze das --verbose Flag beim Start: 'claude --verbose'. Damit siehst du im Detail was passiert wenn Claude Code die MCP Server startet — welche Befehle ausgeführt werden, welche Umgebungsvariablen gesetzt sind, und welche Fehler auftreten. Ein häufiges Problem bei npx-basierten Servern: Der npx Cache ist veraltet oder beschädigt. In diesem Fall hilft 'npx --cache-clear' gefolgt von einem Neustart. Bei Python-basierten Servern ist oft eine falsche Python-Version oder fehlende pip-Packages das Problem. Wenn nichts anderes hilft, teste den MCP Server isoliert. Starte ihn manuell im Terminal und schicke ihm eine Test-Anfrage. So kannst du prüfen ob das Problem beim Server selbst oder bei der Integration mit Claude Code liegt.

# MCP Server Status prüfen
claude mcp list --status

# Verbose Logging aktivieren
claude --verbose

# MCP Logs anzeigen
claude mcp logs github

# Server neu starten
claude mcp restart github

# Alle Server neustarten
claude mcp restart --all

Populäre MCP Server (2026)

Die MCP-Landschaft entwickelt sich rasant weiter. Was vor wenigen Monaten noch experimentell war, ist heute produktionsreif. Stand Februar 2026 gibt es über 500 verfügbare MCP Server, und es kommen wöchentlich neue hinzu. Hier ein Überblick über die wichtigsten Kategorien und die populärsten Implementierungen in jeder. In der Kategorie Versionskontrolle und Projektmanagement dominiert der offizielle GitHub Server. Er bietet umfassenden Zugriff auf Repositories, Issues, Pull Requests, Actions und Code Search. Für GitLab und Bitbucket gibt es Community-Server die ähnliche Funktionalität bieten. Jira und Linear haben ebenfalls gut gepflegte MCP Server für Issue-Tracking. Bei Datenbanken gibt es Server für praktisch jedes System: PostgreSQL, MySQL, SQLite, MongoDB, Redis und mehr. Diese Server ermöglichen Schema-Inspektion, Query-Ausführung und teilweise sogar Migrations-Management direkt aus Claude Code heraus. Für Frontend-Entwickler sind die Browser-Automation Server besonders wertvoll: Puppeteer und Playwright ermöglichen es Claude einen echten Browser zu steuern — Seiten öffnen, Screenshots machen, Formulare ausfüllen, E2E-Tests ausführen. Der Figma MCP Server gibt Zugriff auf Design-Systeme und Komponenten-Bibliotheken. Die Monitoring-Kategorie umfasst Sentry (Error-Tracking), Datadog (Metriken), Grafana (Dashboards) und CloudWatch (AWS-Monitoring). Damit kann Claude Fehler analysieren, Performance-Probleme identifizieren und Monitoring-Dashboards erstellen. Noch relativ neu aber sehr nützlich: Dokumentations-Server wie Context7, die Claude Zugriff auf aktuelle Library-Dokumentation geben. Statt sich auf möglicherweise veraltetes Trainingswissen zu verlassen, kann Claude die neueste API-Dokumentation direkt nachschlagen. Mein Rat: Starte mit 2-3 Servern die deinen Alltag am meisten vereinfachen, und erweitere schrittweise. Die Versuchung alles zu installieren ist groß, aber zu viele aktive Server belasten dein Context Window unnötig.

# 🎭 Playwright – Browser-Automation
claude mcp add playwright npx @anthropic-ai/mcp-playwright
# → Webseiten öffnen, Screenshots machen, klicken, tippen
# → Ideal für Frontend-Testing und visuelles Debugging

# 🎨 Figma – Design-to-Code
claude mcp add figma npx @anthropic-ai/mcp-figma
# → Figma-Designs lesen und in Code umwandeln
# → Farben, Abstände, Komponenten extrahieren

# 📁 Filesystem – Erweiterte Datei-Operationen
claude mcp add fs npx @anthropic-ai/mcp-filesystem /path/to/project
# → Für kontrollierte Datei-Zugriffe in Sandbox

# 🔍 Exa – Web-Suche
claude mcp add exa npx @anthropic-ai/mcp-exa \
  --env EXA_API_KEY="your-key"
# → Web-Recherche direkt aus Claude Code

# 📊 Sentry – Error-Monitoring
claude mcp add sentry npx @sentry/mcp-server \
  --env SENTRY_AUTH_TOKEN="your-token"
# → Fehler aus Produktion direkt analysieren

# 🗃️ Supabase – Backend-as-a-Service
claude mcp add supabase npx @supabase/mcp-server \
  --env SUPABASE_URL="https://xyz.supabase.co" \
  --env SUPABASE_KEY="your-key"

💡 MCP Best Practice Weniger ist mehr bei MCP Servern: - Jeder aktive MCP Server verbraucht Tokens (Tool-Beschreibungen) - Nur Server aktivieren die du gerade brauchst - claude mcp disable server-name zum Deaktivieren - claude mcp enable server-name zum Reaktivieren 💡 Tipp: Lektion 23 (Kosten-Optimierung) erklärt wie MCP Server den Token-Verbrauch beeinflussen.