# MCP-Server

MCP (Model Context Protocol) ist ein offener Standard von Anthropic, mit dem Claude Code eine Verbindung zu externen Tools, Datenbanken, APIs und Diensten herstellen kann. Mit MCP lassen sich die Fähigkeiten von Claude Code erheblich erweitern.

## Was ist MCP?

### Kernkonzepte

MCP ist ein **offenes Protokoll**, das Kommunikationsstandards zwischen KI-Assistenten und externen Systemen definiert. Es besteht aus drei Kernkomponenten:

| Komponente | Beschreibung | Beispiele |
|-----------|-------------|----------|
| **Tools** | Ausführbare Aktionen | Datenbanken abfragen, Anfragen senden, Dateien manipulieren |
| **Resources** | Lesbare Daten | Dateiinhalte, API-Antworten, Datensätze |
| **Prompts** | Vordefinierte Aufgabenvorlagen | Vorlagen für Code-Reviews, Vorlagen für die Berichterstellung |

### Warum MCP?

- **Erweiterte Fähigkeiten**: Lassen Sie Claude auf Systeme zugreifen, die anderweitig nicht erreichbar wären

- **Echtzeitdaten**: Holen Sie sich aktuelle Dokumentation, Datenbankinhalte und API-Daten

- **Automatisierung**: Führen Sie Deployments aus, senden Sie Benachrichtigungen, verwalten Sie Ressourcen

- **Datenschutz**: Daten werden lokal verarbeitet, kein Upload in die Cloud erforderlich

## Schnellstart

### MCP-Status prüfen

```
> /mcp
```

Zeigt den Status der aktuell konfigurierten MCP-Server an.

### MCP-Server hinzufügen

Verwenden Sie den Befehl `claude mcp add`:

```bash
# Add filesystem server
claude mcp add filesystem npx -y @modelcontextprotocol/server-filesystem /path/to/directory

# Add SQLite database server
claude mcp add sqlite npx -y mcp-server-sqlite ./database.db

# Add custom server
claude mcp add my-server node /path/to/server.js
```

### Konfigurationsdatei

Sie können alternativ auch eine `.mcp.json`-Datei im Projektstammverzeichnis erstellen:

```json
{
  "filesystem": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"]
  },
  "database": {
    "command": "npx",
    "args": ["-y", "mcp-server-sqlite", "./data.db"]
  }
}
```

## Beliebte MCP-Server

### Dateisystem

Zugriff auf das lokale Dateisystem:

```json
{
  "filesystem": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
  }
}
```

**Funktionen**: Dateien im angegebenen Verzeichnis lesen, schreiben und durchsuchen.

### SQLite-Datenbank

Verbindung mit einer SQLite-Datenbank:

```json
{
  "sqlite": {
    "command": "npx",
    "args": ["-y", "mcp-server-sqlite", "./database.db"]
  }
}
```

**Funktionen**: SQL-Abfragen ausführen, Datenbankschema verwalten.

### GitHub

Verbindung mit GitHub-Repositorys:

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

**Funktionen**: Issues, PRs und Repository-Operationen verwalten.

### Context7 (Dokumentabruf)

Aktuelle Bibliotheksdokumentation abrufen:

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

**Funktionen**: Aktuelle Dokumentation und Code-Beispiele für jede Bibliothek abrufen.

### Supabase

Verbindung mit Supabase-Backend:

```json
{
  "supabase": {
    "command": "npx",
    "args": ["-y", "@supabase/mcp-server"],
    "env": {
      "SUPABASE_URL": "${SUPABASE_URL}",
      "SUPABASE_KEY": "${SUPABASE_KEY}"
    }
  }
}
```

**Funktionen**: Datenbankoperationen, Authentifizierung, Speicherverwaltung.

### Docker

Container-Verwaltung:

```json
{
  "docker": {
    "command": "npx",
    "args": ["-y", "@docker/mcp-server"]
  }
}
```

