Das Problem: Deine KI ist ein Einzelgänger

Stell dir vor, du hast einen brillanten Assistenten – Claude, ChatGPT, GitHub Copilot. Der kann Code schreiben, Texte formulieren, Probleme lösen. Aber: Er sitzt in einem fensterlosen Raum.

Er hat keinen Zugriff auf:

• Deine GitHub Issues
• Deine Sentry Error-Logs
• Deine Datenbank
• Deine API-Dokumentation
• Deine internen Tools

Das Resultat: Du kopierst ständig Daten hin und her:

Du: "Hier ist mein Sentry Error-Log [kopiert 500 Zeilen]"
KI: "Ich sehe das Problem..."
Du: "Und hier ist der relevante Code [kopiert 300 Zeilen]"
KI: "Ah, jetzt verstehe ich..."
Du: "Und hier ist die API-Doku [kopiert weitere 400 Zeilen]"

Das ist mühsam, fehleranfällig und verschwendet Zeit.

MCP Server lösen dieses Problem ein für alle Mal.

Was ist ein MCP Server?

Ein MCP Server ist wie ein Türsteher, der deiner KI kontrolliert Zugang zu deinen Daten gibt.

Die Analogie: KI als neuer Mitarbeiter

Ohne MCP: Dein neuer Mitarbeiter (die KI) sitzt in einem leeren Büro. Jedes Mal, wenn er etwas braucht, muss er dich fragen:

• “Kannst du mir die Kundendaten geben?”
• “Kannst du mir zeigen, was im CRM steht?”
• “Kannst du nachsehen, welche Tickets offen sind?”

Du bist der Flaschenhals. Alles läuft über dich.

Mit MCP: Der Mitarbeiter hat einen Badge (MCP Server), der ihm Zugang zu bestimmten Räumen gibt:

• Zugang zum GitHub-Archiv
• Zugang zum Sentry-Monitoring
• Zugang zur Datenbank
• KEIN Zugang zum Finanz-System (Security!)

Er kann selbstständig arbeiten, aber nur in dem Rahmen, den du definiert hast.

Technisch gesehen

MCP steht für Model Context Protocol – ein Standard-Protokoll, das Anthropic im November 2024 veröffentlicht hat¹.

Ein MCP Server ist:

• Eine Software, die zwischen deiner KI und einer Datenquelle sitzt
• Spricht ein standardisiertes “Protokoll” (wie USB für Hardware)
• Kann lokal auf deinem Rechner laufen oder remote gehostet sein
• Gibt der KI strukturierten, sicheren Zugriff auf Daten

Das Geniale: Einmal einen MCP Server einrichten → alle MCP-kompatiblen Tools können ihn nutzen.

Warum wurde MCP erfunden?

Vor MCP hatte jede App ihre eigene Integration:

Claude       → Custom GitHub Integration
Cursor       → Custom GitHub Integration
VS Code + KI → Custom GitHub Integration
Windsurf     → Custom GitHub Integration

Die Probleme:

• Jede App muss das Rad neu erfinden
• Unterschiedliche Qualität
• Sicherheitsrisiken durch fragmentierte Zugänge
• Hoher Wartungsaufwand

Mit MCP:

Claude        ↘
Cursor        →  MCP Server  →  GitHub
VS Code + KI  ↗
Windsurf      ↗

Die Vorteile:

• Einmal einrichten, überall nutzen
• Standardisierte Sicherheit
• Open-Source-Ökosystem (Tausende fertige Server)
• Zentrale Verwaltung

Die Adoption: Wer nutzt MCP?

November 2024: Anthropic launcht MCP März 2025: OpenAI integriert MCP in ChatGPT Desktop, Agents SDK, Responses API² April 2025: Microsoft entwickelt offizielles C# SDK³ April 2025: Google kündigt MCP-Support für Gemini an⁴

Das bedeutet: MCP wird der Industrie-Standard für KI-Integrationen.

