Claude Code Integrationen: MCP-Server, IDE-Setup und CI/CD

Claude Code ist schon allein leistungsstark. Es liest Ihre Dateien, schreibt Code, führt Befehle aus. Aber im Moment kopieren Sie jedes Mal wenn Claude etwas außerhalb Ihres Projekts wissen muss — ein Datenbankschema, ein GitHub-Issue, einen Sentry-Fehler — alles von Hand. Sie sind der Mittelsmann.

Was wäre, wenn Claude sich diese Informationen einfach... selbst holen könnte?

Genau das machen MCP-Server. Nur 8% der Setups in unserer Analyse konfigurieren sie, aber diese erreichen durchschnittlich 7.5/10. Der Grund ist einfach: MCP-Server eliminieren die Copy-Paste-Steuer, die den Großteil einer Session-Zeit auffrisst.

Richten wir jetzt einen ein. In unter fünf Minuten haben Sie ihn laufen.

Ihr erster MCP-Server: GitHub

MCP steht für Model Context Protocol. Es ist ein offener Standard der Claude über eine strukturierte Schnittstelle mit externen Diensten kommunizieren lässt. Ein MCP-Server ist ein kleines Programm das im Hintergrund läuft und Claude Zugang zu Tools gibt — wie Issues durchsuchen, Datenbanken abfragen oder Dokumentation lesen.

Fangen wir mit dem GitHub MCP-Server an, weil das Setup kinderleicht ist und der Nutzen sofort spürbar.

Fügen Sie dies zu Ihrer .claude/settings.json hinzu:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_ihr_token_hier"
      }
    }
  }
}

Sie brauchen ein GitHub Personal Access Token. Gehen Sie zu GitHub > Settings > Developer Settings > Personal access tokens > Generate new token. Geben Sie ihm den repo Scope.

Starten Sie Claude Code neu und probieren Sie:

> Liste meine 5 neuesten Pull Requests

Claude bittet Sie nichts einzufügen. Es ruft den GitHub MCP-Server auf, holt Ihre PRs und zeigt sie an. Probieren Sie jetzt:

> Was ist der Status von Issue #42? Lies auch die Kommentare.

Claude holt das Issue, liest die Diskussion und hat den vollen Kontext. Wenn Sie sagen „arbeite an Issue #42", weiß es tatsächlich was Issue #42 besagt — ohne dass Sie die Beschreibung in den Chat kopieren.

Das ist der ganze Punkt von MCP: Claude holt sich den Kontext selbst, statt dass Sie den Kurier spielen.

Der Datenbank-MCP-Server (der alles verändert)

Wenn Sie PostgreSQL nutzen, ist das der MCP-Server bei dem Sie sich fragen werden wie Sie jemals ohne gearbeitet haben.

Fügen Sie zu .claude/settings.json hinzu:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://dev:dev@localhost:5432/myapp_dev"
      }
    }
  }
}

Was das freischaltet:

• Claude liest Ihre echten Tabellenschemata bevor es Queries schreibt — kein Raten bei Spaltennamen mehr
• Es kann SELECT-Queries ausführen um Datenstrukturen zu verstehen
• Migrationsgenerierung wird präzise weil Claude das echte aktuelle Schema sieht
• Spaltennamen-Fehler werden erkannt bevor der Code läuft

Wichtig: Verwenden Sie einen schreibgeschützten Datenbankbenutzer. Claude braucht keinen Schreibzugriff um Ihr Schema zu verstehen:

CREATE USER claude_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE myapp_dev TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;

Probieren Sie es. Fragen Sie Claude: „Zeig mir das Schema der users-Tabelle." Es fragt die Datenbank direkt ab und gibt Ihnen die exakten Spalten, Typen und Constraints. Kein „Ich nehme an das Schema sieht ungefähr so aus" mehr.

Weitere MCP-Server die sich lohnen

Sobald Sie den Dreh raus haben, hier die anderen Server die ihren Platz verdienen:

Slack — Team-Konversationen durchsuchen

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-ihr-bot-token"
      }
    }
  }
}

Arbeiten Sie an einem Feature das letzte Woche in Slack besprochen wurde? Statt die Konversation selbst zusammenzufassen, sucht Claude sie direkt.

Sentry — Fehlerberichte abrufen

{
  "mcpServers": {
    "sentry": {
      "command": "npx",
      "args": ["-y", "@sentry/mcp-server"],
      "env": {
        "SENTRY_AUTH_TOKEN": "ihr_sentry_token",
        "SENTRY_ORG": "ihre-org",
        "SENTRY_PROJECT": "ihr-projekt"
      }
    }
  }
}

Debuggen Sie einen Produktionsfehler? Claude holt die exakte Stack-Trace, betroffene Nutzerzahl und Fehlerhäufigkeit aus Sentry. Kein Screenshotting von Fehlerberichten und Einfügen in den Chat mehr.