**Funktionen**: Container, Images und Netzwerke verwalten.

## Server-Typen

### stdio (Lokaler Prozess)

Der häufigste Typ, läuft als lokaler Unterprozess:

```json
{
  "my-server": {
    "command": "node",
    "args": ["./server.js"],
    "env": {
      "API_KEY": "${API_KEY}"
    }
  }
}
```

**Eigenschaften**:

- Läuft lokal, Daten verbleiben auf Ihrem Rechner

- Claude Code verwaltet den Prozesslebenszyklus

- Ideal für Dateisystem, lokale Datenbanken

### SSE (Server-Sent Events)

> **⚠️ Ab der MCP-Spezifikation 2025-11-25 ist SSE veraltet.** Neue Verbindungen sollten **Streamable HTTP** verwenden (siehe Abschnitt HTTP unten). SSE wird nur noch zur Abwärtskompatibilität mit bestehenden Servern beibehalten.


Verbindung mit remote gehosteten MCP-Servern:

```json
{
  "remote-server": {
    "type": "sse",
    "url": "https://mcp.example.com/sse"
  }
}
```

**Eigenschaften**:

- Geeignet für Cloud-Dienste

- Unterstützt OAuth-Authentifizierung

- Keine lokale Installation erforderlich

### HTTP

RESTful-API-Ansatz:

```json
{
  "api-server": {
    "type": "http",
    "url": "https://api.example.com/mcp",
    "headers": {
      "Authorization": "Bearer ${API_TOKEN}"
    }
  }
}
```

## Umgebungsvariablen

Die MCP-Konfiguration unterstützt Ersetzung durch Umgebungsvariablen:

```json
{
  "my-server": {
    "command": "node",
    "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],
    "env": {
      "DATABASE_URL": "${DATABASE_URL}",
      "API_KEY": "${API_KEY}",
      "DEFAULT_NAMESPACE": "${K8S_NAMESPACE:-default}"
    }
  }
}
```

**Syntax**:

- `${VAR}` – Ersetzung durch den Wert der Umgebungsvariable

- `${VAR:-default}` – Standardwert verwenden, wenn die Variable nicht gesetzt ist

## Praxisbeispiele

### Beispiel 1: Datenbankabfrage-Assistent

```json
{
  "postgres": {
    "command": "npx",
    "args": ["-y", "mcp-server-postgres"],
    "env": {
      "DATABASE_URL": "postgresql://user:pass@localhost/mydb"
    }
  }
}
```

Verwendung:

```
> Query total order amount for the last 7 days
> Find the top 10 users with the most purchases
```

### Beispiel 2: Kubernetes-Operationen

```json
{
  "kubernetes": {
    "command": "node",
    "args": ["./k8s-mcp-server.js"],
    "env": {
      "KUBECONFIG": "${KUBECONFIG}",
      "K8S_NAMESPACE": "${K8S_NAMESPACE:-default}"
    }
  }
}
```

Verwendung:

```
> List the status of all Pods
> Restart the api-server deployment
> Show recent error logs
```

### Beispiel 3: Multi-Server-Konfiguration

```json
{
  "filesystem": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "./src"]
  },
  "database": {
    "command": "npx",
    "args": ["-y", "mcp-server-sqlite", "./data.db"]
  },
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_TOKEN": "${GITHUB_TOKEN}"
    }
  }
}
```

## Fehlerbehebung

### Server startet nicht

1. Prüfen Sie, ob der Befehl ordnungsgemäß installiert ist:
   ```bash
   npx -y @modelcontextprotocol/server-filesystem --help
   ```

2. Prüfen Sie, ob die Umgebungsvariablen gesetzt sind:
   ```bash
   echo $GITHUB_TOKEN
   ```

3. Prüfen Sie die Claude Code-Logs auf Fehlermeldungen

### Tools nicht verfügbar

1. Verwenden Sie `/mcp`, um den Serverstatus zu prüfen

