> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Claude Code mit Tools über MCP verbinden
> Erfahren Sie, wie Sie Claude Code mit Ihren Tools über das Model Context Protocol verbinden.
Claude Code kann sich über das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction), einen offenen Standard für KI-Tool-Integrationen, mit Hunderten von externen Tools und Datenquellen verbinden. MCP-Server geben Claude Code Zugriff auf Ihre Tools, Datenbanken und APIs.
Verbinden Sie einen Server, wenn Sie feststellen, dass Sie Daten aus einem anderen Tool wie einem Issue-Tracker oder einem Überwachungs-Dashboard in den Chat kopieren. Nach der Verbindung kann Claude direkt auf dieses System zugreifen und handeln, anstatt mit dem zu arbeiten, was Sie einfügen.
Wenn Sie Ihren ersten Server verbinden, beginnen Sie mit der [MCP-Schnellstartanleitung](/de/mcp-quickstart) für eine Schritt-für-Schritt-Anleitung. Diese Seite ist die vollständige Referenz.
Was Sie mit MCP tun können
Mit verbundenen MCP-Servern können Sie Claude Code auffordern:
* **Funktionen aus Issue-Trackern implementieren**: „Füge die in JIRA-Issue ENG-4521 beschriebene Funktion hinzu und erstelle einen PR auf GitHub."
* **Überwachungsdaten analysieren**: „Überprüfe Sentry und Statsig, um die Nutzung der in ENG-4521 beschriebenen Funktion zu überprüfen."
* **Datenbanken abfragen**: „Finde E-Mail-Adressen von 10 zufälligen Benutzern, die die Funktion ENG-4521 verwendet haben, basierend auf unserer PostgreSQL-Datenbank."
* **Designs integrieren**: „Aktualisiere unsere Standard-E-Mail-Vorlage basierend auf den neuen Figma-Designs, die in Slack gepostet wurden"
* **Workflows automatisieren**: „Erstelle Gmail-Entwürfe, die diese 10 Benutzer zu einer Feedback-Sitzung zur neuen Funktion einladen."
* **Auf externe Ereignisse reagieren**: Ein MCP-Server kann auch als [Kanal](/de/channels) fungieren, der Nachrichten in Ihre Sitzung pusht, sodass Claude auf Telegram-Nachrichten, Discord-Chats oder Webhook-Ereignisse reagiert, während Sie weg sind.
MCP-Server finden und erstellen
Durchsuchen Sie überprüfte Konnektoren im [Anthropic Directory](https://claude.ai/directory). Directory-Konnektoren verwenden die gleiche MCP-Infrastruktur wie Claude Code, sodass Sie jeden dort aufgelisteten Remote-Server mit `claude mcp add` hinzufügen können.
Überprüfen Sie, dass Sie jedem Server vertrauen, bevor Sie ihn verbinden. Server, die externe Inhalte abrufen, können Sie dem [Risiko von Prompt-Injection aussetzen](/de/security#protect-against-prompt-injection).
Um Ihren eigenen Server zu erstellen, lesen Sie das [MCP-Server-Handbuch](https://modelcontextprotocol.io/docs/develop/build-server) für Protokoll-Grundlagen und die [Claude-Konnektoren-Dokumentation zum Erstellen](https://claude.com/docs/connectors/building) für Authentifizierung, Tests und Directory-Einreichung.
Sie können Claude auch einen Server für Sie mit dem offiziellen [`mcp-server-dev` Plugin](https://github.com/anthropics/claude-plugins-official/tree/main/plugins/mcp-server-dev) erstellen lassen.
Führen Sie in einer Claude Code-Sitzung Folgendes aus:
```
/plugin install mcp-server-dev@claude-plugins-official
```
Wenn Claude Code meldet, dass der Marketplace nicht gefunden wird, führen Sie zuerst `/plugin marketplace add anthropics/claude-plugins-official` aus und versuchen Sie dann die Installation erneut. Nach der Installation führen Sie `/reload-plugins` aus, um es in der aktuellen Sitzung zu aktivieren.
```
/mcp-server-dev:build-mcp-server
```
Claude fragt nach Ihrem Anwendungsfall und erstellt einen Remote-HTTP- oder lokalen Stdio-Server.
MCP-Server installieren
MCP-Server können je nach Ihren Anforderungen auf mehrere Arten konfiguriert werden:
Option 1: Einen Remote-HTTP-Server hinzufügen
HTTP-Server sind die empfohlene Option für die Verbindung mit Remote-MCP-Servern. Dies ist das am weitesten unterstützte Transportprotokoll für Cloud-basierte Dienste.
```bash theme={null}
# Grundlegende Syntax
claude mcp add --transport http
# Echtes Beispiel: Mit Notion verbinden
claude mcp add --transport http notion https://mcp.notion.com/mcp
# Beispiel mit Bearer-Token
claude mcp add --transport http secure-api https://api.example.com/mcp \
--header "Authorization: Bearer your-token"
```
Bei der Konfiguration von MCP-Servern über JSON in `.mcp.json`, `~/.claude.json` oder `claude mcp add-json` akzeptiert das Feld `type` `streamable-http` als Alias für `http`. Die MCP-Spezifikation verwendet den Namen `streamable-http` für dieses Transportprotokoll, sodass Konfigurationen, die aus der Server-Dokumentation kopiert werden, ohne Änderungen funktionieren.
Option 2: Einen Remote-SSE-Server hinzufügen
Das SSE-Transportprotokoll (Server-Sent Events) ist veraltet. Verwenden Sie stattdessen HTTP-Server, wo verfügbar.
```bash theme={null}
# Grundlegende Syntax
claude mcp add --transport sse
# Echtes Beispiel: Mit Asana verbinden
claude mcp add --transport sse asana https://mcp.asana.com/sse
# Beispiel mit Authentifizierungs-Header
claude mcp add --transport sse private-api https://api.company.com/sse \
--header "X-API-Key: your-key-here"
```
Option 3: Einen lokalen Stdio-Server hinzufügen
Stdio-Server werden als lokale Prozesse auf Ihrem Computer ausgeführt. Sie sind ideal für Tools, die direkten Systemzugriff oder benutzerdefinierte Skripte benötigen.
Claude Code setzt `CLAUDE_PROJECT_DIR` in der Umgebung des erzeugten Servers auf das Projektstammverzeichnis, sodass Ihr Server projektrelative Pfade auflösen kann, ohne vom Arbeitsverzeichnis abhängig zu sein. Dies ist das gleiche Verzeichnis, das Hooks in ihrer `CLAUDE_PROJECT_DIR`-Variable erhalten. Lesen Sie es aus Ihrem Serverprozess, zum Beispiel `process.env.CLAUDE_PROJECT_DIR` in Node oder `os.environ["CLAUDE_PROJECT_DIR"]` in Python.
Ihr Server kann auch die MCP-Anfrage `roots/list` aufrufen, die das Verzeichnis zurückgibt, aus dem Claude Code gestartet wurde.
Diese Variable wird in der Umgebung des Servers gesetzt, nicht in der Umgebung von Claude Code selbst, daher erfordert das Referenzieren über `${VAR}`-Erweiterung in einer projekt- oder benutzergesteuerten `.mcp.json` `command` oder `args` einen Standard wie `${CLAUDE_PROJECT_DIR:-.}`. Von Plugins bereitgestellte MCP-Konfigurationen ersetzen `${CLAUDE_PROJECT_DIR}` direkt und benötigen keinen Standard.
```bash theme={null}
# Grundlegende Syntax
claude mcp add [options] -- [args...]
# Echtes Beispiel: Airtable-Server hinzufügen
claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \
-- npx -y airtable-mcp-server
```
**Wichtig: Trennen Sie Server-Argumente mit `--`**
Bei Stdio-Servern trennt der `--` (Doppelstrich) Claudes eigene Optionen, wie `--transport`, `--env` und `--scope`, vom Befehl und den Argumenten, die den Server ausführen. Alles nach `--` wird unverändert an den Server übergeben.
Zum Beispiel:
* `claude mcp add --transport stdio myserver -- npx server` → führt `npx server` aus
* `claude mcp add --env KEY=value --transport stdio myserver -- python server.py --port 8080` → führt `python server.py --port 8080` mit `KEY=value` in der Umgebung aus
Ohne `--` würde Claude Code versuchen, die Flags des Servers, wie `--port` oben, als seine eigenen Optionen zu analysieren.
`--env` akzeptiert mehrere `KEY=value`-Paare. Wenn der Servername direkt nach `--env` kommt, liest die CLI den Namen als ein weiteres Paar und lehnt ihn ab, daher platzieren Sie mindestens eine andere Option zwischen `--env` und dem Servernamen, wie in den obigen Beispielen.
Option 4: Einen Remote-WebSocket-Server hinzufügen
WebSocket-Server halten eine persistente bidirektionale Verbindung, die sich für Remote-MCP-Server eignet, die Claude unaufgefordert Ereignisse pushen. Verwenden Sie HTTP stattdessen, wenn Ihr Server nur auf Anfragen antwortet, da HTTP OAuth und das Flag `claude mcp add --transport` unterstützt, während WebSocket beides nicht unterstützt.
Konfigurieren Sie WebSocket-Server in `.mcp.json` oder mit `claude mcp add-json`:
```bash theme={null}
claude mcp add-json events-server \
'{"type":"ws","url":"wss://mcp.example.com/socket","headers":{"Authorization":"Bearer YOUR_TOKEN"}}'
```
Der Eintrag `type: "ws"` akzeptiert die gleichen Felder `url`, `headers`, `headersHelper`, `timeout` und `alwaysLoad` wie `http`. Die Authentifizierung erfolgt nur über Header, daher übergeben Sie ein statisches Token in `headers` oder generieren Sie eines zur Verbindungszeit mit [`headersHelper`](#use-dynamic-headers-for-custom-authentication). Das Flag `claude mcp add --transport` akzeptiert nicht `ws`.
Verwalten Ihrer Server
Nach der Konfiguration können Sie Ihre MCP-Server mit diesen Befehlen verwalten:
```bash theme={null}
# Alle konfigurierten Server auflisten
claude mcp list
# Details für einen bestimmten Server abrufen
claude mcp get github
# Einen Server entfernen
claude mcp remove github
# (innerhalb von Claude Code) Serverstatus überprüfen
/mcp
```
Projekt-gesteuerte Server aus `.mcp.json`, die auf Ihre Genehmigung warten, erscheinen in `claude mcp list` als `⏸ Genehmigung ausstehend`. Führen Sie `claude` interaktiv aus, um sie zu überprüfen und zu genehmigen. `claude mcp get ` zeigt ausstehende Server als `⏸ Genehmigung ausstehend` und abgelehnte Server als `✗ Abgelehnt` an.
Ab v2.1.196 lesen `claude mcp list` und `claude mcp get` `.mcp.json`-Genehmigungen nur aus Einstellungsdateien, die nicht in das Repository eingecheckt werden, bis Sie dem Arbeitsbereich vertrauen, indem Sie `claude` darin ausführen und den Arbeitsbereich-Vertrauensdialog akzeptieren. Ein geklontes Repository kann seine eigenen Server nicht genehmigen: [`enableAllProjectMcpServers` oder `enabledMcpjsonServers`](/de/settings#available-settings), die in die `.claude/settings.json` des Projekts eingecheckt werden, werden in einem nicht vertrauenswürdigen Ordner ignoriert, und der Server bleibt bei `⏸ Genehmigung ausstehend` statt verbunden und Health-Check zu sein.
Genehmigungen aus diesen Quellen gelten weiterhin in einem nicht vertrauenswürdigen Ordner:
* Ihre Benutzer-`~/.claude/settings.json`
* Verwaltete Einstellungen
* Einstellungen, die mit `--settings` übergeben werden
* `.claude/settings.local.json`, solange Git es nicht verfolgt
Ein `disabledMcpjsonServers`-Eintrag in einer beliebigen Einstellungsdatei lehnt den Server weiterhin ab.
Das `/mcp`-Panel zeigt die Tool-Anzahl neben jedem verbundenen Server an und kennzeichnet Server, die die Tools-Funktion ankündigen, aber keine Tools bereitstellen.
Wenn Ihre Anfrage Tools von einem Server benötigt, der sich noch im Hintergrund verbindet, wartet Claude auf diesen Server, bevor er fortfährt. Mit [Tool-Suche](#scale-with-mcp-tool-search) aktiviert, was die Standardeinstellung ist, erfolgt das Warten innerhalb des `ToolSearch`-Aufrufs. In Konfigurationen ohne Tool-Suche, wie Vertex AI, eine benutzerdefinierte `ANTHROPIC_BASE_URL` oder `ENABLE_TOOL_SEARCH=false`, verwendet Claude stattdessen das `WaitForMcpServers`-Tool.
Der Servername `workspace` ist für interne Verwendung reserviert. Wenn Ihre Konfiguration einen Server mit diesem Namen definiert, überspringt Claude Code ihn beim Laden und zeigt eine Warnung an, die Sie auffordert, ihn umzubenennen.
Claude Code unterstützt MCP-`list_changed`-Benachrichtigungen, die es MCP-Servern ermöglichen, ihre verfügbaren Tools, Prompts und Ressourcen dynamisch zu aktualisieren, ohne dass Sie die Verbindung trennen und erneut verbinden müssen. Wenn ein MCP-Server eine `list_changed`-Benachrichtigung sendet, aktualisiert Claude Code automatisch die verfügbaren Funktionen von diesem Server.
Automatische Wiederverbindung
Wenn ein HTTP- oder SSE-Server während einer Sitzung die Verbindung trennt, verbindet sich Claude Code automatisch mit exponentiellem Backoff wieder: bis zu fünf Versuche, beginnend mit einer Verzögerung von einer Sekunde und sich jedes Mal verdoppelnd. Der Server wird als ausstehend in `/mcp` angezeigt, während die Wiederverbindung läuft. Nach fünf fehlgeschlagenen Versuchen wird der Server als fehlgeschlagen markiert und Sie können ihn manuell von `/mcp` aus erneut versuchen. Stdio-Server sind lokale Prozesse und werden nicht automatisch wiederverbunden.
Das gleiche Backoff gilt, wenn ein HTTP- oder SSE-Server beim Start seine anfängliche Verbindung nicht herstellt. Ab v2.1.121 versucht Claude Code die anfängliche Verbindung bis zu dreimal bei vorübergehenden Fehlern wie einer 5xx-Antwort, einer Verbindungsverweigerung oder einem Timeout erneut, markiert den Server dann als fehlgeschlagen, wenn er immer noch keine Verbindung herstellen kann. Authentifizierungs- und Not-Found-Fehler werden nicht erneut versucht, da sie eine Konfigurationsänderung erfordern, um behoben zu werden.
Ab v2.1.191 versuchen die Funktionsentdeckungsanfragen, die nach einer erfolgreichen Verbindung ausgeführt werden, wie `tools/list`, `prompts/list` und `resources/list`, auch vorübergehende Netzwerk- und Serverfehler bis zu dreimal mit kurzem Backoff erneut. Authentifizierungsfehler, 4xx-Antworten und Request-Timeouts werden nicht erneut versucht.
Push-Nachrichten mit Kanälen
Ein MCP-Server kann auch Nachrichten direkt in Ihre Sitzung pushen, sodass Claude auf externe Ereignisse wie CI-Ergebnisse, Überwachungswarnungen oder Chat-Nachrichten reagieren kann. Um dies zu aktivieren, deklariert Ihr Server die Funktion `claude/channel` und Sie aktivieren sie mit dem Flag `--channels` beim Start. Siehe [Kanäle](/de/channels), um einen offiziell unterstützten Kanal zu verwenden, oder [Kanäle-Referenz](/de/channels-reference), um Ihren eigenen zu erstellen.
Tipps:
* Verwenden Sie das Flag `--scope`, um anzugeben, wo die Konfiguration gespeichert wird:
* `local` (Standard): Nur für Sie im aktuellen Projekt verfügbar. Ältere Versionen nannten diesen Bereich `project`
* `project`: Geteilt mit allen im Projekt über die Datei `.mcp.json`
* `user`: Für Sie über alle Projekte hinweg verfügbar. Ältere Versionen nannten diesen Bereich `global`
* Legen Sie Umgebungsvariablen mit `--env`-Flags fest (zum Beispiel `--env KEY=value`)
* Konfigurieren Sie das Startup-Timeout des MCP-Servers mit der Umgebungsvariablen `MCP_TIMEOUT` (zum Beispiel `MCP_TIMEOUT=10000 claude` setzt ein 10-Sekunden-Timeout)
* Setzen Sie ein Pro-Server-Tool-Ausführungs-Timeout, indem Sie ein `timeout`-Feld in Millisekunden zum `.mcp.json`-Eintrag dieses Servers hinzufügen, zum Beispiel `"timeout": 600000` für zehn Minuten. Dies überschreibt die Umgebungsvariable `MCP_TOOL_TIMEOUT` nur für diesen Server
* Claude Code zeigt eine Warnung an, wenn die MCP-Tool-Ausgabe 10.000 Token überschreitet. Um dieses Limit zu erhöhen, setzen Sie die Umgebungsvariable `MAX_MCP_OUTPUT_TOKENS` (zum Beispiel `MAX_MCP_OUTPUT_TOKENS=50000`)
* Verwenden Sie `/mcp`, um sich bei Remote-Servern zu authentifizieren, die OAuth 2.0-Authentifizierung erfordern
Das Pro-Server-`timeout` ist eine harte Wanduhr-Grenze pro Tool-Aufruf, und Fortschrittsbenachrichtigungen vom Server verlängern sie nicht. Werte unter 1000 werden ignoriert und fallen auf `MCP_TOOL_TIMEOUT` zurück, oder auf seinen Standard von etwa 28 Stunden, wenn diese Variable nicht gesetzt ist. {/* min-version: 2.1.162 */}Vor v2.1.162 wurden Werte unter 1000 stattdessen auf eine Sekunde begrenzt.
Bei HTTP- und SSE-Servern hat das Pro-Request-Fetch-First-Byte-Budget ein 60-Sekunden-Minimum.
Ab v2.1.187 bricht ein Tool-Aufruf an einen Remote-HTTP-, SSE-, WebSocket- oder [claude.ai-Connector](#use-mcp-servers-from-claude-ai)-Server, der 5 Minuten lang keine Antwort und keine Fortschrittsbenachrichtigung sendet, mit einem Fehler ab, anstatt auf die Wanduhr-Grenze zu warten. Setzen Sie die Umgebungsvariable [`CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT`](/de/env-vars) in Millisekunden, um das Idle-Fenster zu ändern, oder setzen Sie sie auf `0`, um die Überprüfung zu deaktivieren. Stdio-Server sind lokale Prozesse und unterliegen nicht dem Idle-Timeout.
Von Plugins bereitgestellte MCP-Server
[Plugins](/de/plugins) können MCP-Server bündeln und automatisch Tools und Integrationen bereitstellen, wenn das Plugin aktiviert ist. Plugin-MCP-Server funktionieren identisch mit benutzerkonfigurierten Servern.
**Wie Plugin-MCP-Server funktionieren**:
* Plugins definieren MCP-Server in `.mcp.json` im Plugin-Root oder inline in `plugin.json`
* Wenn ein Plugin aktiviert ist, starten seine MCP-Server automatisch
* Plugin-MCP-Tools erscheinen neben manuell konfigurierten MCP-Tools
* Plugin-Server werden durch die Plugin-Installation verwaltet, nicht durch `/mcp`-Befehle
**Beispiel-Plugin-MCP-Konfiguration**:
In `.mcp.json` im Plugin-Root:
```json theme={null}
{
"mcpServers": {
"database-tools": {
"command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
"args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
"env": {
"DB_URL": "${DB_URL}"
}
}
}
}
```
Oder inline in `plugin.json`:
```json theme={null}
{
"name": "my-plugin",
"mcpServers": {
"plugin-api": {
"command": "${CLAUDE_PLUGIN_ROOT}/servers/api-server",
"args": ["--port", "8080"]
}
}
}
```
**Plugin-MCP-Funktionen**:
* **Automatischer Lebenszyklus**: Bei Sitzungsstart verbinden sich Server für aktivierte Plugins automatisch. Wenn Sie ein Plugin während einer Sitzung aktivieren oder deaktivieren, führen Sie `/reload-plugins` aus, um seine MCP-Server zu verbinden oder zu trennen
* **Umgebungsvariablen**: Verwenden Sie `${CLAUDE_PLUGIN_ROOT}` für gebündelte Plugin-Dateien, `${CLAUDE_PLUGIN_DATA}` für [persistente Daten](/de/plugins-reference#persistent-data-directory), die Plugin-Updates überstehen, und `${CLAUDE_PROJECT_DIR}` für das stabile Projektstammverzeichnis
* **Zugriff auf Benutzerumgebung**: Zugriff auf die gleichen Umgebungsvariablen wie manuell konfigurierte Server
* **Mehrere Transporttypen**: Unterstützung für Stdio-, SSE-, HTTP- und WebSocket-Transporte, wobei die Transportunterstützung je nach Server variieren kann
**Anzeigen von Plugin-MCP-Servern**:
```bash theme={null}
# Innerhalb von Claude Code alle MCP-Server einschließlich Plugin-Server anzeigen
/mcp
```
Plugin-Server erscheinen in der Liste mit Indikatoren, die zeigen, dass sie von Plugins stammen.
**Plugin-MCP-Tool-Namen**:
Tools von einem Plugin-gebündelten MCP-Server enthalten sowohl den Plugin-Namen als auch den Server-Schlüssel in ihrem aufrufbaren Namen. Die vollständige Form ist `mcp__plugin____`, wobei jedes Zeichen außerhalb von `A-Z`, `a-z`, `0-9`, `_` und `-` durch `_` ersetzt wird. Für den Server `database-tools`, der in einem Plugin namens `my-plugin` gebündelt ist, ist ein `query`-Tool aufrufbar als:
```
mcp__plugin_my-plugin_database-tools__query
```
Verwenden Sie diesen vollständigen Namen, wenn Sie auf das Tool in [Berechtigungsregeln](/de/permissions), der `allowed-tools`-Liste eines Skills oder dem [`tools`-Feld eines Subagenten](/de/sub-agents#available-tools) verweisen.
**Vorteile von Plugin-MCP-Servern**:
* **Gebündelte Verteilung**: Tools und Server zusammen verpackt
* **Automatische Einrichtung**: Keine manuelle MCP-Konfiguration erforderlich
* **Team-Konsistenz**: Alle erhalten die gleichen Tools, wenn das Plugin installiert ist
Siehe die [Plugin-Komponenten-Referenz](/de/plugins-reference#mcp-servers) für Details zum Bündeln von MCP-Servern mit Plugins.
MCP-Installationsbereiche
MCP-Server können auf drei verschiedenen Bereichsebenen konfiguriert werden. Der Bereich, den Sie wählen, steuert, in welchen Projekten der Server geladen wird und ob die Konfiguration mit Ihrem Team geteilt wird. Administratoren können Server auch auf Unternehmensebene über [verwaltete Konfiguration](#managed-mcp-configuration) bereitstellen.
| Bereich | Wird geladen in | Mit Team geteilt | Gespeichert in |
| ------------------------- | --------------------- | -------------------------- | --------------------------- |
| [Lokal](#local-scope) | Nur aktuelles Projekt | Nein | `~/.claude.json` |
| [Projekt](#project-scope) | Nur aktuelles Projekt | Ja, über Versionskontrolle | `.mcp.json` im Projekt-Root |
| [Benutzer](#user-scope) | Alle Ihre Projekte | Nein | `~/.claude.json` |
Lokaler Bereich
Der lokale Bereich ist der Standard. Ein lokal begrenzter Server wird nur in dem Projekt geladen, in dem Sie ihn hinzugefügt haben, und bleibt privat für Sie. Claude Code speichert ihn in `~/.claude.json` unter dem Pfad dieses Projekts, daher wird derselbe Server nicht in Ihren anderen Projekten angezeigt. Verwenden Sie den lokalen Bereich für persönliche Entwicklungsserver, experimentelle Konfigurationen oder Server mit Anmeldedaten, die Sie nicht in der Versionskontrolle haben möchten.
Der Begriff „lokaler Bereich" für MCP-Server unterscheidet sich von allgemeinen lokalen Einstellungen. Lokal begrenzte MCP-Server werden in `~/.claude.json` (Ihr Home-Verzeichnis) gespeichert, während allgemeine lokale Einstellungen `.claude/settings.local.json` (im Projektverzeichnis) verwenden. Siehe [Einstellungen](/de/settings#settings-files) für Details zu Einstellungsdatei-Speicherorten.
```bash theme={null}
# Einen lokal begrenzten Server hinzufügen (Standard)
claude mcp add --transport http stripe https://mcp.stripe.com
# Lokalen Bereich explizit angeben
claude mcp add --transport http stripe --scope local https://mcp.stripe.com
```
Der Befehl schreibt den Server in den Eintrag für Ihr aktuelles Projekt in `~/.claude.json`. Das folgende Beispiel zeigt das Ergebnis, wenn Sie ihn von `/path/to/your/project` aus ausführen:
```json theme={null}
{
"projects": {
"/path/to/your/project": {
"mcpServers": {
"stripe": {
"type": "http",
"url": "https://mcp.stripe.com"
}
}
}
}
}
```
Projektbereich
Projektbegrenzte Server ermöglichen Teamzusammenarbeit durch das Speichern von Konfigurationen in einer `.mcp.json`-Datei im Root-Verzeichnis Ihres Projekts. Diese Datei ist dazu bestimmt, in die Versionskontrolle eingecheckt zu werden, um sicherzustellen, dass alle Teammitglieder Zugriff auf die gleichen MCP-Tools und -Dienste haben. Wenn Sie einen projektbegrenzten Server hinzufügen, erstellt oder aktualisiert Claude Code automatisch diese Datei mit der entsprechenden Konfigurationsstruktur.
```bash theme={null}
# Einen projektbegrenzten Server hinzufügen
claude mcp add --transport http paypal --scope project https://mcp.paypal.com/mcp
```
Die resultierende `.mcp.json`-Datei folgt einem standardisierten Format:
```json theme={null}
{
"mcpServers": {
"shared-server": {
"command": "/path/to/server",
"args": [],
"env": {}
}
}
}
```
Aus Sicherheitsgründen fordert Claude Code eine Genehmigung an, bevor projektbegrenzte Server aus `.mcp.json`-Dateien verwendet werden. Wenn Sie diese Genehmigungswahlmöglichkeiten zurücksetzen müssen, verwenden Sie den Befehl `claude mcp reset-project-choices`.
Benutzerbereich
Benutzerbegrenzte Server werden in `~/.claude.json` gespeichert und bieten projektübergreifende Zugänglichkeit, wodurch sie über alle Projekte auf Ihrem Computer verfügbar sind und gleichzeitig privat für Ihr Benutzerkonto bleiben. Dieser Bereich funktioniert gut für persönliche Utility-Server, Entwicklungstools oder Dienste, die Sie häufig über verschiedene Projekte hinweg verwenden.
```bash theme={null}
# Einen Benutzer-Server hinzufügen
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic
```
Bereichshierarchie und Vorrang
Wenn derselbe Server auf mehreren Bereichen definiert ist, verbindet sich Claude Code einmal damit und verwendet die Definition aus der höchsten Vorrangsquelle. Der gesamte Server-Eintrag aus dieser Quelle wird verwendet; Felder werden nicht über Bereiche hinweg zusammengeführt.
1. Lokaler Bereich
2. Projektbereich
3. Benutzerbereich
4. [Von Plugins bereitgestellte Server](/de/plugins)
5. [Claude.ai-Connectoren](#use-mcp-servers-from-claude-ai)
Die drei Bereiche stimmen Duplikate nach Name ab. Plugins und Connectoren stimmen nach Endpunkt ab, daher wird einer, der auf die gleiche URL oder den gleichen Befehl wie ein Server oben verweist, als Duplikat behandelt.
Umgebungsvariablen-Erweiterung in `.mcp.json`
Claude Code unterstützt die Umgebungsvariablen-Erweiterung in `.mcp.json`-Dateien, die es Teams ermöglicht, Konfigurationen zu teilen und gleichzeitig Flexibilität für maschinenspezifische Pfade und vertrauliche Werte wie API-Schlüssel zu bewahren.
**Unterstützte Syntax:**
* `${VAR}` - Erweitert sich zum Wert der Umgebungsvariablen `VAR`
* `${VAR:-default}` - Erweitert sich zu `VAR`, wenn gesetzt, andernfalls wird `default` verwendet
**Erweiterungsorte:**
Umgebungsvariablen können erweitert werden in:
* `command` - Der Server-Ausführungspfad
* `args` - Befehlszeilenargumente
* `env` - Umgebungsvariablen, die an den Server übergeben werden
* `url` - Für HTTP-Server-Typen
* `headers` - Für HTTP-Server-Authentifizierung
**Beispiel mit Variablenerweiterung:**
```json theme={null}
{
"mcpServers": {
"api-server": {
"type": "http",
"url": "${API_BASE_URL:-https://api.example.com}/mcp",
"headers": {
"Authorization": "Bearer ${API_KEY}"
}
}
}
}
```
Wenn eine erforderliche Umgebungsvariable nicht gesetzt ist und keinen Standardwert hat, kann Claude Code die Konfiguration nicht analysieren.
Praktische Beispiele
Beispiel: Fehler mit Sentry überwachen
```bash theme={null}
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```
Authentifizieren Sie sich mit Ihrem Sentry-Konto:
```text theme={null}
/mcp
```
Debuggen Sie dann Produktionsprobleme:
```text theme={null}
What are the most common errors in the last 24 hours?
```
```text theme={null}
Show me the stack trace for error ID abc123
```
```text theme={null}
Which deployment introduced these new errors?
```
Beispiel: Mit GitHub für Code-Reviews verbinden
GitHubs Remote-MCP-Server authentifiziert sich mit einem GitHub-Personal-Access-Token, der als Header übergeben wird. Um einen zu erhalten, öffnen Sie Ihre [GitHub-Token-Einstellungen](https://github.com/settings/personal-access-tokens), generieren Sie ein neues feingranulares Token mit Zugriff auf die Repositories, mit denen Claude arbeiten soll, und fügen Sie dann den Server hinzu:
```bash theme={null}
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
--header "Authorization: Bearer YOUR_GITHUB_PAT"
```
Arbeiten Sie dann mit GitHub:
```text theme={null}
Review PR #456 and suggest improvements
```
```text theme={null}
Create a new issue for the bug we just found
```
```text theme={null}
Show me all open PRs assigned to me
```
Beispiel: Ihre PostgreSQL-Datenbank abfragen
```bash theme={null}
claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
--dsn "postgresql://readonly:pass@prod.db.com:5432/analytics"
```
Fragen Sie dann Ihre Datenbank natürlich ab:
```text theme={null}
What's our total revenue this month?
```
```text theme={null}
Show me the schema for the orders table
```
```text theme={null}
Find customers who haven't made a purchase in 90 days
```
Mit Remote-MCP-Servern authentifizieren
Viele Cloud-basierte MCP-Server erfordern Authentifizierung. Claude Code unterstützt OAuth 2.0 für sichere Verbindungen.
Claude Code markiert einen Remote-Server als authentifizierungsbedürftig, wenn der Server mit `401 Unauthorized` oder `403 Forbidden` antwortet. Jeder dieser Statuscodes kennzeichnet den Server in `/mcp`, damit Sie den OAuth-Fluss abschließen können.
Ab v2.1.195 zeigt Claude Code sofort einen Hinweis an, der auf `/mcp` verweist, wenn eine Token-Aktualisierung fehlschlägt, weil der Server das gespeicherte Refresh-Token ablehnt. Das Menü des verbundenen Servers dort bietet „Re-authenticate", damit Sie sich erneut anmelden können, bevor der nächste Tool-Aufruf fehlschlägt.
Ein benutzerdefinierter Server, der einen `WWW-Authenticate`-Header zurückgibt, der auf seinen Autorisierungsserver verweist, erhält die gleiche automatische Erkennung wie jeder andere Remote-Server.
Ab v2.1.193 zeigt Claude Code auch einen Starthinweis an, wenn ein oder mehrere konfigurierte Server Authentifizierung benötigen, sodass Sie `/mcp` nicht öffnen müssen, um zu erkennen, welche Server Anmeldung benötigen.
Im nicht-interaktiven Modus gibt es kein `/mcp`-Panel, daher kann Claude Code den OAuth-Fluss nicht für Sie ausführen. Ab v2.1.196 teilt Claude Code Claude mit, dass die Tools des Servers nicht verfügbar sind, bis Sie ihn autorisieren, wenn ein konfigurierter Server während eines `claude -p`- oder Agent SDK-Laufs mit aktivierter [Tool-Suche](#scale-with-mcp-tool-search) (Standard) Authentifizierung benötigt. Claude kann dann den Server benennen, der Anmeldung benötigt, anstatt so zu reagieren, als wäre der Server nicht konfiguriert. Schließen Sie die Anmeldung aus einer interaktiven Sitzung mit `/mcp` oder `claude mcp login ` ab.
Wenn Sie `headers.Authorization` für den Server konfiguriert haben und der Server diesen Header ablehnt, meldet Claude Code die Verbindung als fehlgeschlagen, anstatt auf OAuth zurückzugreifen. Überprüfen Sie, dass das Token für den MCP-Endpunkt gültig ist, oder entfernen Sie den Header, um den OAuth-Fluss zu verwenden.
Zum Beispiel:
```bash theme={null}
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp
```
In Claude Code verwenden Sie den Befehl:
```text theme={null}
/mcp
```
Folgen Sie dann den Schritten in Ihrem Browser, um sich anzumelden.
Tipps:
* Authentifizierungstoken werden sicher gespeichert und automatisch aktualisiert
* Verwenden Sie „Clear authentication" im `/mcp`-Menü, um den Zugriff zu widerrufen
* Wenn Ihr Browser nicht automatisch geöffnet wird, kopieren Sie die bereitgestellte URL und öffnen Sie sie manuell
* Wenn die Browser-Umleitung nach der Authentifizierung mit einem Verbindungsfehler fehlschlägt, fügen Sie die vollständige Callback-URL aus der Adressleiste Ihres Browsers in die URL-Eingabeaufforderung ein, die in Claude Code angezeigt wird
* OAuth-Authentifizierung funktioniert mit HTTP-Servern
Authentifizieren Sie sich über die Befehlszeile
Ab v2.1.186 führt `claude mcp login ` den OAuth-Fluss eines konfigurierten Servers direkt aus Ihrer Shell aus, sodass Sie das `/mcp`-Panel nicht innerhalb einer Sitzung öffnen müssen.
```bash theme={null}
claude mcp login sentry
```
Um gespeicherte Anmeldedaten später zu löschen, führen Sie `claude mcp logout ` aus.
Ab v2.1.191 erkennt der Befehl, wenn kein lokaler Browser verfügbar ist, z. B. während einer SSH-Sitzung oder unter Linux ohne Display-Server, und gibt die Autorisierungs-URL aus, anstatt zu versuchen, einen Browser zu öffnen. Öffnen Sie die URL auf Ihrem lokalen Computer und fügen Sie dann die vollständige Umleitungs-URL aus der Adressleiste Ihres Browsers an der Eingabeaufforderung ein. Der Befehl benötigt ein interaktives Terminal für den Einfügungsschritt, daher verbinden Sie sich mit `ssh -t`. Übergeben Sie `--no-browser`, um die URL-Eingabeaufforderung zu erzwingen, auch wenn ein lokaler Browser erkannt wird.
```bash theme={null}
claude mcp login sentry --no-browser
```
Verwenden Sie einen festen OAuth-Callback-Port
Einige MCP-Server erfordern einen spezifischen Redirect-URI, der im Voraus registriert ist. Standardmäßig wählt Claude Code einen zufällig verfügbaren Port für den OAuth-Callback. Verwenden Sie `--callback-port`, um den Port zu fixieren, damit er einem vorregistrierten Redirect-URI der Form `http://localhost:PORT/callback` entspricht.
Sie können `--callback-port` allein (mit dynamischer Client-Registrierung) oder zusammen mit `--client-id` (mit vorkonfigurierten Anmeldedaten) verwenden.
```bash theme={null}
# Fester Callback-Port mit dynamischer Client-Registrierung
claude mcp add --transport http \
--callback-port 8080 \
my-server https://mcp.example.com/mcp
```
Einige MCP-Server unterstützen keine automatische OAuth-Einrichtung über Dynamic Client Registration. Wenn Sie einen Fehler wie „Incompatible auth server: does not support dynamic client registration" sehen, erfordert der Server vorkonfigurierte Anmeldedaten. Claude Code unterstützt auch Server, die ein Client ID Metadata Document (CIMD) anstelle von Dynamic Client Registration verwenden, und erkennt diese automatisch. Wenn die automatische Erkennung fehlschlägt, registrieren Sie zunächst eine OAuth-App über das Entwicklerportal des Servers und geben Sie dann die Anmeldedaten beim Hinzufügen des Servers an.
Erstellen Sie eine App über das Entwicklerportal des Servers und notieren Sie sich Ihre Client-ID und Ihren Client-Secret.
Viele Server erfordern auch einen Redirect-URI. Wenn ja, wählen Sie einen Port und registrieren Sie einen Redirect-URI im Format `http://localhost:PORT/callback`. Verwenden Sie denselben Port mit `--callback-port` im nächsten Schritt.
Wählen Sie eine der folgenden Methoden. Der für `--callback-port` verwendete Port kann ein beliebiger verfügbarer Port sein. Er muss nur dem Redirect-URI entsprechen, den Sie im vorherigen Schritt registriert haben.
Verwenden Sie `--client-id`, um die Client-ID Ihrer App zu übergeben. Das Flag `--client-secret` fordert das Secret mit maskierter Eingabe an:
```bash theme={null}
claude mcp add --transport http \
--client-id your-client-id --client-secret --callback-port 8080 \
my-server https://mcp.example.com/mcp
```
Fügen Sie das Objekt `oauth` in die JSON-Konfiguration ein und übergeben Sie `--client-secret` als separates Flag:
```bash theme={null}
claude mcp add-json my-server \
'{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' \
--client-secret
```
Verwenden Sie `--callback-port` ohne Client-ID, um den Port zu fixieren und gleichzeitig die dynamische Client-Registrierung zu verwenden:
```bash theme={null}
claude mcp add-json my-server \
'{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"callbackPort":8080}}'
```
Legen Sie das Secret über eine Umgebungsvariable fest, um die interaktive Eingabeaufforderung zu überspringen:
```bash theme={null}
MCP_CLIENT_SECRET=your-secret claude mcp add --transport http \
--client-id your-client-id --client-secret --callback-port 8080 \
my-server https://mcp.example.com/mcp
```
Führen Sie `/mcp` in Claude Code aus und folgen Sie dem Browser-Login-Ablauf.
Tipps:
* Das Client-Secret wird sicher in Ihrem System-Keychain (macOS) oder einer Anmeldedatei gespeichert, nicht in Ihrer Konfiguration
* Wenn der Server einen öffentlichen OAuth-Client ohne Secret verwendet, verwenden Sie nur `--client-id` ohne `--client-secret`
* `--callback-port` kann mit oder ohne `--client-id` verwendet werden
* Diese Flags gelten nur für HTTP- und SSE-Transporte. Sie haben keine Auswirkung auf Stdio-Server
* Verwenden Sie `claude mcp get `, um zu überprüfen, dass OAuth-Anmeldedaten für einen Server konfiguriert sind
Verweisen Sie Claude Code auf eine spezifische OAuth-Autorisierungsserver-Metadaten-URL, um die Standard-Erkennungskette zu umgehen. Legen Sie `authServerMetadataUrl` fest, wenn die Standard-Endpunkte des MCP-Servers Fehler zurückgeben, oder wenn Sie die Erkennung durch einen internen Proxy leiten möchten. Standardmäßig überprüft Claude Code zunächst RFC 9728 Protected Resource Metadata unter `/.well-known/oauth-protected-resource` und fällt dann auf RFC 8414 Authorization Server Metadata unter `/.well-known/oauth-authorization-server` zurück.
Legen Sie `authServerMetadataUrl` im Objekt `oauth` der Konfiguration Ihres Servers in `.mcp.json` fest:
```json theme={null}
{
"mcpServers": {
"my-server": {
"type": "http",
"url": "https://mcp.example.com/mcp",
"oauth": {
"authServerMetadataUrl": "https://auth.example.com/.well-known/openid-configuration"
}
}
}
}
```
Die URL muss `https://` verwenden. `authServerMetadataUrl` erfordert Claude Code v2.1.64 oder später. Die `scopes_supported` der Metadaten-URL überschreiben die Bereiche, die der Upstream-Server bewirbt.
Beschränken Sie OAuth-Bereiche
Legen Sie `oauth.scopes` fest, um die Bereiche zu fixieren, die Claude Code während des Autorisierungsflusses anfordert. Dies ist die unterstützte Methode, um einen MCP-Server auf eine von Ihrem Sicherheitsteam genehmigte Teilmenge zu beschränken, wenn der Upstream-Autorisierungsserver mehr Bereiche bewirbt, als Sie gewähren möchten. Der Wert ist eine einzelne durch Leerzeichen getrennte Zeichenkette, die dem `scope`-Parameter-Format in RFC 6749 §3.3 entspricht.
```json theme={null}
{
"mcpServers": {
"slack": {
"type": "http",
"url": "https://mcp.slack.com/mcp",
"oauth": {
"scopes": "channels:read chat:write search:read"
}
}
}
}
```
`oauth.scopes` hat Vorrang vor sowohl `authServerMetadataUrl` als auch den Bereichen, die der Server unter `/.well-known` entdeckt. Lassen Sie es ungesetzt, damit der MCP-Server den angeforderten Bereichssatz bestimmt.
Ab v2.1.196 fordert Claude Code, wenn `oauth.scopes` nicht gesetzt ist, den Bereich an, der vom `WWW-Authenticate`-Header des Servers oder seinen Protected Resource Metadata bereitgestellt wird, und sendet keinen `scope`-Parameter, wenn keiner von beiden einen bereitstellt. Es fordert nicht mehr den vollständigen `scopes_supported`-Katalog aus automatisch erkannten Authorization Server Metadata an. Das Anfordern dieses Katalogs führte dazu, dass Identity Provider, die Admin-only- oder Template-Bereiche bewerben, die Autorisierungsanfrage mit einem `invalid_scope`-Fehler ablehnten. Metadaten, die von einer konfigurierten `authServerMetadataUrl` abgerufen werden, liefern immer noch ihre `scopes_supported` als die angeforderten Bereiche.
Wenn der Autorisierungsserver `offline_access` in `scopes_supported` bewirbt, fügt Claude Code es zu den fixierten Bereichen hinzu, damit das Zugriffs-Token ohne neue Browser-Anmeldung aktualisiert werden kann.
Wenn der Server später einen 403 `insufficient_scope` für einen Tool-Aufruf zurückgibt, authentifiziert sich Claude Code mit den gleichen fixierten Bereichen erneut. Erweitern Sie `oauth.scopes`, wenn ein Tool, das Sie benötigen, einen Bereich außerhalb der Fixierung erfordert.
Wenn Ihr MCP-Server ein anderes Authentifizierungsschema verwendet als OAuth (wie Kerberos, kurzlebige Token oder ein internes SSO), verwenden Sie `headersHelper`, um Request-Header zur Verbindungszeit zu generieren. Claude Code führt den Befehl aus und fügt seine Ausgabe in die Verbindungs-Header ein.
```json theme={null}
{
"mcpServers": {
"internal-api": {
"type": "http",
"url": "https://mcp.internal.example.com",
"headersHelper": "/opt/bin/get-mcp-auth-headers.sh"
}
}
}
```
Der Befehl kann auch inline sein:
```json theme={null}
{
"mcpServers": {
"internal-api": {
"type": "http",
"url": "https://mcp.internal.example.com",
"headersHelper": "echo '{\"Authorization\": \"Bearer '\"$(get-token)\"'\"}'"
}
}
}
```
**Anforderungen:**
* Der Befehl muss ein JSON-Objekt mit String-Schlüssel-Wert-Paaren auf stdout schreiben
* Der Befehl wird in einer Shell mit einem 10-Sekunden-Timeout ausgeführt
* Dynamische Header überschreiben alle statischen `headers` mit dem gleichen Namen
Der Helper wird bei jeder Verbindung neu ausgeführt (beim Sitzungsstart und bei Wiederverbindung). Es gibt kein Caching, daher ist Ihr Skript für jede Token-Wiederverwendung verantwortlich.
Ab v2.1.193 führt Claude Code den Helper automatisch erneut aus, wenn ein Tool-Aufruf `401 Unauthorized` oder `403 Forbidden` zurückgibt, verbindet sich mit den neuen Headern erneut und wiederholt den Aufruf einmal. Claude Code markiert den Server als authentifizierungsbedürftig in `/mcp` nur, wenn dieser Wiederholungsversuch auch fehlschlägt.
Claude Code setzt diese Umgebungsvariablen beim Ausführen des Helpers:
| Variable | Wert |
| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
| `CLAUDE_CODE_MCP_SERVER_NAME` | der Name des MCP-Servers |
| `CLAUDE_CODE_MCP_SERVER_URL` | die URL des MCP-Servers |
| `CLAUDE_PLUGIN_ROOT` | das Root-Verzeichnis des Plugins. Wird nur gesetzt, wenn ein [Plugin](/de/plugins-reference#mcp-servers) den Server bereitstellt |
Verwenden Sie diese, um ein einzelnes Helper-Skript zu schreiben, das mehrere MCP-Server bedient.
Für einen von einem Plugin bereitgestellten Server wird der Helper auch mit seinem Arbeitsverzeichnis auf das Plugin-Root gesetzt ausgeführt, sodass ein relativer `headersHelper`-Pfad im Plugin-Verzeichnis aufgelöst wird, anstatt gegen das Arbeitsverzeichnis der Sitzung. Erfordert Claude Code v2.1.195 oder später.
`headersHelper` führt beliebige Shell-Befehle aus. Wenn es auf Projekt- oder lokalem Bereich definiert ist, wird es nur nach Ihrer Zustimmung zum Workspace-Trust-Dialog ausgeführt.
MCP-Server aus JSON-Konfiguration hinzufügen
Wenn Sie eine JSON-Konfiguration für einen MCP-Server haben, können Sie sie direkt hinzufügen:
```bash theme={null}
# Grundlegende Syntax
claude mcp add-json ''
# Beispiel: Hinzufügen eines HTTP-Servers mit JSON-Konfiguration
claude mcp add-json weather-api '{"type":"http","url":"https://api.weather.com/mcp","headers":{"Authorization":"Bearer token"}}'
# Beispiel: Hinzufügen eines Stdio-Servers mit JSON-Konfiguration
claude mcp add-json local-weather '{"type":"stdio","command":"/path/to/weather-cli","args":["--api-key","abc123"],"env":{"CACHE_DIR":"/tmp"}}'
# Beispiel: Hinzufügen eines HTTP-Servers mit vorkonfigurierten OAuth-Anmeldedaten
claude mcp add-json my-server '{"type":"http","url":"https://mcp.example.com/mcp","oauth":{"clientId":"your-client-id","callbackPort":8080}}' --client-secret
```
```bash theme={null}
claude mcp get weather-api
```
Tipps:
* Stellen Sie sicher, dass das JSON in Ihrer Shell ordnungsgemäß escaped ist
* Das JSON muss dem MCP-Server-Konfigurationsschema entsprechen
* Sie können `--scope user` verwenden, um den Server zu Ihrer Benutzerkonfiguration statt zur projektspezifischen hinzuzufügen
MCP-Server aus Claude Desktop importieren
Wenn Sie bereits MCP-Server in Claude Desktop konfiguriert haben, können Sie diese importieren:
```bash theme={null}
# Grundlegende Syntax
claude mcp add-from-claude-desktop
```
Nach dem Ausführen des Befehls wird ein interaktives Dialogfeld angezeigt, in dem Sie auswählen können, welche Server Sie importieren möchten.
```bash theme={null}
claude mcp list
```
Tipps:
* Diese Funktion funktioniert nur auf macOS und Windows Subsystem for Linux (WSL)
* Sie liest die Claude Desktop-Konfigurationsdatei von ihrem Standardort auf diesen Plattformen
* Verwenden Sie das Flag `--scope user`, um Server zu Ihrer Benutzerkonfiguration hinzuzufügen
* Importierte Server haben die gleichen Namen wie in Claude Desktop
* Wenn Server mit den gleichen Namen bereits vorhanden sind, erhalten sie ein numerisches Suffix (zum Beispiel `server_1`)
MCP-Server von Claude.ai verwenden
Wenn Sie sich in Claude Code mit einem [claude.ai](https://claude.ai)-Konto angemeldet haben, sind MCP-Server, die Sie in Claude.ai hinzugefügt haben, automatisch in Claude Code verfügbar:
Fügen Sie Server unter [claude.ai/customize/connectors](https://claude.ai/customize/connectors) hinzu. Bei Team- und Enterprise-Plänen können nur Administratoren Server hinzufügen.
Führen Sie alle erforderlichen Authentifizierungsschritte in Claude.ai durch.
In Claude Code verwenden Sie den Befehl:
```text theme={null}
/mcp
```
Claude.ai-Server erscheinen in der Liste mit Indikatoren, die zeigen, dass sie von Claude.ai stammen.
Ab v2.1.161 werden Connectoren, bei denen Sie sich noch nie angemeldet haben, hinter einer Zeile `Show unused connectors` am Ende des Claude.ai-Abschnitts eingeklappt, sodass eine von der Organisation bereitgestellte Liste das Panel nicht ausfüllt. Wählen Sie die Zeile aus, um sie zu erweitern. Ein Connector, bei dem Sie sich zuvor angemeldet haben, bleibt sichtbar, auch wenn er derzeit eine erneute Authentifizierung benötigt.
Claude.ai-Connectoren werden nur abgerufen, wenn Ihre aktive [Authentifizierungsmethode](/de/authentication#authentication-precedence) Ihr Claude.ai-Abonnement ist. Sie werden nicht geladen, wenn `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, `apiKeyHelper` oder ein Drittanbieter wie Bedrock oder Vertex aktiv ist, auch wenn Sie zuvor `/login` ausgeführt haben. Wenn `/mcp` einen Connector, den Sie hinzugefügt haben, nicht auflistet, führen Sie `/status` aus, um zu bestätigen, welche Authentifizierungsmethode aktiv ist, heben Sie diese Umgebungsvariable auf oder entfernen Sie die `apiKeyHelper`-Einstellung, und führen Sie dann `/login` aus, um Ihr Claude.ai-Konto auszuwählen.
Ein Server, den Sie in Claude Code hinzugefügt haben, hat [Vorrang](#scope-hierarchy-and-precedence) vor einem Claude.ai-Connector, der auf dieselbe URL verweist. Wenn dies geschieht, listet `/mcp` den Connector als verborgen auf und zeigt, wie Sie das Duplikat entfernen können, wenn Sie lieber den Connector verwenden möchten.
Einige von Anthropic gehostete Connectoren, wie Microsoft 365, Gmail und Google Calendar, unterstützen keine lokale OAuth von Claude Code aus, da der vorgelagerte Identitätsanbieter nur die Umleitungs-URL akzeptiert, die claude.ai registriert hat. Ab v2.1.162 zeigt die Authentifizierung eines dieser Hosts in `/mcp` eine Nachricht an, die Sie anweist, es stattdessen unter Einstellungen → Connectoren auf claude.ai zu verbinden. Sobald es dort verbunden ist, erscheint der Connector automatisch in Claude Code.
Claude.ai-Connectoren deaktivieren
Um Claude.ai-MCP-Server in Claude Code zu deaktivieren, setzen Sie [`disableClaudeAiConnectors`](/de/settings#available-settings) auf `true` in einem beliebigen Einstellungsbereich:
```json theme={null}
{
"disableClaudeAiConnectors": true
}
```
Diese Einstellung verwendet Any-Source-True-Semantik: `true` in einer beliebigen Einstellungsquelle hat Vorrang. Eine eingecheckte Projekt-`.claude/settings.json` kann ein Repository von Cloud-Connectoren ausschließen, aber ein Projekt-Level-`false` kann Connectoren nicht erneut aktivieren, die ein Benutzer- oder Richtlinien-Level-`true` deaktiviert hat. Server, die explizit über `--mcp-config` übergeben werden, sind nicht betroffen.
Sie können auch die Umgebungsvariable `ENABLE_CLAUDEAI_MCP_SERVERS` auf `false` setzen, was denselben Effekt für die aktuelle Shell-Sitzung hat:
```bash theme={null}
ENABLE_CLAUDEAI_MCP_SERVERS=false claude
```
Um einzelne Claude.ai-Connectoren zu blockieren, anstatt alle zu blockieren, fügen Sie sie zu [`deniedMcpServers`](/de/managed-mcp) nach Name oder nach URL-Muster hinzu. Beispielsweise blockiert ein `serverName`-Eintrag von `"claude.ai Slack"` den Slack-Connector. Um einen Connector nur für das aktuelle Projekt ein- oder auszuschalten, verwenden Sie das `/mcp`-Panel.
Diese clientseitigen Einstellungen regeln lokale Claude Code-Sitzungen. In [Claude Code im Web](/de/claude-code-on-the-web)-Sitzungen werden Claude.ai-Connectoren vom Remote-Host bereitgestellt und kommen als explizite `--mcp-config`-Einträge an, daher gilt `disableClaudeAiConnectors` dort nicht. Connector-URLs werden auch durch den Sitzungs-Proxy umgeschrieben, daher passt ein `deniedMcpServers`-`serverUrl`-Muster, das auf die Anbieter-URL abzielt, nicht. Verwalten Sie, welche Connectoren eine Cloud-Sitzung verwenden kann, über Ihre Claude.ai-Organisationseinstellungen.
Claude Code als MCP-Server verwenden
Sie können Claude Code selbst als MCP-Server verwenden, mit dem sich andere Anwendungen verbinden können:
```bash theme={null}
# Starten Sie Claude als Stdio-MCP-Server
claude mcp serve
```
Sie können dies in Claude Desktop verwenden, indem Sie diese Konfiguration zu claude\_desktop\_config.json hinzufügen:
```json theme={null}
{
"mcpServers": {
"claude-code": {
"type": "stdio",
"command": "claude",
"args": ["mcp", "serve"],
"env": {}
}
}
}
```
**Konfigurieren Sie den Pfad der ausführbaren Datei**: Das Feld `command` muss auf die Claude Code-Ausführungsdatei verweisen. Wenn der Befehl `claude` nicht in Ihrem System-PATH vorhanden ist, müssen Sie den vollständigen Pfad zur ausführbaren Datei angeben.
Um den vollständigen Pfad zu finden:
```bash theme={null}
which claude
```
Verwenden Sie dann den vollständigen Pfad in Ihrer Konfiguration:
```json theme={null}
{
"mcpServers": {
"claude-code": {
"type": "stdio",
"command": "/full/path/to/claude",
"args": ["mcp", "serve"],
"env": {}
}
}
}
```
Ohne den korrekten Pfad der ausführbaren Datei treten Fehler wie `spawn claude ENOENT` auf.
Tipps:
* Der Server bietet Zugriff auf Claudes Tools wie View, Edit, LS usw.
* In Claude Desktop versuchen Sie, Claude aufzufordern, Dateien in einem Verzeichnis zu lesen, Änderungen vorzunehmen und mehr.
* Dieser MCP-Server stellt nur Claudes Tools für Ihren MCP-Client zur Verfügung, daher ist Ihr eigener Client dafür verantwortlich, Benutzerbestätigung für einzelne Tool-Aufrufe zu implementieren.
MCP-Ausgabelimits und Warnungen
Wenn MCP-Tools große Ausgaben erzeugen, hilft Claude Code bei der Verwaltung der Token-Nutzung, um zu verhindern, dass Ihr Gesprächskontext überwältigt wird:
* **Ausgabe-Warnungsschwelle**: Claude Code zeigt eine Warnung an, wenn eine MCP-Tool-Ausgabe 10.000 Token überschreitet
* **Konfigurierbares Limit**: Sie können die maximale zulässige MCP-Ausgabe-Token mit der Umgebungsvariablen `MAX_MCP_OUTPUT_TOKENS` anpassen
* **Standardlimit**: Das Standardmaximum beträgt 25.000 Token
* **Bereich**: Die Umgebungsvariable gilt für Tools, die kein eigenes Limit deklarieren. Tools, die [`anthropic/maxResultSizeChars`](#raise-the-limit-for-a-specific-tool) setzen, verwenden diesen Wert stattdessen für Textinhalte, unabhängig davon, auf was `MAX_MCP_OUTPUT_TOKENS` gesetzt ist. Tools, die Bilddaten zurückgeben, unterliegen immer noch `MAX_MCP_OUTPUT_TOKENS`
Um das Limit für Tools zu erhöhen, die große Ausgaben erzeugen:
```bash theme={null}
export MAX_MCP_OUTPUT_TOKENS=50000
claude
```
Dies ist besonders nützlich bei der Arbeit mit MCP-Servern, die:
* Große Datensätze oder Datenbanken abfragen
* Detaillierte Berichte oder Dokumentation generieren
* Umfangreiche Protokolldateien oder Debugging-Informationen verarbeiten
Wenn Sie einen MCP-Server erstellen, können Sie einzelnen Tools ermöglichen, Ergebnisse größer als die Standard-Persist-to-Disk-Schwelle zurückzugeben, indem Sie `_meta["anthropic/maxResultSizeChars"]` in der Tool-Antwort des `tools/list` einstellen. Claude Code erhöht die Schwelle dieses Tools auf den annotierten Wert, bis zu einer harten Obergrenze von 500.000 Zeichen.
Dies ist nützlich für Tools, die inhärent große, aber notwendige Ausgaben zurückgeben, wie Datenbankschemas oder vollständige Dateibäume. Ohne die Anmerkung werden Ergebnisse, die die Standard-Schwelle überschreiten, auf die Festplatte persistiert und durch eine Dateireferenz im Gespräch ersetzt.
```json theme={null}
{
"name": "get_schema",
"description": "Returns the full database schema",
"_meta": {
"anthropic/maxResultSizeChars": 200000
}
}
```
Die Anmerkung gilt unabhängig von `MAX_MCP_OUTPUT_TOKENS` für Textinhalte, daher müssen Benutzer die Umgebungsvariable nicht für Tools erhöhen, die sie deklarieren. Tools, die Bilddaten zurückgeben, unterliegen immer noch dem Token-Limit.
Wenn Sie häufig Ausgabewarnungen bei bestimmten MCP-Servern erhalten, die Sie nicht kontrollieren, erwägen Sie, das Limit `MAX_MCP_OUTPUT_TOKENS` zu erhöhen. Sie können auch den Server-Autor bitten, die Anmerkung `anthropic/maxResultSizeChars` hinzuzufügen oder ihre Antworten zu paginieren. Die Anmerkung hat keine Auswirkung auf Tools, die Bildinhalte zurückgeben; für diese ist das Erhöhen von `MAX_MCP_OUTPUT_TOKENS` die einzige Option.
Reagieren Sie auf MCP-Elicitierungsanfragen
MCP-Server können während einer Aufgabe strukturierte Eingaben von Ihnen anfordern, indem sie Elicitierung verwenden. Wenn ein Server Informationen benötigt, die er nicht selbst abrufen kann, zeigt Claude Code einen interaktiven Dialog an und leitet Ihre Antwort an den Server weiter. Auf Ihrer Seite ist keine Konfiguration erforderlich: Elicitierungs-Dialoge erscheinen automatisch, wenn ein Server sie anfordert.
Server können Eingaben auf zwei Arten anfordern:
* **Formularmodus**: Claude Code zeigt einen Dialog mit Formularfeldern an, die vom Server definiert werden (zum Beispiel eine Eingabeaufforderung für Benutzername und Passwort). Füllen Sie die Felder aus und senden Sie sie ab.
* **URL-Modus**: Claude Code öffnet eine Browser-URL für Authentifizierung oder Genehmigung. Führen Sie den Ablauf im Browser durch und bestätigen Sie dann in der CLI.
Um automatisch auf Elicitierungsanfragen ohne Dialog zu reagieren, verwenden Sie den [`Elicitation`-Hook](/de/hooks#elicitation).
Wenn Sie einen MCP-Server erstellen, der Elicitierung verwendet, siehe die [MCP-Elicitierungs-Spezifikation](https://modelcontextprotocol.io/docs/learn/client-concepts#elicitation) für Protokolldetails und Schema-Beispiele.
MCP-Ressourcen verwenden
MCP-Server können Ressourcen verfügbar machen, auf die Sie mit @-Erwähnungen verweisen können, ähnlich wie Sie auf Dateien verweisen.
Referenzieren Sie MCP-Ressourcen
Geben Sie `@` in Ihre Eingabeaufforderung ein, um verfügbare Ressourcen von allen verbundenen MCP-Servern anzuzeigen. Ressourcen erscheinen neben Dateien im Autocomplete-Menü.
Verwenden Sie das Format `@server:protocol://resource/path`, um auf eine Ressource zu verweisen:
```text theme={null}
Can you analyze @github:issue://123 and suggest a fix?
```
```text theme={null}
Please review the API documentation at @docs:file://api/authentication
```
Sie können mehrere Ressourcen in einer einzelnen Eingabeaufforderung referenzieren:
```text theme={null}
Compare @postgres:schema://users with @docs:file://database/user-model
```
Tipps:
* Ressourcen werden automatisch abgerufen und als Anhänge eingefügt, wenn sie referenziert werden
* Ressourcenpfade sind fuzzy-durchsuchbar im @-Erwähnungs-Autocomplete
* Claude Code stellt automatisch Tools zur Verfügung, um MCP-Ressourcen aufzulisten und zu lesen, wenn Server diese unterstützen
* Ressourcen können jeden Inhaltstyp enthalten, den der MCP-Server bereitstellt (Text, JSON, strukturierte Daten usw.)
Die Tool-Suche hält die MCP-Kontextnutzung niedrig, indem Tool-Definitionen aufgeschoben werden, bis Claude sie benötigt. Nur Tool-Namen und Server-Anweisungen werden beim Sitzungsstart geladen, daher hat das Hinzufügen weiterer MCP-Server minimale Auswirkungen auf Ihr Kontextfenster. Claude Code verhängt keine feste Tool-Obergrenze pro Server; die praktische Grenze ist Ihr Kontextfenster-Budget.
Wie es funktioniert
Die Tool-Suche ist standardmäßig aktiviert. MCP-Tools werden aufgeschoben, anstatt sie vorab in den Kontext zu laden, und Claude verwendet ein Such-Tool, um relevante Tools zu entdecken, wenn eine Aufgabe sie benötigt. Nur die Tools, die Claude tatsächlich verwendet, gelangen in den Kontext. Aus Ihrer Perspektive funktionieren MCP-Tools genau wie zuvor.
Wenn Sie schwellenwertbasiertes Laden bevorzugen, setzen Sie `ENABLE_TOOL_SEARCH=auto`, um Schemas vorab zu laden, wenn sie in 10 % des Kontextfensters passen, und verschieben Sie nur den Überschuss. Siehe [Tool-Suche konfigurieren](#configure-tool-search) für alle Optionen.
Für MCP-Server-Autoren
Wenn Sie einen MCP-Server erstellen, wird das Feld für Server-Anweisungen mit aktivierter Tool-Suche nützlicher. Server-Anweisungen helfen Claude zu verstehen, wann nach Ihren Tools gesucht werden soll, ähnlich wie [Skills](/de/skills) funktionieren.
Fügen Sie klare, aussagekräftige Server-Anweisungen hinzu, die erklären:
* Welche Kategorie von Aufgaben Ihre Tools verarbeiten
* Wann Claude nach Ihren Tools suchen sollte
* Wichtige Funktionen, die Ihr Server bietet
Claude Code schneidet Tool-Beschreibungen und Server-Anweisungen bei 2 KB ab. Halten Sie sie prägnant, um Kürzungen zu vermeiden, und platzieren Sie kritische Details am Anfang.
Die Tool-Suche ist standardmäßig aktiviert: MCP-Tools werden aufgeschoben und bei Bedarf entdeckt. Claude Code deaktiviert sie standardmäßig auf Vertex AI. Sie ist auch deaktiviert, wenn `ANTHROPIC_BASE_URL` auf einen Host von Drittanbietern verweist, da die meisten Proxys `tool_reference`-Blöcke nicht weiterleiten. Setzen Sie `ENABLE_TOOL_SEARCH` explizit fest, um eine der beiden Fallback-Einstellungen zu überschreiben.
Die Tool-Suche erfordert ein Modell, das `tool_reference`-Blöcke unterstützt. Haiku-Modelle unterstützen dies nicht. Auf Vertex AI wird die Tool-Suche für Claude Sonnet 4.5 und später sowie Claude Opus 4.5 und später unterstützt.
Steuern Sie das Verhalten der Tool-Suche mit der Umgebungsvariablen `ENABLE_TOOL_SEARCH`:
| Wert | Verhalten |
| :-------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| (nicht gesetzt) | Alle MCP-Tools werden aufgeschoben und bei Bedarf geladen. Fällt auf das Laden vorab zurück auf Vertex AI oder wenn `ANTHROPIC_BASE_URL` ein Host von Drittanbietern ist |
| `true` | Alle MCP-Tools werden aufgeschoben. Claude Code sendet den Beta-Header auch auf Vertex AI und durch Proxys. Anfragen schlagen fehl bei Vertex AI-Modellen älter als Sonnet 4.5 oder Opus 4.5 oder bei Proxys, die `tool_reference`-Blöcke nicht unterstützen |
| `auto` | Schwellenmodus: Tools werden vorab geladen, wenn sie in 10 % des Kontextfensters passen, andernfalls aufgeschoben |
| `auto:N` | Schwellenmodus mit benutzerdefiniertem Prozentsatz, wobei `N` 0-100 ist. Beispiel: `auto:5` für 5 % |
| `false` | Alle MCP-Tools werden vorab geladen, keine Verschiebung |
```bash theme={null}
# Verwenden Sie eine benutzerdefinierte 5%-Schwelle
ENABLE_TOOL_SEARCH=auto:5 claude
# Deaktivieren Sie die Tool-Suche vollständig
ENABLE_TOOL_SEARCH=false claude
```
Oder legen Sie den Wert im Feld `env` Ihrer [settings.json](/de/settings#available-settings) fest.
Sie können das `ToolSearch`-Tool auch spezifisch deaktivieren:
```json theme={null}
{
"permissions": {
"deny": ["ToolSearch"]
}
}
```
Einen Server von der Verschiebung ausnehmen
Wenn die Tools eines Servers für Claude immer sichtbar sein sollten, ohne einen Suchschritt durchzuführen, setzen Sie `alwaysLoad` in der Konfiguration dieses Servers auf `true`. Jedes Tool von diesem Server wird dann beim Sitzungsstart in den Kontext geladen, unabhängig von der Einstellung `ENABLE_TOOL_SEARCH`. Verwenden Sie dies für eine kleine Anzahl von Tools, die Claude bei jedem Durchgang benötigt, da jedes vorab geladene Tool Kontext verbraucht, der sonst für Ihr Gespräch verfügbar wäre.
Der folgende `.mcp.json`-Eintrag nimmt einen HTTP-Server von der Verschiebung aus, während andere Server aufgeschoben bleiben:
```json theme={null}
{
"mcpServers": {
"core-tools": {
"type": "http",
"url": "https://mcp.example.com/mcp",
"alwaysLoad": true
}
}
}
```
Das Feld `alwaysLoad` ist auf allen Server-Typen verfügbar und erfordert Claude Code v2.1.121 oder später. Ein MCP-Server kann auch einzelne Tools als immer geladen markieren, indem `"anthropic/alwaysLoad": true` im `_meta`-Objekt des Tools enthalten ist, was denselben Effekt nur für dieses Tool hat.
Das Setzen von `alwaysLoad: true` blockiert auch den Start, bis sich der Server verbindet, begrenzt auf das Standard-Verbindungs-Timeout von 5 Sekunden. Dies gilt auch, obwohl MCP-Startup ansonsten [standardmäßig nicht blockierend ist](/de/env-vars), da die Tools vorhanden sein müssen, wenn der erste Prompt erstellt wird. Andere Server verbinden sich weiterhin im Hintergrund.
MCP-Prompts als Befehle verwenden
MCP-Server können Prompts verfügbar machen, die in Claude Code als Befehle verfügbar werden.
Führen Sie MCP-Prompts aus
Geben Sie `/` ein, um alle verfügbaren Befehle anzuzeigen, einschließlich derer von MCP-Servern. MCP-Prompts erscheinen mit dem Format `/mcp__servername__promptname`.
```text theme={null}
/mcp__github__list_prs
```
Viele Prompts akzeptieren Argumente. Übergeben Sie sie durch Leerzeichen getrennt nach dem Befehl:
```text theme={null}
/mcp__github__pr_review 456
```
```text theme={null}
/mcp__jira__create_issue "Bug in login flow" high
```
Tipps:
* MCP-Prompts werden dynamisch von verbundenen Servern entdeckt
* Argumente werden basierend auf den definierten Parametern des Prompts analysiert
* Prompt-Ergebnisse werden direkt in das Gespräch eingefügt
* Server- und Prompt-Namen werden normalisiert, wobei Leerzeichen in Unterstriche umgewandelt werden
Verwaltete MCP-Konfiguration
Für Organisationen, die eine zentralisierte Kontrolle über MCP-Server benötigen, die Benutzer verbinden können, siehe [Verwaltete MCP-Konfiguration](/de/managed-mcp). Sie behandelt die Bereitstellung eines festen Serversatzes mit `managed-mcp.json`, die Einschränkung von Servern mit `allowedMcpServers` und `deniedMcpServers` sowie das, was Benutzer sehen, wenn ein Server blockiert ist.