Context7 — Live-Dokumentation

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  }
}

Dieser ist heimlich super nützlich. Statt sich auf Trainingsdaten zu verlassen (die veraltet sein könnten), holt Claude die aktuelle Doku für die exakte Bibliotheksversion die Sie nutzen. Besonders praktisch bei schnelllebigen Bibliotheken wie Next.js, React oder Prisma wo sich die API zwischen Versionen ändert.

Filesystem — Auf Dateien außerhalb Ihres Projekts zugreifen

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/Users/sie/projekte/shared-libs",
        "/Users/sie/projekte/design-system"
      ]
    }
  }
}

Monorepo? Claude soll Ihr Design-System referenzieren während es ein Feature bearbeitet? Der Filesystem-Server gibt ihm Zugang zu Verzeichnissen außerhalb des aktuellen Projekts.

IDE-Integration: Claude dort treffen wo Sie coden

VS Code

Der schnellste Einstieg:

1. Installieren Sie die Claude Code Extension aus dem VS Code Marketplace
2. Öffnen Sie Ihr Projekt
3. Drücken Sie Cmd+Shift+P (Mac) oder Ctrl+Shift+P (Windows/Linux) und tippen Sie „Claude"
4. Wählen Sie „Claude Code: Open Panel"

Die VS Code Extension gibt Claude Zugang zu Ihren geöffneten Dateien, Terminal-Ausgabe, TypeScript-Fehlern, ESLint-Warnungen — alles ohne Copy-Paste.

JetBrains (IntelliJ, WebStorm, PyCharm)

Öffnen Sie das eingebaute Terminal in Ihrer JetBrains IDE und führen Sie claude aus. Es funktioniert im Terminal-Panel mit vollem Projektzugriff. Das JetBrains-Plugin (derzeit in Beta) fügt Inline-Vorschläge und ein Chat-Panel in der IDE hinzu.

Terminal mit tmux

Wenn Sie im Terminal leben, funktioniert dieses Muster gut — Claude in einem Fenster, Ihr Editor im anderen:

tmux new-session -d -s dev
tmux split-window -h
tmux send-keys -t dev:0.1 'claude' Enter
tmux attach -t dev

Sie coden links, Claude läuft rechts. Gleiches Projektverzeichnis, null Kontextwechsel.

CI/CD: Claude reviewt jede PR automatisch

Hier wird Claude Code vom persönlichen Tool zur Team-Infrastruktur.

Automatisierte PR-Review mit GitHub Actions

Erstellen Sie .github/workflows/claude-review.yml:

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Claude Code Review
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Überprüfe diesen Pull Request. Prüfe auf:
            1. Sicherheitsprobleme (SQL Injection, XSS, exponierte Secrets)
            2. Performance-Probleme (N+1 Queries, fehlende Indizes)
            3. Fehlende Fehlerbehandlung
            4. Testabdeckungslücken

            Poste dein Review als PR-Kommentar mit KRITISCH und INFORMELL Sektionen.

Jede PR bekommt ein gründliches Review bevor ein Mensch überhaupt hinschaut. Mechanische Probleme werden automatisch gefangen, damit Ihre menschlichen Reviewer sich auf Architektur und Design-Entscheidungen konzentrieren können.

Automatisiertes Issue-Triage

name: Issue Triage
on:
  issues:
    types: [opened]

jobs:
  triage:
    runs-on: ubuntu-latest
    permissions:
      issues: write
    steps:
      - uses: actions/checkout@v4

      - name: Triage Issue
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Analysiere dieses GitHub Issue. Basierend auf der Codebase:
            1. Identifiziere welche Dateien wahrscheinlich betroffen sind
            2. Schätze die Komplexität (trivial / moderat / komplex)
            3. Schlage relevante Labels vor
            4. Wenn es ein Bug ist, versuche die Ursache zu identifizieren

            Poste deine Analyse als Kommentar.

Neue Issues werden automatisch analysiert — betroffene Dateien identifiziert, Komplexität geschätzt, Labels vorgeschlagen. Ihr Team verbringt weniger Zeit mit Sortieren und mehr mit Bauen.

Headless-Modus für Scripting

Claude Code kann nicht-interaktiv laufen für benutzerdefinierte Automatisierung:

# Einzelnen Prompt ausführen und beenden
claude -p "Führe die Testsuite aus und melde Fehler" --output-format json

# Eingabe pipen
echo "Erkläre die Architektur dieses Projekts" | claude -p --output-format text

# In einem Skript verwenden
RESULT=$(claude -p "Prüfe auf TODO-Kommentare in src/" --output-format json)
echo "$RESULT" | jq '.output'

Das ist der Baustein für benutzerdefinierte CI/CD-Schritte, Pre-Commit-Hooks und jeden Workflow bei dem Claude einen bestimmten Job erledigen und zurückmelden soll.