2. Überprüfen Sie das Konfigurationsdateiformat (JSON-Syntax)

3. Starten Sie Claude Code neu, um die Konfiguration erneut zu laden

### Berechtigungsprobleme

- Stellen Sie sicher, dass Dateipfade Lese-/Schreibberechtigungen haben

- Die Datenbankverbindungszeichenfolge ist korrekt

- Das API-Token ist gültig und verfügt über ausreichende Berechtigungen

## Sicherheitsempfehlungen

1. **Minimalprinzip**: Erteilen Sie nur die notwendigen Zugriffe

2. **Sensible Informationen schützen**: Verwenden Sie Umgebungsvariablen für Tokens und Passwörter

3. **Pfadzugriff einschränken**: Geben Sie für Dateisystem-Server nur notwendige Verzeichnisse frei

4. **Keys regelmäßig rotieren**: Aktualisieren Sie API-Tokens in regelmäßigen Abständen

## Sicherheitshinweise

Ein MCP-Server wird mit Ihrer Identität ausgeführt – er kann Daten lesen, Tools aufrufen und auf Zugangsdaten zugreifen. Das Hinzufügen eines MCP-Servers eines Drittanbieters bedeutet im Wesentlichen, externen Code in Ihre Entwicklungsumgebung einzubinden, gehen Sie daher sorgfältig damit um.

**Hauptrisiken**

- **Datenexfiltration**: Ein bösartiger oder kompromittierter Server kann Ihren Code, Ihre Dateien oder den Gesprächsinhalt an ein externes Ziel senden.

- **Tool-Poisoning**: Ein Server bettet versteckte Anweisungen in seine Tool-Beschreibungen ein und bringt Claude dazu, Handlungen auszuführen, die Sie nie autorisiert haben.

- **Offenlegung von Zugangsdaten**: Ein falsch konfigurierter Server kann Umgebungsvariablen, Secrets oder Tokens lesen.

- **Übermäßige Rechte**: Das Erteilen von Tool-Funktionalitäten über das tatsächlich benötigte Maß hinaus vergrößert die Angriffsfläche.

**Wichtige Gegenmaßnahmen**

- **Nur vertrauenswürdige Server installieren**: Bevorzugen Sie offizielle, geprüfte oder quelloffene MCP-Server; vermeiden Sie Implementierungen unbekannter Herkunft.

- **Minimalprinzip**: Prüfen Sie die deklarierten Tool-Scopes jedes Servers einzeln und geben Sie nur die Fähigkeiten und Verzeichnisse frei, die Sie wirklich benötigen.

- **Menschliche Genehmigungsfenster beibehalten**: Claude Code fragt vor jeder Tool-Ausführung nach – genehmigen Sie destruktive, schreibende oder zugangsdatenberührende Operationen nicht blind oder vollständig automatisch.

- **Zugangsdaten isolieren**: Wenn Sie Befehle in einer Sandbox ausführen, verwenden Sie `sandbox.credentials`, um zu verhindern, dass Sandbox-Prozesse Secrets und Umgebungsvariablen lesen.

- **Aufrufe protokollieren**: Erfassen und überprüfen Sie Tool-Aufrufaktivitäten regelmäßig, um anomales Verhalten frühzeitig zu erkennen.

Das vollständige Bedrohungsmodell, Sandbox- und Zugangsdaten-Isolationskonfiguration finden Sie unter [Bewährte Sicherheitspraktiken](/docs/advanced/security).

## Nächste Schritte

- Erfahren Sie mehr über das [Plugin-System](/docs/advanced/plugins), um eigene Funktionalitäten zu erstellen

- Prüfen Sie [CLI-Tipps](/docs/usage/cli-tips), um Ihre Effizienz zu steigern

- Entdecken Sie [Workflow-Tipps](/docs/usage/workflow-tips), um Ihren Entwicklungsablauf zu optimieren