Wer heute MCP lernt, ist für die nächsten Jahre gerüstet.

Die 5 wichtigsten MCP Server für den Einstieg

Schauen wir uns konkrete MCP Server an, die du heute nutzen kannst.

1. GitHub MCP Server

Was macht er? Gibt deiner KI Zugriff auf GitHub:

• Repositories durchsuchen
• Issues lesen und erstellen
• Pull Requests analysieren
• Commits nachverfolgen
• Code-Historie verstehen

Warum ist das nützlich?

Statt:

Du: "Welche Issues sind noch offen?"
[Du öffnest GitHub, kopierst die Liste]
Du: [Fügt 20 Issues ein]
KI: "Okay, ich sehe..."

Mit GitHub MCP:

Du: "Welche Security-Issues sind noch offen?"
KI: [Ruft automatisch GitHub ab]
KI: "Es gibt 3 offene Security-Issues:
     1. XSS-Schwachstelle in Login-Form
     2. SQL-Injection in Search
     3. Unsichere Session-Verwaltung"

Wie installiere ich das?

# MCP Server für GitHub installieren
npm install -g @modelcontextprotocol/server-github

# In Claude hinzufügen
claude mcp add --transport http github https://mcp.github.com

Du wirst nach einem GitHub Token gefragt. Den bekommst du hier:

1. Gehe zu https://github.com/settings/tokens
2. Klicke “Generate new token (classic)”
3. Wähle Scopes: repo, read:org, read:user
4. Kopiere den Token und füge ihn ein

Fertig! Claude hat jetzt Zugriff auf deine GitHub-Daten.

2. Sentry MCP Server

Was macht er? Verbindet deine KI mit Sentry (Error-Tracking):

• Fehler analysieren
• Stacktraces interpretieren
• Fix-Vorschläge generieren
• Performance-Probleme identifizieren

Warum ist das nützlich?

Ohne MCP:

1. Du siehst einen Error in Sentry
2. Kopierst den Stacktrace
3. Kopierst den betroffenen Code
4. Fragst die KI: “Was ist hier falsch?”
5. Die KI rät (ohne Kontext)

Mit Sentry MCP:

Du: "Was ist mit dem TypeError in production?"
KI: [Holt automatisch Error-Details von Sentry]
KI: "Der TypeError tritt auf, weil user.profile in
     auth.ts:42 undefined sein kann. Das Problem wurde
     127 Mal in den letzten 24h gemeldet.

     Fix: Füge eine Null-Check hinzu:
     if (!user.profile) throw new AuthError('Profile missing')"

Installation:

# Sentry MCP Server installieren
npm install -g @modelcontextprotocol/server-sentry

# Konfiguration in Claude
claude mcp add --transport http sentry https://mcp.sentry.io \
  --header "Authorization: Bearer YOUR_SENTRY_TOKEN"

Sentry Token bekommst du in deinen Sentry Settings unter “Auth Tokens”.

3. Puppeteer MCP Server

Was macht er? Gibt deiner KI die Kontrolle über einen Browser:

• Webseiten öffnen
• Formulare ausfüllen
• Screenshots erstellen
• Daten von Webseiten extrahieren
• E2E-Tests durchführen

Warum ist das nützlich?

Beispiel 1: Testing

Du: "Teste den Checkout-Flow auf unserer Webseite"
KI: [Startet Browser]
    [Navigiert zu Shop]
    [Legt Produkt in Warenkorb]
    [Geht zur Kasse]
    [Füllt Formular aus]
    [Macht Screenshot]
KI: "Der Checkout funktioniert, aber das Total
     wird erst nach 3 Sekunden angezeigt.
     Performance-Problem? Hier ist der Screenshot."

Beispiel 2: Data Scraping

Du: "Extrahiere alle Preise von competitor.com"
KI: [Öffnet competitor.com]
    [Scrollt durch Produktliste]
    [Sammelt Daten]
