Claude Code mit Tools über MCP verbinden

Claude Code kann sich über das Model Context Protocol (MCP), 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.

Was Sie mit MCP tun können

Mit verbundenen MCP-Servern können Sie Claude Code auffordern:

Funktionen aus Issue-Trackern implementieren: „Fügen Sie die in JIRA-Issue ENG-4521 beschriebene Funktion hinzu und erstellen Sie einen PR auf GitHub.”
Überwachungsdaten analysieren: „Überprüfen Sie Sentry und Statsig, um die Nutzung der in ENG-4521 beschriebenen Funktion zu überprüfen.”
Datenbanken abfragen: „Finden Sie E-Mail-Adressen von 10 zufälligen Benutzern, die die Funktion ENG-4521 verwendet haben, basierend auf unserer PostgreSQL-Datenbank.”
Designs integrieren: „Aktualisieren Sie unsere Standard-E-Mail-Vorlage basierend auf den neuen Figma-Designs, die in Slack gepostet wurden”
Workflows automatisieren: „Erstellen Sie Gmail-Entwürfe, die diese 10 Benutzer zu einer Feedback-Sitzung über die neue Funktion einladen.”

Beliebte MCP-Server

Hier sind einige häufig verwendete MCP-Server, die Sie mit Claude Code verbinden können:

Verwenden Sie MCP-Server von Drittanbietern auf eigene Gefahr – Anthropic hat die Korrektheit oder Sicherheit all dieser Server nicht überprüft. Stellen Sie sicher, dass Sie den MCP-Servern vertrauen, die Sie installieren. Seien Sie besonders vorsichtig bei der Verwendung von MCP-Servern, die nicht vertrauenswürdige Inhalte abrufen könnten, da diese Sie dem Risiko von Prompt-Injection aussetzen können.

Benötigen Sie eine bestimmte Integration? Finden Sie Hunderte weitere MCP-Server auf GitHub, oder erstellen Sie Ihren eigenen mit dem MCP SDK.

MCP-Server installieren

MCP-Server können je nach Ihren Anforderungen auf drei verschiedene 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 verbreitete Transport für Cloud-basierte Dienste.

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

# 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"

Option 2: Einen Remote-SSE-Server hinzufügen

Der SSE-Transport (Server-Sent Events) ist veraltet. Verwenden Sie stattdessen HTTP-Server, wo verfügbar.

# Grundlegende Syntax
claude mcp add --transport sse <name> <url>

# 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.

# Grundlegende Syntax
claude mcp add [options] <name> -- <command> [args...]

# Echtes Beispiel: Airtable-Server hinzufügen
claude mcp add --transport stdio --env AIRTABLE_API_KEY=YOUR_KEY airtable \
  -- npx -y airtable-mcp-server

Wichtig: Reihenfolge der OptionenAlle Optionen (--transport, --env, --scope, --header) müssen vor dem Servernamen stehen. Der -- (Doppelstrich) trennt dann den Servernamen von dem Befehl und den Argumenten, die an den MCP-Server übergeben werden.Zum Beispiel:

claude mcp add --transport stdio myserver -- npx server → führt npx server aus
claude mcp add --transport stdio --env KEY=value myserver -- python server.py --port 8080 → führt python server.py --port 8080 mit KEY=value in der Umgebung aus

Dies verhindert Konflikte zwischen Claudes Flags und den Flags des Servers.

Verwalten Sie Ihre Server

Nach der Konfiguration können Sie Ihre MCP-Server mit diesen Befehlen verwalten:

# 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

Dynamische Tool-Updates

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.

Tipps:

Verwenden Sie das Flag --scope, um anzugeben, wo die Konfiguration gespeichert wird:
- local (Standard): Nur für Sie im aktuellen Projekt verfügbar (hieß in älteren Versionen project)
- project: Geteilt mit allen im Projekt über die Datei .mcp.json
- user: Für Sie über alle Projekte hinweg verfügbar (hieß in älteren Versionen global)
Legen Sie Umgebungsvariablen mit --env-Flags fest (zum Beispiel --env KEY=value)
Konfigurieren Sie das MCP-Server-Startup-Timeout mit der Umgebungsvariable MCP_TIMEOUT (zum Beispiel MCP_TIMEOUT=10000 claude setzt ein 10-Sekunden-Timeout)
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