Halten Sie Ihre Tokens sicher

MCP-Server laufen mit Ihren Credentials. Nehmen Sie das ernst.

Committen Sie nie Tokens in settings.json. Verwenden Sie stattdessen Umgebungsvariablen-Referenzen:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Verwenden Sie schreibgeschützte Credentials wo immer möglich. Claude braucht selten Schreibzugriff auf Ihre Datenbank oder GitHub.

Beschränken Sie auf das Nötige. Verbinden Sie keine Produktionsdatenbank — nutzen Sie Dev oder Staging.

Prüfen Sie den MCP-Server-Code. Das sind npm-Pakete die mit Ihren Credentials laufen. Prüfen Sie den Quellcode, bevorzugen Sie offizielle Pakete und fixieren Sie Versionen.

Das komplette Setup

Hier ist die vollständige .claude/settings.json für ein gut integriertes Projekt — Berechtigungen, MCP-Server und Hooks arbeiten zusammen:

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git *)",
      "Read",
      "Glob",
      "Grep"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force*)"
    ]
  },
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DEV_DATABASE_URL}"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": ".claude/hooks/pre-tool-guard.sh"
      }
    ]
  }
}

Datenbankschema-Zugriff, GitHub Issues und PRs, Live-Dokumentation, Sicherheits-Guards und vernünftige Berechtigungen. Das ist eine vernetzte Entwicklungsumgebung, kein isolierter Chatbot.

Wie es weitergeht

Mit Integrationen wird Claude Code zu einem Tool das sich seinen eigenen Kontext holt statt einem Tool in das Sie Kontext einfügen. Die nächsten Schritte:

• Workflow-Muster — Subagents, Code-Review-Orchestrierung und die Debugging-Strategien der Power-User
• Kostenoptimierung — MCP-Server erhöhen den Token-Verbrauch, also halten diese Strategien Ihre Rechnung im Griff
• Ihr Setup bewerten um zu sehen wie Ihre Integrationen im Vergleich zu Top-Konfigurationen abschneiden

Häufig gestellte Fragen

Wie viele MCP-Server kann ich gleichzeitig betreiben?

Kein hartes Limit, aber jeder Server ist ein separater Prozess der Speicher und CPU nutzt. In der Praxis sind 3-5 der Sweet Spot. Darüber hinaus steigt die Startzeit und Claudes Kontext wird mit Tool-Beschreibungen überfrachtet. Starten Sie mit den Servern die Ihnen am meisten Copy-Paste ersparen — typischerweise Datenbank und GitHub.

Funktionieren MCP-Server mit dem Max-Plan oder nur der API?

Beide. MCP-Server laufen lokal auf Ihrem Rechner unabhängig vom Abrechnungsmodell. Der einzige Kostenunterschied: MCP-Tool-Aufrufe erzeugen zusätzliche Tokens (Tool-Beschreibungen, Eingaben, Ausgaben), was bei API-Preisen pro Token mehr ins Gewicht fällt als beim Max-Pauschalplan.

Kann ich meinen eigenen MCP-Server schreiben?

Ja, und es ist einfacher als Sie denken. Ein MCP-Server kommuniziert über stdio mit JSON-RPC. Das @modelcontextprotocol/sdk Paket bietet TypeScript-Helfer:

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

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

server.setRequestHandler("tools/list", async () => ({
  tools: [{ name: "my_tool", description: "Does something useful", inputSchema: { type: "object" } }]
}));

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

Es gibt auch SDKs für Python, Go und Rust.

Ist die GitHub Actions Integration sicher?

Die offizielle anthropics/claude-code-action läuft in einer gesandboxten CI-Umgebung. Sie kann nur auf das zugreifen was Sie über GitHub Actions Permissions gewähren (contents: read, pull-requests: write). Speichern Sie Ihren Anthropic API-Key als GitHub Secret, nie hartcodiert. Das Hauptrisiko sind Kosten — eine außer Kontrolle geratene Action auf einem aktiven Repo kann hohe API-Kosten erzeugen. Setzen Sie Ausgabenalarme und begrenzen Sie welche Events die Action auslösen.

Warum MCP statt Claude einfach Shell-Befehle ausführen zu lassen?

Shell-Befehle funktionieren, aber sie sind fragil. Mit einem PostgreSQL MCP-Server ruft Claude query("SELECT * FROM users LIMIT 5") auf — es muss keinen psql-Connection-String herausfinden, keine Authentifizierung handhaben oder tabellarische Ausgabe parsen. MCP gibt Claude typisierten, strukturierten Zugriff auf Ihre Tools. Weniger Fehler, zuverlässigere Ergebnisse, und Sie können Datenbank-Lesezugriff gewähren ohne vollen Shell-Zugriff zu geben.