KI: "Ich habe 47 Produkte gefunden. Durchschnittspreis: 89€.
     Unsere Preise sind im Schnitt 12% teurer."

Installation:

# Puppeteer MCP Server
npm install -g @modelcontextprotocol/server-puppeteer

# Starte lokal (kein externer Token nötig)
puppeteer-mcp-server --port 3001

# Füge zu Claude hinzu
claude mcp add --transport http puppeteer http://localhost:3001

Wichtig: Puppeteer läuft lokal auf deinem Rechner. Die KI steuert einen Browser, der auf deinem PC läuft.

4. Firebase MCP Server

Was macht er? Gibt deiner KI Zugriff auf Firebase:

• Firestore-Datenbank lesen/schreiben
• Cloud Storage verwalten
• User Authentication
• Realtime Database

Warum ist das nützlich?

Beispiel: Daten-Cleanup

Du: "Lösche alle abgelaufenen Sessions aus Firestore"
KI: [Verbindet mit Firebase]
    [Query: sessions WHERE expiresAt < NOW()]
    [Findet 342 Sessions]
    [Löscht sie]
KI: "342 abgelaufene Sessions gelöscht.
     Älteste war von vor 90 Tagen."

Beispiel: User-Management

Du: "Welche User haben sich diese Woche registriert?"
KI: [Query Firestore]
KI: "27 neue User seit Montag.
     Top Herkunft: Deutschland (12), Österreich (8), Schweiz (7)"

Installation:

# Firebase MCP Server
npm install -g @modelcontextprotocol/server-firebase

# Benötigt Firebase Service Account Key
# (Download von Firebase Console → Project Settings → Service Accounts)

claude mcp add --transport http firebase https://mcp.firebase.com \
  --config service-account-key.json

Sicherheitshinweis: Der Service Account Key hat volle Zugriffsrechte. Nutze Read-Only Keys, wo möglich.

5. Sequential Thinking MCP Server

Was macht er? Hilft der KI, strukturiert zu denken:

• Komplexe Probleme in Schritte zerlegen
• Hypothesen bilden und testen
• Alternative Lösungswege erkunden
• Reflexion über Zwischenergebnisse

Warum ist das nützlich?

Ohne Sequential Thinking:

Du: "Warum funktioniert der Login nicht?"
KI: "Vielleicht ist das Passwort falsch?"
Du: "Nein, Passwort stimmt."
KI: "Dann ist vielleicht die Session abgelaufen?"
[Raten geht weiter...]

Mit Sequential Thinking:

Du: "Warum funktioniert der Login nicht?"
KI: "Lass mich systematisch vorgehen:

     Schritt 1: Prüfe ob User existiert
     → Ergebnis: User existiert

     Schritt 2: Validiere Passwort-Hash
     → Ergebnis: Hash stimmt überein

     Schritt 3: Checke Session-Cookie
     → Ergebnis: Cookie fehlt

     Problem gefunden: Session-Cookie wird nicht gesetzt.
     Ursache: SameSite-Attribut fehlt in cookie.ts:23"

Installation:

# Sequential Thinking MCP Server
npm install -g @modelcontextprotocol/server-sequential-thinking

claude mcp add --transport http thinking https://mcp.thinking.dev

MCP in Claude hinzufügen: Die komplette Anleitung

Claude hat die beste MCP-Integration. Schauen wir uns alle Möglichkeiten an.

Methode 1: Via CLI (einfachste Variante)

Schritt 1: Stelle sicher, dass du Claude CLI installiert hast:

# Prüfen, ob claude CLI verfügbar ist
claude --version

# Falls nicht installiert:
npm install -g @anthropic-ai/claude-cli

Schritt 2: MCP Server hinzufügen:

# Basis-Syntax
claude mcp add --transport http <name> <url>

# Beispiel: GitHub
claude mcp add --transport http github https://mcp.github.com