Windows-Benutzer: Auf nativem Windows (nicht WSL) erfordern lokale MCP-Server, die npx verwenden, den cmd /c-Wrapper, um eine ordnungsgemäße Ausführung zu gewährleisten.

# Dies erstellt command="cmd", das Windows ausführen kann
claude mcp add --transport stdio my-server -- cmd /c npx -y @some/package

Ohne den cmd /c-Wrapper treten Fehler wie „Connection closed” auf, da Windows npx nicht direkt ausführen kann. (Siehe die obige Anmerkung für eine Erklärung des ---Parameters.)

Von Plugins bereitgestellte MCP-Server

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:

{
  "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:

{
  "name": "my-plugin",
  "mcpServers": {
    "plugin-api": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/api-server",
      "args": ["--port", "8080"]
    }
  }
}

Plugin-MCP-Funktionen:

Automatischer Lebenszyklus: Server starten, wenn das Plugin aktiviert wird, aber Sie müssen Claude Code neu starten, um MCP-Server-Änderungen anzuwenden (Aktivierung oder Deaktivierung)
Umgebungsvariablen: Verwenden Sie ${CLAUDE_PLUGIN_ROOT} für Plugin-relative Pfade
Zugriff auf Benutzerumgebung: Zugriff auf die gleichen Umgebungsvariablen wie manuell konfigurierte Server
Mehrere Transport-Typen: Unterstützung für Stdio-, SSE- und HTTP-Transporte (die Transport-Unterstützung kann je nach Server variieren)

Anzeigen von Plugin-MCP-Servern:

# Innerhalb von Claude Code, siehe alle MCP-Server einschließlich Plugin-Server
/mcp

Plugin-Server erscheinen in der Liste mit Indikatoren, die zeigen, dass sie von Plugins stammen. Vorteile von Plugin-MCP-Servern:

Gebündelte Verteilung: Tools und Server zusammen verpackt
Automatische Einrichtung: Keine manuelle MCP-Konfiguration erforderlich
Team-Konsistenz: Jeder erhält die gleichen Tools, wenn das Plugin installiert ist

Siehe die Plugin-Komponenten-Referenz für Details zum Bündeln von MCP-Servern mit Plugins.

MCP-Installationsbereiche

MCP-Server können auf drei verschiedenen Bereichsebenen konfiguriert werden, die jeweils unterschiedliche Zwecke für die Verwaltung der Serverzugänglichkeit und des Austauschs erfüllen. Das Verständnis dieser Bereiche hilft Ihnen, die beste Methode zur Konfiguration von Servern für Ihre spezifischen Anforderungen zu bestimmen.

Lokaler Bereich

Lokal begrenzte Server stellen die Standard-Konfigurationsebene dar und werden in ~/.claude.json unter dem Pfad Ihres Projekts gespeichert. Diese Server bleiben privat für Sie und sind nur zugänglich, wenn Sie im aktuellen Projektverzeichnis arbeiten. Dieser Bereich ist ideal für persönliche Entwicklungsserver, experimentelle Konfigurationen oder Server, die vertrauliche Anmeldedaten enthalten, die nicht geteilt werden sollten.

# 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

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.

# 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:

{
  "mcpServers": {
    "shared-server": {
      "command": "/path/to/server",
      "args": [],
      "env": {}
    }
  }
}

Aus Sicherheitsgründen fordert Claude Code eine Genehmigung auf, 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.

# Einen Benutzer-Server hinzufügen
claude mcp add --transport http hubspot --scope user https://mcp.hubspot.com/anthropic

Den richtigen Bereich wählen

Wählen Sie Ihren Bereich basierend auf:

Lokaler Bereich: Persönliche Server, experimentelle Konfigurationen oder vertrauliche Anmeldedaten, die für ein Projekt spezifisch sind
Projektbereich: Team-gemeinsame Server, projektspezifische Tools oder Dienste, die für die Zusammenarbeit erforderlich sind
Benutzerbereich: Persönliche Utilities, die über mehrere Projekte hinweg benötigt werden, Entwicklungstools oder häufig verwendete Dienste

Wo werden MCP-Server gespeichert?

