# Claude Code MCP einrichten: Server hinzufügen, verwalten

URL: https://agentvera.dev/de/blog/claude-code-mcp-setup/ · Veröffentlicht: 2026-10-28

MCP-Server in Claude Code einrichten: claude mcp add für stdio und HTTP, Scopes, .mcp.json, /mcp und OAuth, Import aus Claude Desktop, Timeouts und Output-Limits.

**Kurz gesagt:**

- Einen Server fügst du mit claude mcp add hinzu: Optionen stehen vor dem Namen, der Befehl eines lokalen stdio-Servers nach --. Remote-Server nutzen --transport http mit einer URL.
- Der Scope bestimmt den Speicherort: local (Standard) und user in ~/.claude.json, project in einer .mcp.json im Repo-Root, die du committen kannst.
- Mit /mcp prüfst du in einer Session den Status, meldest dich bei OAuth-Servern an und schaltest Server ab. MCP_TIMEOUT und MAX_MCP_OUTPUT_TOKENS lösen die meisten Start- und Output-Probleme.
- Claude Code fragt, bevor es die .mcp.json-Server eines Projekts nutzt. Prüfe sie wie jeden Code aus dem Repo und halte Tokens in ${VAR}-Referenzen statt in der Datei.

Um MCP in Claude Code einzurichten, führst du `claude mcp add` im Terminal aus. Ein lokaler Server ist `claude mcp add <name> -- <befehl>`, ein Remote-Server `claude mcp add --transport http <name> <url>`, und `--scope` legt fest, ob der Server nur für dich in diesem Projekt gilt (`local`, Standard), über eine `.mcp.json` für das ganze Team (`project`) oder für dich in jedem Projekt (`user`). Danach tippst du in einer Session `/mcp`, um die Verbindung zu prüfen und dich bei OAuth-Servern anzumelden.