# Mit Authentifizierung
claude mcp add --transport http sentry https://mcp.sentry.io \
  --header "Authorization: Bearer YOUR_TOKEN"

Schritt 3: Prüfen, ob es funktioniert:

# Liste aller konfigurierten MCP Server
claude mcp list

# Output sollte sein:
# github (http://mcp.github.com) - active
# sentry (http://mcp.sentry.io) - active

Schritt 4: Teste in Claude:

Öffne Claude (Desktop oder Web) und frage:

Du: "Welche GitHub Repositories habe ich?"

Wenn MCP funktioniert, antwortet Claude direkt mit deinen Repos. Wenn nicht, sagt er: “Ich habe keinen Zugriff auf GitHub.”

Methode 2: Via JSON-Konfiguration (für Power-User)

Wenn du mehrere MCP Server gleichzeitig konfigurieren willst, ist JSON einfacher.

Schritt 1: Erstelle ~/.config/claude/mcp.json:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "sentry": {
      "transport": "http",
      "url": "https://mcp.sentry.io",
      "headers": {
        "Authorization": "Bearer ${SENTRY_TOKEN}"
      }
    },
    "puppeteer": {
      "transport": "http",
      "url": "http://localhost:3001"
    }
  }
}

Schritt 2: Setze Environment-Variablen:

# In ~/.bashrc oder ~/.zshrc
export GITHUB_TOKEN="ghp_your_token_here"
export SENTRY_TOKEN="your_sentry_token"

Schritt 3: Lade die Konfiguration:

# Claude neu starten oder Config explizit laden
claude mcp reload

Vorteil: Alle Server auf einmal konfiguriert, Tokens zentral verwaltet, versionierbar (ohne Tokens im Code).

Methode 3: Projekt-spezifische MCP Server

Du willst, dass MCP Server nur für ein bestimmtes Projekt gelten? Nutze Project Scope.

Schritt 1: Im Projekt-Ordner:

cd ~/projects/my-app

# Füge MCP Server mit --scope project hinzu
claude mcp add --scope project --transport http github https://mcp.github.com

Schritt 2: Claude erstellt .mcp.json im Projekt:

{
  "mcpServers": {
    "github": {
      "transport": "http",
      "url": "https://mcp.github.com",
      "scopes": ["repo:read", "issues:write"]
    }
  }
}

Schritt 3: Committe die Datei:

git add .mcp.json
git commit -m "Add MCP configuration for team"

Vorteil: Das ganze Team nutzt dieselben MCP Server, keine individuelle Konfiguration nötig.

MCP in Zed Editor einbinden

Zed ist ein moderner Code-Editor, der Claude als KI-Assistenten einbinden kann. Aber: Zed verbindet sich nicht direkt mit MCP Servern – das läuft über Claude.

So funktioniert’s:

Zed Editor  →  Claude API  →  MCP Server

Schritt-für-Schritt:

1. Claude API-Key in Zed einrichten

Öffne Zed Settings (Cmd+, auf Mac, Ctrl+, auf Windows):

{
  "assistant": {
    "version": "2",
    "provider": {
      "name": "anthropic",
      "api_key": "YOUR_CLAUDE_API_KEY"
    }
  }
}

Claude API-Key bekommst du hier: https://console.anthropic.com/settings/keys

2. MCP Server in Claude konfigurieren

Nutze die Methoden von oben (CLI oder JSON), um MCP Server in Claude hinzuzufügen.

# Beispiel: GitHub MCP
claude mcp add --scope user --transport http github https://mcp.github.com

3. In Zed nutzen

Öffne den Zed Assistant (Cmd+Shift+A):

Du: "Welche offenen Issues gibt es in meinem Projekt?"
Claude (via Zed): [Greift auf GitHub MCP zu]
Claude: "Es gibt 12 offene Issues..."

Wichtig: Die MCP Server laufen über deinen Claude-Account, nicht über Zed direkt. Zed ist nur das Frontend.