Benutzer- und lokaler Bereich: ~/.claude.json (im Feld mcpServers oder unter Projektpfaden)
Projektbereich: .mcp.json im Projekt-Root (eingecheckt in die Versionskontrolle)
Verwaltet: managed-mcp.json in Systemverzeichnissen (siehe Verwaltete MCP-Konfiguration)

Bereichshierarchie und Vorrang

MCP-Server-Konfigurationen folgen einer klaren Vorranghierarchie. Wenn Server mit dem gleichen Namen auf mehreren Bereichen vorhanden sind, löst das System Konflikte auf, indem es lokal begrenzte Server zuerst priorisiert, gefolgt von projektbegrenzten Servern und schließlich benutzerbegrenzten Servern. Dieses Design stellt sicher, dass persönliche Konfigurationen gemeinsame Konfigurationen bei Bedarf überschreiben können.

Umgebungsvariablenerweiterung in `.mcp.json`

Claude Code unterstützt die Umgebungsvariablenerweiterung 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 Umgebungsvariable 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:

{
  "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

# 1. Fügen Sie den Sentry MCP-Server hinzu
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

# 2. Verwenden Sie /mcp, um sich mit Ihrem Sentry-Konto zu authentifizieren
> /mcp

# 3. Debuggen Sie Produktionsprobleme
> "What are the most common errors in the last 24 hours?"
> "Show me the stack trace for error ID abc123"
> "Which deployment introduced these new errors?"

Beispiel: Mit GitHub für Code-Reviews verbinden

# 1. Fügen Sie den GitHub MCP-Server hinzu
claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# 2. In Claude Code, authentifizieren Sie sich bei Bedarf
> /mcp
# Wählen Sie „Authenticate" für GitHub

# 3. Jetzt können Sie Claude auffordern, mit GitHub zu arbeiten
> "Review PR #456 and suggest improvements"
> "Create a new issue for the bug we just found"
> "Show me all open PRs assigned to me"

Beispiel: Ihre PostgreSQL-Datenbank abfragen

# 1. Fügen Sie den Datenbankserver mit Ihrer Verbindungszeichenfolge hinzu
claude mcp add --transport stdio db -- npx -y @bytebase/dbhub \
  --dsn "postgresql://readonly:[email protected]:5432/analytics"

# 2. Fragen Sie Ihre Datenbank natürlich ab
> "What's our total revenue this month?"
> "Show me the schema for the orders table"
> "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.

Fügen Sie den Server hinzu, der Authentifizierung erfordert

Zum Beispiel:

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

Verwenden Sie den /mcp-Befehl innerhalb von Claude Code

In Claude Code verwenden Sie den Befehl:

> /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
OAuth-Authentifizierung funktioniert mit HTTP-Servern

MCP-Server aus JSON-Konfiguration hinzufügen

Wenn Sie eine JSON-Konfiguration für einen MCP-Server haben, können Sie diese direkt hinzufügen:

Fügen Sie einen MCP-Server aus JSON hinzu

# Grundlegende Syntax
claude mcp add-json <name> '<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"}}'

Überprüfen Sie, ob der Server hinzugefügt wurde

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 hinzuzufügen, anstatt zur projektspezifischen

MCP-Server aus Claude Desktop importieren

Wenn Sie bereits MCP-Server in Claude Desktop konfiguriert haben, können Sie diese importieren:

Importieren Sie Server aus Claude Desktop

# Grundlegende Syntax 
claude mcp add-from-claude-desktop 

Wählen Sie aus, welche Server importiert werden sollen

Nach dem Ausführen des Befehls wird ein interaktiver Dialog angezeigt, mit dem Sie auswählen können, welche Server Sie importieren möchten.

Überprüfen Sie, ob die Server importiert wurden

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)

Claude Code als MCP-Server verwenden

Sie können Claude Code selbst als MCP-Server verwenden, mit dem sich andere Anwendungen verbinden können:

# 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:

{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}

Konfigurieren des ausführbaren Pfads: Das Feld command muss auf die Claude Code-Ausführungsdatei verweisen. Wenn der Befehl claude nicht in Ihrem System-PATH ist, müssen Sie den vollständigen Pfad zur Ausführungsdatei angeben.Um den vollständigen Pfad zu finden:

which claude

Verwenden Sie dann den vollständigen Pfad in Ihrer Konfiguration:

{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "/full/path/to/claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}

Ohne den korrekten ausführbaren Pfad 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.
Beachten Sie, dass dieser MCP-Server nur Claudes Tools Ihrem MCP-Client bereitstellt, 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 Umgebungsvariable MAX_MCP_OUTPUT_TOKENS anpassen
Standardlimit: Das Standardmaximum beträgt 25.000 Token

Um das Limit für Tools zu erhöhen, die große Ausgaben erzeugen:

# Legen Sie ein höheres Limit für MCP-Tool-Ausgaben fest
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 häufig Ausgabewarnungen mit bestimmten MCP-Servern erhalten, sollten Sie das Limit erhöhen oder den Server so konfigurieren, dass er seine Antworten paginiert oder filtert.

MCP-Ressourcen verwenden

MCP-Server können Ressourcen bereitstellen, auf die Sie mit @ Erwähnungen verweisen können, ähnlich wie Sie auf Dateien verweisen.

MCP-Ressourcen referenzieren

Verfügbare Ressourcen auflisten

Geben Sie @ in Ihre Eingabeaufforderung ein, um verfügbare Ressourcen von allen verbundenen MCP-Servern anzuzeigen. Ressourcen erscheinen neben Dateien im Autocomplete-Menü.

Eine bestimmte Ressource referenzieren

Verwenden Sie das Format @server:protocol://resource/path, um auf eine Ressource zu verweisen:

> Can you analyze @github:issue://123 and suggest a fix?

> Please review the API documentation at @docs:file://api/authentication

Mehrere Ressourcenreferenzen

Sie können mehrere Ressourcen in einer einzigen Eingabeaufforderung referenzieren:

> 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 zum Auflisten und Lesen von MCP-Ressourcen bereit, wenn Server diese unterstützen
Ressourcen können jeden Inhaltstyp enthalten, den der MCP-Server bereitstellt (Text, JSON, strukturierte Daten usw.)

MCP-Prompts als Slash-Befehle verwenden

MCP-Server können Prompts bereitstellen, die als Slash-Befehle in Claude Code verfügbar werden.

MCP-Prompts ausführen

Verfügbare Prompts entdecken

Geben Sie / ein, um alle verfügbaren Befehle anzuzeigen, einschließlich derjenigen von MCP-Servern. MCP-Prompts erscheinen mit dem Format /mcp__servername__promptname.

Einen Prompt ohne Argumente ausführen

> /mcp__github__list_prs

Einen Prompt mit Argumenten ausführen

Viele Prompts akzeptieren Argumente. Übergeben Sie sie durch Leerzeichen getrennt nach dem Befehl:

> /mcp__github__pr_review 456

> /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 (Leerzeichen werden zu Unterstrichen)

Verwaltete MCP-Konfiguration

Für Organisationen, die eine zentralisierte Kontrolle über MCP-Server benötigen, unterstützt Claude Code zwei Konfigurationsoptionen:

Exklusive Kontrolle mit managed-mcp.json: Stellen Sie einen festen Satz von MCP-Servern bereit, die Benutzer nicht ändern oder erweitern können
Richtlinienbasierte Kontrolle mit Allowlists/Denylists: Ermöglichen Sie Benutzern, ihre eigenen Server hinzuzufügen, aber beschränken Sie, welche zulässig sind

Diese Optionen ermöglichen es IT-Administratoren:

Zu kontrollieren, auf welche MCP-Server Mitarbeiter zugreifen können: Stellen Sie einen standardisierten Satz genehmigter MCP-Server in der gesamten Organisation bereit
Unbefugte MCP-Server zu verhindern: Beschränken Sie Benutzer daran, nicht genehmigte MCP-Server hinzuzufügen
MCP vollständig zu deaktivieren: Entfernen Sie die MCP-Funktionalität vollständig, falls erforderlich

Option 1: Exklusive Kontrolle mit managed-mcp.json

Wenn Sie eine managed-mcp.json-Datei bereitstellen, übernimmt sie exklusive Kontrolle über alle MCP-Server. Benutzer können keine MCP-Server außer denen, die in dieser Datei definiert sind, hinzufügen, ändern oder verwenden. Dies ist der einfachste Ansatz für Organisationen, die vollständige Kontrolle wünschen. Systemadministratoren stellen die Konfigurationsdatei in einem systemweiten Verzeichnis bereit:

macOS: /Library/Application Support/ClaudeCode/managed-mcp.json
Linux und WSL: /etc/claude-code/managed-mcp.json
Windows: C:\Program Files\ClaudeCode\managed-mcp.json

Dies sind systemweite Pfade (nicht Benutzer-Home-Verzeichnisse wie ~/Library/...), die Administratorrechte erfordern. Sie sind dazu bestimmt, von IT-Administratoren bereitgestellt zu werden.

Die managed-mcp.json-Datei verwendet das gleiche Format wie eine Standard-.mcp.json-Datei:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    },
    "company-internal": {
      "type": "stdio",
      "command": "/usr/local/bin/company-mcp-server",
      "args": ["--config", "/etc/company/mcp-config.json"],
      "env": {
        "COMPANY_API_URL": "https://internal.company.com"
      }
    }
  }
}