Dieser Leitfaden geht jeden Schritt durch: Transports, den Trenner `--`, Umgebungsvariablen und Header, Scopes, `.mcp.json` von Hand schreiben, die Befehle `list`, `get` und `remove`, OAuth, den Import aus Claude Desktop, Timeouts und Output-Limits und was du prüfen solltest, bevor du den Servern eines Projekts vertraust. Die Befehle stammen aus Anthropics [MCP-Dokumentation für Claude Code](https://code.claude.com/docs/en/mcp "Claude Code MCP-Dokumentation"), Stand Oktober 2026. Ist MCP neu für dich, lies zuerst [was ein MCP-Server ist](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server"); welche Server sich lohnen, steht in [die besten MCP-Server fürs Programmieren](/de/blog/best-mcp-servers-for-coding/ "Die besten MCP-Server fürs Programmieren").

## Kurzreferenz

| Aufgabe | Befehl |
| --- | --- |
| Lokalen (stdio-)Server hinzufügen | `claude mcp add <name> -- <befehl> [argumente...]` |
| Remote-(HTTP-)Server hinzufügen | `claude mcp add --transport http <name> <url>` |
| Aus einem JSON-Snippet hinzufügen | `claude mcp add-json <name> '<json>'` |
| Mit dem Team teilen | `--scope project` ergänzen (schreibt `.mcp.json`) |
| In allen Projekten nutzen | `--scope user` ergänzen |
| Server und ihren Zustand auflisten | `claude mcp list` |
| Details zu einem Server | `claude mcp get <name>` |
| Server entfernen | `claude mcp remove <name>` |
| Bei einem OAuth-Server anmelden | `/mcp` in einer Session oder `claude mcp login <name>` |
| Aus Claude Desktop importieren | `claude mcp add-from-claude-desktop` |
| Status, Anmeldung, Abschalten, Neuverbinden | `/mcp` in Claude Code |

Kurze Flags gehen auch: `-t` für `--transport`, `-s` für `--scope`, `-e` für `--env` und `-H` für `--header`.

## Transport wählen: stdio, HTTP oder SSE

Ein [MCP](/de/glossary/mcp/ "MCP")-Server erreicht Claude Code auf einem von drei Wegen:

| Transport | Was es ist | Wann |
| --- | --- | --- |
| `stdio` | Ein lokaler Prozess, den Claude Code startet und über stdin und stdout anspricht | Server, die du mit `npx`, `uvx`, Docker oder einem eigenen Skript startest |
| `http` | Ein Remote-Server über Streamable HTTP | Gehostete Dienste: Notion, Sentry, GitHub, Stripe und andere. Anthropic empfiehlt es für Remote-Server |
| `sse` | Server-Sent Events | Nur ältere Remote-Server. Die Doku markiert SSE als veraltet |

`--transport sse` brauchst du kaum noch. Seit Claude Code 2.1.265 versucht `claude mcp add --transport http` zuerst HTTP und wechselt von selbst zu SSE, wenn der Server kein HTTP annimmt. In älteren Versionen gibst du `--transport sse` ausdrücklich an.

## Lokalen stdio-Server hinzufügen

Die Regel, über die die meisten stolpern: Die Optionen von Claude Code (`--transport`, `--scope`, `--env`) stehen **vor** dem Servernamen, und alles nach `--` ist der Befehl des Servers und wird unverändert durchgereicht.

```bash
# Grundform
claude mcp add [optionen] <name> -- <befehl> [argumente...]

# Playwright, gestartet mit npx
claude mcp add playwright -- npx -y @playwright/mcp@latest

# Ein Server, der einen API-Key in seiner Umgebung braucht
claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \
  -- npx -y airtable-mcp-server
```

Ohne `--` würde ein Server-Flag wie `--port 8080` als Option von Claude Code gelesen, und der Befehl schlägt fehl. Noch ein Haken aus der Doku: `--env` nimmt mehrere `KEY=value`-Paare an. Folgt der Servername direkt danach, wird er als weiteres Paar gelesen und abgelehnt. Setz eine andere Option wie `--transport stdio` dazwischen, wie im Beispiel oben.

Claude Code setzt `CLAUDE_PROJECT_DIR` in der Umgebung jedes stdio-Servers, damit ein Server das Projekt-Root findet, ohne vom Arbeitsverzeichnis abzuhängen.

## Remote-HTTP-Server hinzufügen

Remote-Server bekommen statt eines Befehls eine URL. Header ergänzt du mit `--header`, wenn der Server einen API-Key oder ein Bearer-Token verlangt:

```bash
# Ein gehosteter Server mit OAuth-Anmeldung
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Ein Server mit statischem Token
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"
```

Ein Header, den du hier eintippst, landet im Klartext in der Konfigurationsdatei. Für alles Geteilte sind OAuth oder eine `${VAR}`-Referenz in der `.mcp.json` die bessere Wahl, mehr dazu unten.

Hast du schon eine JSON-Definition aus der README eines Servers, spar dir die Flags und füge sie mit `add-json` ein. Der Befehl nimmt das Objekt, das in `mcpServers` stehen würde, nicht die ganze Datei:

```bash
claude mcp add-json example '{"command":"npx","args":["-y","@example/mcp-server"]}'
```

## Scope wählen

Jedes `claude mcp add` schreibt in einen von drei Scopes:

| Scope | Flag | Gespeichert in | Wer ihn bekommt |
| --- | --- | --- | --- |
| Local (Standard) | `--scope local` | `~/.claude.json`, unter dem Pfad dieses Projekts | Nur du, nur in diesem Projekt |
| Project | `--scope project` | `.mcp.json` im Projekt-Root | Alle, die das Repo klonen |
| User | `--scope user` | `~/.claude.json` | Nur du, in jedem Projekt |

```bash
claude mcp add --transport http stripe https://mcp.stripe.com                      # local
claude mcp add --transport http shared-server --scope project https://example.com/mcp
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic
```

Faustregel: Persönliche Tools und alles mit deinen eigenen Zugangsdaten gehört in `user` oder `local`; Server, die das ganze Team für die Arbeit am Repo braucht, gehören in `project`.

„Local“ meint hier übrigens nicht `.claude/settings.local.json`. Lokale MCP-Server liegen in `~/.claude.json` in deinem Home-Verzeichnis.

Ist derselbe Name an mehreren Stellen definiert, nimmt Claude Code den obersten Eintrag und führt keine Felder zusammen: zuerst local, dann project, dann user, dann Plugin-Server, dann claude.ai-Connectors. Zeigen zwei Scopes mit demselben Namen auf unterschiedliche Endpunkte, warnen `claude mcp list` und `/mcp` dich.

## .mcp.json von Hand schreiben

Ein Server mit Scope project ist einfach eine `.mcp.json`, die du bearbeiten und in Pull Requests reviewen kannst:

```json
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest"]
    },
    "api-server": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": {
        "Authorization": "Bearer ${API_KEY}"
      }
    }
  }
}
```

`${VAR}` wird zu einer Umgebungsvariable aufgelöst, `${VAR:-default}` fällt auf einen Standardwert zurück. Das funktioniert in `command`, `args`, `env`, `url` und `headers`, und so committest du die Datei, ohne Tokens zu committen: Jede Entwicklerin und jeder Entwickler setzt `API_KEY` in der eigenen Shell. Fehlt eine Variable ohne Standardwert, warnen `claude mcp list` und `/mcp` und lassen den Text unaufgelöst.

Ein `"timeout"` pro Server in Millisekunden setzt ein festes Limit für die Tool-Aufrufe dieses Servers.

## Server verwalten: list, get, remove und /mcp

In der Shell:

```bash
claude mcp list          # alle Server mit Verbindungsstatus
claude mcp get notion    # Details zu einem Server, auch warum er fehlschlug
claude mcp remove notion # aus seinem Scope löschen
```

`list` und `get` zeigen die Fehlerdetails mit geschwärzten Zugangsdaten. Ein Projekt-Server, den du noch nicht freigegeben hast, steht als ausstehend da, bis du `claude` interaktiv startest und zustimmst.

In einer Session ist `/mcp` die Schaltzentrale. Es zeigt Status und Anzahl der Tools jedes Servers, und im Menü eines Servers kannst du dich anmelden, neu anmelden, die Anmeldung löschen, neu verbinden oder den Server abschalten, ohne seine Konfiguration zu löschen. `/mcp reconnect all` versucht alle fehlgeschlagenen Server auf einmal neu (ab Claude Code 2.1.284).

Verbundene Server bringen mehr als Tools mit. Mit `@` verweist du neben deinen Dateien auf Ressourcen eines Servers, und mit `/` siehst du seine Prompts als `/servername:promptname (MCP)`. Die Tools selbst heißen `mcp__<server>__<tool>`; diesen Namen verwendest du in Berechtigungsregeln und in [Hook-Matchern](/de/blog/claude-code-hooks-guide/ "Claude Code Hooks Leitfaden").

## Bei OAuth-Servern anmelden

Viele gehostete Server wie Sentry, Notion oder Linear nutzen OAuth statt eines statischen Tokens. Füge den Server mit `--transport http` und ohne Header hinzu und melde dich dann an:

```bash
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```

Führe in Claude Code `/mcp` aus, wähle den Server und dann **Authenticate**. Dein Browser öffnet sich, du meldest dich an, und Claude Code speichert das Token und erneuert es. Das geht auch aus der Shell, ohne eine Session zu öffnen:

```bash
claude mcp login sentry               # öffnet den Browser
claude mcp login sentry --no-browser  # gibt die URL aus, für SSH-Sessions
claude mcp logout sentry              # gespeicherte Zugangsdaten vergessen
```

Headless-Läufe (`claude -p`) können keine Anmeldung anzeigen, also melde dich vorher einmal interaktiv an. Manche Server brauchen einen festen Callback-Port oder eine vorab registrierte OAuth-App; dafür gibst du beim Hinzufügen `--callback-port`, `--client-id` und `--client-secret` an. Das Secret wird maskiert abgefragt oder in CI aus `MCP_CLIENT_SECRET` gelesen.

## Server aus Claude Desktop importieren

Hast du Server schon in der Claude-Desktop-App eingerichtet, musst du sie nicht neu eintippen:

```bash
claude mcp add-from-claude-desktop
```

Ein Dialog lässt dich die zu importierenden Server auswählen. Stand Oktober 2026 funktioniert das nur unter macOS und in WSL. Mit `--scope user` importierst du in deine User-Konfiguration. Servernamen dürfen nur Buchstaben, Ziffern, Bindestriche und Unterstriche enthalten; ein Desktop-Server mit Leerzeichen im Namen wird übersprungen und gemeldet, und ein bereits vorhandener Name bekommt ein Suffix wie `server_1`.

## Fehlerbehebung

| Symptom | Was hilft |
| --- | --- |
| Server verbindet sich nicht | `claude mcp get <name>` für den Fehler, dann **Reconnect** in `/mcp` |
| Langsamer Server läuft beim Start in einen Timeout | Mit `MCP_TIMEOUT=10000 claude` starten (zehn Sekunden) |
| Lange Tool-Aufrufe brechen ab | `MCP_TOOL_TIMEOUT` für alle Server oder `"timeout"` pro Server in der `.mcp.json` |
| Output-Warnung oder abgeschnittene Ergebnisse | Claude Code warnt ab 10.000 Tokens und kappt standardmäßig bei 25.000. Mit `MAX_MCP_OUTPUT_TOKENS=50000` anheben |
| Flags des Servers werden ignoriert oder abgelehnt | Optionen von Claude Code vor den Namen, den Serverbefehl nach `--` |
| `${VAR}`-Warnung in `/mcp` | Variable in der Shell setzen, aus der du Claude Code startest, oder `:-default` ergänzen |
| Server wird beim Laden übersprungen | Der Name ist reserviert (`workspace`, `claude-in-chrome`, `computer-use` und ein paar weitere); umbenennen |
| Token funktioniert mit curl, hier nicht | Nach Leerzeichen oder Zeilenumbruch am Ende des eingefügten Tokens suchen; Claude Code warnt vor verstecktem Whitespace |

Für lange Textergebnisse gibt es ein zweites Limit: Ein Ergebnis über 50.000 Zeichen wird in einer Datei gespeichert, statt direkt in den Kontext zu gehen.

Remote-Server, die mitten in der Session wegbrechen, werden bis zu fünfmal mit wachsendem Abstand neu versucht. stdio-Server werden nicht automatisch neu gestartet; ein abgestürzter lokaler Server braucht ein Reconnect über `/mcp`.

Der Kontext ist die andere Kostenstelle. Claude Code nutzt auf aktuellen Modellen standardmäßig Tool Search: Beim Start werden nur Tool-Namen und Server-Anweisungen geladen, die vollständigen Tool-Definitionen erst, wenn Claude sie braucht. Das hält eine lange Serverliste günstig, aber jeder Server ist eine weitere Stelle, die ausfallen oder missbraucht werden kann, also halte die Liste kurz. Für Skripte lädt `--mcp-config <datei>` zusätzliche Server für einen Lauf, und `--strict-mcp-config` sorgt dafür, dass Claude Code nur diese nutzt.

## Sicherheit: Projekt-Server sind Code aus dem Repo

Eine `.mcp.json` im Repo kann jeden lokalen Befehl starten oder auf jede URL zeigen. Genau das macht sie für Teams nützlich, und genau deshalb geht Claude Code vorsichtig damit um:

- **Erst die Freigabe.** In einer interaktiven Session fragt Claude Code, bevor es Server mit Scope project nutzt. `claude mcp reset-project-choices` setzt deine bisherigen Antworten zurück.
- **Ein Repo kann sich nicht selbst freigeben.** Einstellungen wie `enableAllProjectMcpServers`, die in die `.claude/settings.json` des Projekts committet sind, werden ignoriert, bis du dem Ordner vertraust, und der Server bleibt ausstehend. Freigaben aus deinen eigenen User-Einstellungen gelten weiterhin.
- **Headless-Läufe fragen nicht.** In `claude -p` und Agent-SDK-Läufen gibt es keine Rückfrage, also laden Projekt-Server ohne. Um einen Server in jedem Modus zu sperren, trag ihn in `disabledMcpjsonServers` ein.
- **Zugangsdaten bleiben zu Hause.** In `url` und `headers` eines Remote-Servers werden sensible Variablen wie `ANTHROPIC_API_KEY` leer aufgelöst, selbst wenn sie gesetzt sind. So kann ein Projekt deinen Anthropic-Key nicht still an seinen Server schicken.
- **Trau dem, was ein Server zurückgibt, so wenig wie dem, was er ausführt.** Anthropics Doku warnt, dass Server, die fremde Inhalte abrufen, dich für [Prompt Injection](/de/glossary/prompt-injection/ "Prompt Injection") angreifbar machen können. Bevorzuge Read-only-Modi und eng begrenzte Tokens.

Lies vor der Freigabe `command`, `args` und `url` jedes Servers so, wie du ein `postinstall`-Skript lesen würdest. Das größere Bild findest du unter [Sicherheit von KI-Coding-Agenten](/de/blog/ai-coding-agent-security/ "Sicherheit von KI-Coding-Agenten").

## Wenn du mehr als Claude Code nutzt

Alles oben gilt pro CLI. Codex hält seine Server in `~/.codex/config.toml`, Gemini CLI in einer eigenen `settings.json`, und jedes Tool hat eigene Befehle. Ist Claude Code dein einziger Agent, reichen `claude mcp add` und eine committete `.mcp.json` völlig aus, und nichts hier verlangt ein weiteres Tool.

Nutzt du mehrere Coding-CLIs, laufen die Listen auseinander. Genau dafür ist der [MCP-Manager](/de/features/mcp-manager/ "MCP-Manager") in AgentVera gedacht, der Desktop-App, die diesen Blog herausgibt:

- **Einmal hinzugefügt, beim Start verbunden.** Du registrierst stdio-, HTTP- und SSE-Server in AgentVera, und sie verbinden sich beim Start der Agenten: mit allen Agenten, mit ausgewählten, mit den Agenten einer Gruppe oder mit einer Team-Rolle. Claude Code, Codex und die anderen CLI-Agenten mit MCP-Unterstützung bekommen sie.
- **Im Einklang mit der Konfiguration von Claude Code.** Server aus den Einstellungen von Claude Code und Codex werden mit ihrem Zustand aufgelistet; du kannst sie in AgentVera importieren oder aus der CLI entfernen, und die Server von AgentVera lassen sich auch in die CLI-Einstellungen schreiben.
- **Eine Anmeldung, keine Tokens in Dateien.** Remote-Server laufen über das Gateway von AgentVera, du meldest dich einmal in der App bei einem OAuth-Server an, und die CLI des Agenten hält weder Header noch Token. Geheime Umgebungsvariablen und Header liegen im Schlüsselbund deines Betriebssystems.
- **Kosten, die du siehst.** Ein Verbindungstest listet Tools, Prompts und Ressourcen eines Servers mit ungefähren Token-Kosten pro Tool.

## Fazit

Fang mit einem Server an, den du wirklich brauchst, hinzugefügt mit `claude mcp add` im engsten Scope, der funktioniert. Prüf ihn mit `claude mcp list` oder `/mcp`, melde dich mit `/mcp` oder `claude mcp login` an und verschieb ihn erst dann in eine committete `.mcp.json`, wenn das ganze Team ihn braucht, mit Tokens in `${VAR}`-Referenzen. Wenn etwas hakt, lösen `claude mcp get`, `MCP_TIMEOUT` und `MAX_MCP_OUTPUT_TOKENS` das meiste.

Mehr dazu:

- [Was ist ein MCP-Server?](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server")
- [Die besten MCP-Server für Coding-Agenten](/de/blog/best-mcp-servers-for-coding/ "Die besten MCP-Server fürs Programmieren")
- [MCP-Manager](/de/features/mcp-manager/ "MCP-Manager")
- [Claude Code als Agent](/de/agents/claude-code/ "Claude Code in AgentVera")

## Häufige Fragen

**Wie füge ich Claude Code einen MCP-Server hinzu?** Führe claude mcp add im Terminal aus. Für einen lokalen Server: claude mcp add <name> -- <befehl> [argumente]. Für einen Remote-Server: claude mcp add --transport http <name> <url>. Prüfe danach mit claude mcp list oder /mcp in einer Session, ob er sich verbindet.

**Wo speichert Claude Code MCP-Server?** Server mit Scope local (Standard) und user liegen in ~/.claude.json, local-Server unter dem Pfad des jeweiligen Projekts. Server mit Scope project liegen in einer .mcp.json im Projekt-Root, die du für dein Team committen kannst.

**Was ist der Unterschied zwischen local, project und user?** Local gilt nur für dich und nur in diesem Projekt. Project gilt über die .mcp.json für alle, die das Repo klonen. User gilt nur für dich, aber in jedem Projekt auf deinem Rechner. Gibt es einen Namen in mehreren Scopes, gewinnt local vor project und project vor user.

**Wie melde ich mich bei einem MCP-Server mit OAuth an?** Füge ihn mit --transport http hinzu, führe dann in Claude Code /mcp aus und wähle Authenticate, oder nutze claude mcp login <name> in der Shell. Der Login im Browser schließt den Ablauf ab; Claude Code speichert das Token und erneuert es.

**Warum läuft mein MCP-Server in einen Timeout oder kürzt seine Ausgabe?** Langsame Server brauchen eventuell mehr Startzeit: Starte Claude Code mit MCP_TIMEOUT=10000 für zehn Sekunden. Tool-Ausgaben sind standardmäßig auf 25.000 Tokens begrenzt, mit einer Warnung ab 10.000; das Limit hebst du mit MAX_MCP_OUTPUT_TOKENS an.

**Ist eine .mcp.json aus einem geklonten Repo sicher?** Behandle sie wie jeden Code, den du nicht selbst geschrieben hast. Claude Code fragt in einer interaktiven Session nach, bevor es Projekt-Server nutzt, und ein geklontes Repo kann seine eigenen Server nicht freigeben. Lies jeden Befehl und jede URL, bevor du zustimmst.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/