Alternative: Lokale MCP Server für Zed

Wenn du nicht über Claude gehen willst, kannst du MCP Server auch lokal für Zed einrichten:

Schritt 1: Starte MCP Server lokal:

# Beispiel: Puppeteer
puppeteer-mcp-server --port 3001

Schritt 2: In Zed Settings:

{
  "assistant": {
    "version": "2",
    "mcp_servers": [
      {
        "name": "puppeteer",
        "url": "http://localhost:3001"
      }
    ]
  }
}

Vorteil: Keine Claude API-Kosten, volle Kontrolle. Nachteil: Du musst Server manuell starten und verwalten.

MCP in VS Code mit Continue.dev einbinden

VS Code hat keine native MCP-Integration, aber Continue.dev (eine beliebte KI-Extension) unterstützt MCP.

Schritt 1: Installiere Continue.dev

1. Öffne VS Code Extensions (Cmd+Shift+X)
2. Suche “Continue”
3. Installiere “Continue - AI Code Assistant”

Schritt 2: Konfiguriere MCP Server

Continue nutzt eine config.json:

# Öffne Continue Config
# In VS Code Command Palette (Cmd+Shift+P):
# "Continue: Open config.json"

Schritt 3: Füge MCP Server hinzu:

{
  "models": [
    {
      "title": "Claude with MCP",
      "provider": "anthropic",
      "model": "claude-3-5-sonnet-20241022",
      "apiKey": "YOUR_CLAUDE_API_KEY",
      "mcpServers": [
        {
          "name": "github",
          "transport": "http",
          "url": "https://mcp.github.com",
          "headers": {
            "Authorization": "Bearer ${GITHUB_TOKEN}"
          }
        }
      ]
    }
  ]
}

Schritt 4: Nutze Continue im Editor:

• Cmd+L: Öffne Continue Chat
• Frage: “Welche Issues sind in diesem Projekt offen?”
• Continue greift auf GitHub MCP zu

Lokal vs. Remote: Was passt zu mir?

Eine wichtige Entscheidung: Sollen MCP Server lokal auf deinem Rechner laufen oder remote gehostet sein?

Lokale MCP Server

Wie funktioniert’s?

# Du startest den Server auf deinem Rechner
puppeteer-mcp-server --port 3001

# Claude/Zed verbindet sich zu localhost
claude mcp add --transport http puppeteer http://localhost:3001

Vorteile: **Maximale Privacy - Daten verlassen nie deinen Rechner **Keine Kosten für Hosting **Schnell - keine Netzwerk-Latenz **Volle Kontrolle - du bestimmst, was läuft

Nachteile: **Server muss manuell gestartet werden **Nicht verfügbar, wenn Rechner aus ist **Jedes Teammitglied muss individuell einrichten

Wann nutzen?

• Sensible Daten (Kundendaten, interne Tools)
• Einzelperson oder kleines Team
• Entwicklung/Testing
• Privacy-first Ansatz

Beispiel-Setup (macOS/Linux):

# 1. Installiere MCP Server lokal
npm install -g @modelcontextprotocol/server-puppeteer
npm install -g @modelcontextprotocol/server-filesystem

# 2. Erstelle Startskript
cat > ~/start-mcp-servers.sh << 'EOF'
#!/bin/bash
puppeteer-mcp-server --port 3001 &
filesystem-mcp-server --port 3002 --root ~/projects &
echo "MCP Servers gestartet"
EOF

chmod +x ~/start-mcp-servers.sh

# 3. Automatisch beim Login starten (macOS)
# System Settings → Users → Login Items → Add ~/start-mcp-servers.sh

Remote MCP Server

Wie funktioniert’s?

# MCP Server läuft auf einem Server irgendwo im Internet
claude mcp add --transport http github https://mcp.github.com