Option 2: Richtlinienbasierte Kontrolle mit Allowlists und Denylists

Anstatt exklusive Kontrolle zu übernehmen, können Administratoren Benutzern erlauben, ihre eigenen MCP-Server zu konfigurieren, während sie Einschränkungen für zulässige Server durchsetzen. Dieser Ansatz verwendet allowedMcpServers und deniedMcpServers in der verwalteten Einstellungsdatei.

Wahl zwischen Optionen: Verwenden Sie Option 1 (managed-mcp.json), wenn Sie einen festen Satz von Servern ohne Benutzeranpassung bereitstellen möchten. Verwenden Sie Option 2 (Allowlists/Denylists), wenn Sie Benutzern erlauben möchten, ihre eigenen Server unter Richtlinienbeschränkungen hinzuzufügen.

Einschränkungsoptionen

Jeder Eintrag in der Allowlist oder Denylist kann Server auf drei Arten einschränken:

Nach Servername (serverName): Passt den konfigurierten Namen des Servers an
Nach Befehl (serverCommand): Passt den genauen Befehl und die Argumente an, die zum Starten von Stdio-Servern verwendet werden
Nach URL-Muster (serverUrl): Passt Remote-Server-URLs mit Wildcard-Unterstützung an

Wichtig: Jeder Eintrag muss genau eines von serverName, serverCommand oder serverUrl haben.

Beispielkonfiguration

{
  "allowedMcpServers": [
    // Nach Servername zulassen
    { "serverName": "github" },
    { "serverName": "sentry" },

    // Nach genauem Befehl zulassen (für Stdio-Server)
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem"] },
    { "serverCommand": ["python", "/usr/local/bin/approved-server.py"] },

    // Nach URL-Muster zulassen (für Remote-Server)
    { "serverUrl": "https://mcp.company.com/*" },
    { "serverUrl": "https://*.internal.corp/*" }
  ],
  "deniedMcpServers": [
    // Nach Servername blockieren
    { "serverName": "dangerous-server" },

    // Nach genauem Befehl blockieren (für Stdio-Server)
    { "serverCommand": ["npx", "-y", "unapproved-package"] },

    // Nach URL-Muster blockieren (für Remote-Server)
    { "serverUrl": "https://*.untrusted.com/*" }
  ]
}

Wie befehlsbasierte Einschränkungen funktionieren

Genaue Übereinstimmung:

Befehlsarrays müssen genau übereinstimmen – sowohl der Befehl als auch alle Argumente in der richtigen Reihenfolge
Beispiel: ["npx", "-y", "server"] passt NICHT zu ["npx", "server"] oder ["npx", "-y", "server", "--flag"]

Stdio-Server-Verhalten:

Wenn die Allowlist irgendwelche serverCommand-Einträge enthält, müssen Stdio-Server einem dieser Befehle entsprechen
Stdio-Server können nicht nur nach Name bestehen, wenn Befehlsbeschränkungen vorhanden sind
Dies stellt sicher, dass Administratoren erzwingen können, welche Befehle ausgeführt werden dürfen

Nicht-Stdio-Server-Verhalten:

Remote-Server (HTTP, SSE, WebSocket) verwenden URL-basierte Übereinstimmung, wenn serverUrl-Einträge in der Allowlist vorhanden sind
Wenn keine URL-Einträge vorhanden sind, fallen Remote-Server auf namensbasierte Übereinstimmung zurück
Befehlsbeschränkungen gelten nicht für Remote-Server