Vorteile: **Immer verfügbar - auch wenn dein Rechner aus ist **Team-weit nutzbar - einmal einrichten, alle nutzen es **Verwaltetes Caching - zentrale Performance-Optimierung **Kein manueller Start nötig

Nachteile: **Privacy - Daten gehen über externen Server **Kosten für Hosting (je nach Anbieter) **Netzwerk-Latenz (minimal, aber messbar) **Abhängigkeit von externer Infrastruktur

Wann nutzen?

• Öffentliche Daten (GitHub, Sentry)
• Große Teams
• Production-Einsatz
• Managed Services bevorzugt

Beispiel-Setup:

# Offizielle MCP Server von Anthropic
claude mcp add --transport http github https://mcp.github.com
claude mcp add --transport http gitlab https://mcp.gitlab.com

# Managed MCP Services (Beispiele)
claude mcp add --transport http supabase https://mcp.supabase.co
claude mcp add --transport http slack https://mcp.slack.com

Hybrid-Ansatz (Best of Both)

Die meisten Teams nutzen eine Kombination:

Lokal:

• Filesystem-Zugriff
• Lokale Datenbanken
• Browser-Automatisierung (Puppeteer)
• Interne Tools

Remote:

• GitHub/GitLab
• Sentry/Error-Tracking
• Public APIs
• Team-weite Services

Beispiel-Konfiguration:

{
  "mcpServers": {
    "github": {
      "transport": "http",
      "url": "https://mcp.github.com",
      "comment": "Remote - Team-weit"
    },
    "sentry": {
      "transport": "http",
      "url": "https://mcp.sentry.io",
      "comment": "Remote - Zentral"
    },
    "puppeteer": {
      "transport": "http",
      "url": "http://localhost:3001",
      "comment": "Lokal - Privacy"
    },
    "filesystem": {
      "command": "filesystem-mcp-server",
      "args": ["--root", "${HOME}/projects"],
      "comment": "Lokal - Sicherheit"
    }
  }
}

Sicherheit: Die wichtigsten Regeln

MCP Server haben Zugriff auf deine Daten. Deshalb ist Sicherheit kritisch.

Regel 1: Nutze HTTPS (nie HTTP)

# **UNSICHER - Daten unverschlüsselt
claude mcp add --transport http api http://api.example.com

# **SICHER - Daten verschlüsselt
claude mcp add --transport http api https://api.example.com

Ausnahme: localhost (läuft auf deinem Rechner, kein Netzwerk).

Regel 2: Minimale Zugriffsrechte (Least Privilege)

Gib MCP Servern nur die Rechte, die sie wirklich brauchen.

GitHub-Beispiel:

# **ZU VIEL - Admin-Rechte
# Scopes: admin:org, delete:repo, admin:public_key

# **MINIMAL - Nur Lesen
# Scopes: repo:read, issues:read

claude mcp add --transport http github https://mcp.github.com \
  --scopes "repo:read,issues:read"

Firebase-Beispiel:

Statt Full-Access Service Account → Read-Only Account:

{
  "type": "service_account",
  "project_id": "my-project",
  "client_email": "[email protected]",
  "private_key": "...",
  "role": "roles/datastore.viewer"  // ← Nur Lesen!
}

Regel 3: Keine Tokens im Code

# **SCHLECHT - Token hardcoded
claude mcp add --transport http api https://api.example.com \
  --header "Authorization: Bearer sk_live_abc123xyz"

# **GUT - Token aus Environment
export API_TOKEN="sk_live_abc123xyz"
claude mcp add --transport http api https://api.example.com \
  --header "Authorization: Bearer ${API_TOKEN}"

Warum? Wenn du die Config versionierst (git), landen Tokens im Repository.

Regel 4: Regelmäßig Zugriffe prüfen

# Liste alle aktiven MCP Server
claude mcp list

# Output:
# github (https://mcp.github.com) - last used: 2 min ago
# sentry (https://mcp.sentry.io) - last used: 3 days ago
# old-api (https://old-api.com) - last used: never

# Entferne ungenutzte Server
claude mcp remove old-api

Best Practice: Monatliches Audit - welche Server werden wirklich genutzt?

Regel 5: Trenne User- und Projekt-Scopes

# Persönliche Server (nur für dich)
claude mcp add --scope user puppeteer http://localhost:3001

# Team-Server (für alle im Projekt)
claude mcp add --scope project github https://mcp.github.com

Vorteil: Persönliche Experimente kontaminieren nicht die Team-Konfiguration.

Troubleshooting: Wenn MCP nicht funktioniert

Problem 1: “MCP Server not found”

Symptom: Claude sagt “I don’t have access to GitHub”

Ursache: MCP Server nicht korrekt hinzugefügt oder nicht gestartet.

Lösung:

# Prüfe Status
claude mcp list

# Wenn leer oder "inactive":
claude mcp add --transport http github https://mcp.github.com

# Teste explizit
claude mcp test github

Problem 2: “Authentication failed”

Symptom: “Error: 401 Unauthorized”

Ursache: Token abgelaufen oder falsch.

Lösung:

# Entferne Server
claude mcp remove github

# Füge neu hinzu mit frischem Token
export GITHUB_TOKEN="ghp_new_token"
claude mcp add --transport http github https://mcp.github.com

Problem 3: “Connection refused”

Symptom: “Error: ECONNREFUSED”

Ursache: Lokaler MCP Server läuft nicht.

Lösung:

# Prüfe ob Server läuft
lsof -i :3001

# Wenn nicht → Starte ihn
puppeteer-mcp-server --port 3001

# Dann teste
curl http://localhost:3001/health
# Expected: {"status": "ok"}

Problem 4: “Timeout”

Symptom: Anfrage hängt, dann Timeout

Ursache: Remote MCP Server überlastet oder down.

Lösung:

# Prüfe Server-Status
curl https://mcp.github.com/health

# Wenn down → Nutze Fallback
claude mcp add --transport http github-backup https://backup.mcp.github.com

Problem 5: “Permission denied”

Symptom: “403 Forbidden”

Ursache: Token hat nicht die nötigen Scopes.

Lösung:

# GitHub: Gehe zu https://github.com/settings/tokens
# Editiere Token, füge fehlende Scopes hinzu

# Dann neu laden
claude mcp reload

Zusammenfassung: Die 5 wichtigsten Erkenntnisse

1. MCP Server sind Brücken Sie verbinden deine KI sicher und strukturiert mit deinen Daten – ohne dass du ständig copy-paste machen musst.

2. Einmal einrichten, überall nutzen Ein MCP Server funktioniert mit Claude, Cursor, Zed, VS Code + Continue – dank standardisiertem Protokoll.

3. Die 5 Must-Have Server GitHub (Code), Sentry (Errors), Puppeteer (Browser), Firebase (Daten), Sequential Thinking (Strukturiertes Denken)

4. Lokal für Privacy, Remote für Teams Sensible Daten lokal behalten, öffentliche Dienste remote nutzen – Hybrid ist Best Practice.

5. Sicherheit durch Design HTTPS, minimale Scopes, keine Tokens im Code, regelmäßige Audits – dann ist MCP sicher.

Nächste Schritte

Jetzt ausprobieren:

# Installiere GitHub MCP (5 Minuten)
npm install -g @modelcontextprotocol/server-github
claude mcp add --transport http github https://mcp.github.com

# Teste in Claude
"Welche GitHub Repositories habe ich?"

Viel Erfolg!

---

Quellen

Footnotes

1. Anthropic: Introducing the Model Context Protocol ↩

2. TechCrunch: OpenAI adopts rival Anthropic’s standard for connecting AI models to data ↩

3. Microsoft: Partners with Anthropic to create official C# SDK for Model Context Protocol ↩

4. Anthropic MCP Adoption Overview ↩