Wie URL-basierte Einschränkungen funktionieren

URL-Muster unterstützen Wildcards mit *, um eine beliebige Zeichenfolge zu entsprechen. Dies ist nützlich, um ganze Domänen oder Subdomänen zuzulassen. Wildcard-Beispiele:

https://mcp.company.com/* - Alle Pfade auf einer bestimmten Domäne zulassen
https://*.example.com/* - Jede Subdomain von example.com zulassen
http://localhost:*/* - Jeden Port auf localhost zulassen

Remote-Server-Verhalten:

Wenn die Allowlist irgendwelche serverUrl-Einträge enthält, müssen Remote-Server einem dieser URL-Muster entsprechen
Remote-Server können nicht nur nach Name bestehen, wenn URL-Beschränkungen vorhanden sind
Dies stellt sicher, dass Administratoren erzwingen können, welche Remote-Endpunkte zulässig sind

Beispiel: URL-only Allowlist

{
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.company.com/*" },
    { "serverUrl": "https://*.internal.corp/*" }
  ]
}

Ergebnis:

HTTP-Server unter https://mcp.company.com/api: ✅ Zulässig (passt URL-Muster)
HTTP-Server unter https://api.internal.corp/mcp: ✅ Zulässig (passt Wildcard-Subdomain)
HTTP-Server unter https://external.com/mcp: ❌ Blockiert (passt kein URL-Muster)
Stdio-Server mit beliebigem Befehl: ❌ Blockiert (keine Namen- oder Befehlseinträge zum Abgleichen)

Beispiel: Command-only Allowlist

{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}

Ergebnis:

Stdio-Server mit ["npx", "-y", "approved-package"]: ✅ Zulässig (passt Befehl)
Stdio-Server mit ["node", "server.js"]: ❌ Blockiert (passt Befehl nicht)
HTTP-Server namens „my-api”: ❌ Blockiert (keine Namenseinträge zum Abgleichen)

Beispiel: Gemischte Namen- und Befehlsallowlist

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}

Ergebnis:

Stdio-Server namens „local-tool” mit ["npx", "-y", "approved-package"]: ✅ Zulässig (passt Befehl)
Stdio-Server namens „local-tool” mit ["node", "server.js"]: ❌ Blockiert (Befehlseinträge vorhanden, aber passt nicht)
Stdio-Server namens „github” mit ["node", "server.js"]: ❌ Blockiert (Stdio-Server müssen Befehlen entsprechen, wenn Befehlseinträge vorhanden sind)
HTTP-Server namens „github”: ✅ Zulässig (passt Name)
HTTP-Server namens „other-api”: ❌ Blockiert (Name passt nicht)

Beispiel: Name-only Allowlist

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "internal-tool" }
  ]
}

Ergebnis:

Stdio-Server namens „github” mit beliebigem Befehl: ✅ Zulässig (keine Befehlsbeschränkungen)
Stdio-Server namens „internal-tool” mit beliebigem Befehl: ✅ Zulässig (keine Befehlsbeschränkungen)
HTTP-Server namens „github”: ✅ Zulässig (passt Name)
Beliebiger Server namens „other”: ❌ Blockiert (Name passt nicht)

Allowlist-Verhalten (`allowedMcpServers`)

undefined (Standard): Keine Einschränkungen – Benutzer können beliebige MCP-Server konfigurieren
Leeres Array []: Vollständige Sperrung – Benutzer können keine MCP-Server konfigurieren
Liste von Einträgen: Benutzer können nur Server konfigurieren, die nach Name, Befehl oder URL-Muster übereinstimmen

Denylist-Verhalten (`deniedMcpServers`)

undefined (Standard): Keine Server sind blockiert
Leeres Array []: Keine Server sind blockiert
Liste von Einträgen: Angegebene Server sind explizit über alle Bereiche hinweg blockiert

Wichtige Hinweise

Option 1 und Option 2 können kombiniert werden: Wenn managed-mcp.json vorhanden ist, hat es exklusive Kontrolle und Benutzer können keine Server hinzufügen. Allowlists/Denylists gelten weiterhin für die verwalteten Server selbst.
Denylist hat absoluten Vorrang: Wenn ein Server einem Denylist-Eintrag entspricht (nach Name, Befehl oder URL), wird er blockiert, auch wenn er auf der Allowlist ist
Name-, Befehl- und URL-basierte Einschränkungen funktionieren zusammen: Ein Server besteht, wenn er einem Namenseintrag, einem Befehlseintrag oder einem URL-Muster entspricht (es sei denn, er ist durch Denylist blockiert)

Bei Verwendung von managed-mcp.json: Benutzer können MCP-Server nicht über claude mcp add oder Konfigurationsdateien hinzufügen. Die Einstellungen allowedMcpServers und deniedMcpServers gelten weiterhin, um zu filtern, welche verwalteten Server tatsächlich geladen werden.

Mit Claude Code entwickeln

​Was Sie mit MCP tun können

​Beliebte MCP-Server

​MCP-Server installieren

​Option 1: Einen Remote-HTTP-Server hinzufügen

​Option 2: Einen Remote-SSE-Server hinzufügen

​Option 3: Einen lokalen Stdio-Server hinzufügen

​Verwalten Sie Ihre Server

​Dynamische Tool-Updates

​Von Plugins bereitgestellte MCP-Server

​MCP-Installationsbereiche

​Lokaler Bereich

​Projektbereich

​Benutzerbereich

​Den richtigen Bereich wählen

​Bereichshierarchie und Vorrang

​Umgebungsvariablenerweiterung in .mcp.json

​Praktische Beispiele

​Beispiel: Fehler mit Sentry überwachen

​Beispiel: Mit GitHub für Code-Reviews verbinden

​Beispiel: Ihre PostgreSQL-Datenbank abfragen

​Mit Remote-MCP-Servern authentifizieren

​MCP-Server aus JSON-Konfiguration hinzufügen

​MCP-Server aus Claude Desktop importieren

​Claude Code als MCP-Server verwenden

​MCP-Ausgabelimits und Warnungen

​MCP-Ressourcen verwenden

​MCP-Ressourcen referenzieren

​MCP-Prompts als Slash-Befehle verwenden

​MCP-Prompts ausführen

​Verwaltete MCP-Konfiguration

​Option 1: Exklusive Kontrolle mit managed-mcp.json

​Option 2: Richtlinienbasierte Kontrolle mit Allowlists und Denylists

​Einschränkungsoptionen

​Beispielkonfiguration

​Wie befehlsbasierte Einschränkungen funktionieren

​Wie URL-basierte Einschränkungen funktionieren

​Allowlist-Verhalten (allowedMcpServers)

​Denylist-Verhalten (deniedMcpServers)

​Wichtige Hinweise

Was Sie mit MCP tun können

Beliebte MCP-Server

MCP-Server installieren

Option 1: Einen Remote-HTTP-Server hinzufügen

Option 2: Einen Remote-SSE-Server hinzufügen

Option 3: Einen lokalen Stdio-Server hinzufügen

Verwalten Sie Ihre Server

Dynamische Tool-Updates

Von Plugins bereitgestellte MCP-Server

MCP-Installationsbereiche

Lokaler Bereich

Projektbereich

Benutzerbereich

Den richtigen Bereich wählen

Bereichshierarchie und Vorrang

Umgebungsvariablenerweiterung in `.mcp.json`

Praktische Beispiele

Beispiel: Fehler mit Sentry überwachen

Beispiel: Mit GitHub für Code-Reviews verbinden

Beispiel: Ihre PostgreSQL-Datenbank abfragen

Mit Remote-MCP-Servern authentifizieren

MCP-Server aus JSON-Konfiguration hinzufügen

MCP-Server aus Claude Desktop importieren

Claude Code als MCP-Server verwenden

MCP-Ausgabelimits und Warnungen

MCP-Ressourcen verwenden

MCP-Ressourcen referenzieren

MCP-Prompts als Slash-Befehle verwenden

MCP-Prompts ausführen

Verwaltete MCP-Konfiguration

Option 1: Exklusive Kontrolle mit managed-mcp.json

Option 2: Richtlinienbasierte Kontrolle mit Allowlists und Denylists

Einschränkungsoptionen

Beispielkonfiguration

Wie befehlsbasierte Einschränkungen funktionieren

Wie URL-basierte Einschränkungen funktionieren

Allowlist-Verhalten (`allowedMcpServers`)

Denylist-Verhalten (`deniedMcpServers`)

Wichtige Hinweise