> ## Documentation Index
> Fetch the complete documentation index at: https://docs.windsurf.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Model Context Protocol (MCP)

> Konfigurieren Sie MCP-Server, um Cascade mit benutzerdefinierten Tools und Diensten über stdio-, HTTP- oder SSE-Transporte zu erweitern, mit Admin-Steuerelementen für Teams und Enterprise.

**MCP (Model Context Protocol)** ist ein Protokoll, das LLMs den Zugriff auf eigene Tools und Dienste ermöglicht.
Ein MCP-Client (hier: Cascade) kann Anfragen an MCP-Server stellen, um auf die von ihnen bereitgestellten Tools zuzugreifen.
Cascade integriert MCP nun nativ, sodass Sie eine eigene Auswahl an MCP-Servern für die Nutzung durch Cascade einbinden können.
Weitere Informationen finden Sie in der [offiziellen MCP-Dokumentation](https://modelcontextprotocol.io/).

<Note>Enterprise-Nutzer müssen dies in den Einstellungen manuell aktivieren</Note>

<div id="adding-a-new-mcp-plugin">
  ## Hinzufügen eines neuen MCP-Plugins
</div>

Neue MCP-Plugins fügen Sie hinzu, indem Sie zu `Settings` > `Tools` > `Windsurf Settings` > `Add Server` navigieren.

Wenn das gewünschte MCP-Plugin nicht aufgeführt ist, können Sie es manuell hinzufügen, indem Sie auf die Schaltfläche `View Raw Config` klicken und die Rohdatei `mcp_config.json` bearbeiten.

Wenn Sie einen MCP-Server auswählen, klicken Sie einfach auf `+ Add Server`, um den Server und seine Tools in Cascade verfügbar zu machen.

<Frame>
  <img src="https://mintcdn.com/codeium/d8O4q6w3H2CjrirL/assets/plugins/mcp-server-templates.jpg?fit=max&auto=format&n=d8O4q6w3H2CjrirL&q=85&s=06f96424bd8374333d6969006868456e" width="1666" height="1388" data-path="assets/plugins/mcp-server-templates.jpg" />
</Frame>

Cascade unterstützt drei [Transporttypen](https://modelcontextprotocol.io/docs/concepts/transports) für MCP-Server: `stdio`, `Streamable HTTP` und `SSE`.

Cascade unterstützt außerdem OAuth für jeden Transporttyp.

Für `http`-Server sollte die URL dem Endpunkt entsprechen und etwa so aussehen: `https://<your-server-url>/mcp`.

<Note>Stellen Sie sicher, dass Sie nach dem Hinzufügen eines neuen MCP-Plugins die Aktualisieren-Schaltfläche drücken.</Note>

<div id="mcp_configjson">
  ## mcp\_config.json
</div>

Die Datei `~/.codeium/mcp_config.json` ist eine JSON-Datei, die eine Liste von Servern enthält, zu denen sich Cascade verbinden kann.

Hier ist eine Beispielkonfiguration, die einen einzelnen Server für GitHub einrichtet:

```json theme={null}
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<IHR_PERSÖNLICHES_ZUGANGSTOKEN>"
      }
    }
  }
}
```

Stelle sicher, dass du die erforderlichen Argumente und Umgebungsvariablen für die Server angibst, die du verwenden möchtest.

Siehe das [offizielle MCP-Server-Referenz‑Repository](https://github.com/modelcontextprotocol/servers) oder [OpenTools](https://opentools.com/) für einige Beispielserver.

<div id="remote-http-mcps">
  ### Remote HTTP-MCPs
</div>

Es ist wichtig zu beachten, dass die Konfiguration für Remote-HTTP-MCPs leicht abweicht und ein Feld `serverUrl` oder `url` erfordert.

Hier ist eine Beispielkonfiguration für einen HTTP-Server:

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<ihre-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}
```

<div id="config-interpolation">
  ### Konfigurationsinterpolation
</div>

Die Datei `~/.codeium/mcp_config.json` führt die Interpolation von
Umgebungsvariablen in folgenden Feldern durch: `command`, `args`, `env`, `serverUrl`, `url` und
`headers`.

Hier ist eine Beispielkonfiguration, die die Umgebungsvariable `AUTH_TOKEN`
in `headers` verwendet.

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "Bearer ${env:AUTH_TOKEN}"
      }
    }
  }
}
```

<div id="admin-controls-teams-enterprises">
  ## Admin-Kontrollen (Teams & Enterprise)
</div>

Team-Admins können den MCP-Zugriff für ihr Team ein- und ausschalten und eine Allowlist zugelassener MCP-Server verwalten, die dein Team verwenden kann:

<Card title="MCP-Team-Einstellungen" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Anpassbare MCP-Einstellungen für dein Team.
</Card>

<Warning>Der obige Link funktioniert nur, wenn du Admin-Berechtigungen für dein Team hast.</Warning>

Standardmäßig können Nutzer innerhalb eines Teams ihre eigenen MCP-Server konfigurieren. Sobald du jedoch auch nur einen einzigen MCP-Server auf die Allowlist setzt, werden **alle nicht auf der Allowlist stehenden Server** für dein Team blockiert.

<div id="how-server-matching-works">
  ### Funktionsweise des Server-Matchings
</div>

Wenn Sie einen MCP-Server auf die Allowlist setzen, verwendet das System **Regex-Musterabgleich** mit den folgenden Regeln:

* **Vollständiger Zeichenfolgenabgleich**: Alle Muster werden automatisch verankert (mit `^(?:pattern)$` umschlossen), um Teiltreffer zu verhindern
* **Command-Feld**: Muss exakt übereinstimmen oder gemäß Ihrem Regex-Muster
* **Arguments-Array**: Jedes Argument wird einzeln mit seinem entsprechenden Muster abgeglichen
* **Array-Länge**: Die Anzahl der Argumente muss zwischen Allowlist und Benutzerkonfiguration exakt übereinstimmen
* **Sonderzeichen**: Zeichen wie `$`, `.`, `[`, `]`, `(`, `)` haben in Regex eine besondere Bedeutung und sollten mit `\` escaped werden, wenn Sie eine wörtliche Übereinstimmung wünschen

<div id="configuration-options">
  ### Konfigurationsoptionen
</div>

<AccordionGroup>
  <Accordion title="Option 1: Standard aus dem Plugin-Store (empfohlen)" description="Lassen Sie das Feld Server Config (JSON) leer, um die Standardkonfiguration aus dem Windsurf MCP Plugin Store zu verwenden.">
    **Admin-Whitelist-Konfiguration:**

    * **Server-ID**: `github-mcp-server`
    * **Server Config (JSON)**: *(leer lassen)*

    ```json theme={null}
    {}
    ```

    **Passende Benutzerkonfiguration (`mcp_config.json`):**

    ```json theme={null}
    {
      "mcpServers": {
        "github-mcp-server": {
          "command": "docker",
          "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
          }
        }
      }
    }
    ```

    So können Nutzer den GitHub-MCP-Server mit jeder gültigen Konfiguration installieren, solange die Server-ID mit dem Eintrag im Plugin-Store übereinstimmt.
  </Accordion>

  <Accordion title="Option 2: Exakte Übereinstimmung" description="Geben Sie die genaue Konfiguration vor, die Nutzer verwenden müssen. Diese Konfiguration muss exakt eingehalten werden.">
    **Admin-Whitelist-Konfiguration:**

    * **Server-ID**: `github-mcp-server`
    * **Server Config (JSON)**:

    ```json theme={null}
    {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": ""
      }
    }
    ```

    **Passende Benutzerkonfiguration (`mcp_config.json`):**

    ```json theme={null}
    {
      "mcpServers": {
        "github-mcp-server": {
          "command": "docker",
          "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
          }
        }
      }
    }
    ```

    Nutzer müssen genau diese Konfiguration verwenden – jede Abweichung bei command oder args wird blockiert. Der Abschnitt `env` kann unterschiedliche Werte enthalten.
  </Accordion>

  <Accordion title="Option 3: Flexible Regex-Muster" description="Verwenden Sie Regex-Muster, um Variationen in Benutzerkonfigurationen zuzulassen und gleichzeitig Sicherheitskontrollen beizubehalten.">
    **Admin-Whitelist-Konfiguration:**

    * **Server-ID**: `python-mcp-server`
    * **Server Config (JSON)**:

    ```json theme={null}
    {
      "command": "python3",
      "args": ["/.*\\.py", "--port", "[0-9]+"]
    }
    ```

    **Passende Benutzerkonfiguration (`mcp_config.json`):**

    ```json theme={null}
    {
      "mcpServers": {
        "python-mcp-server": {
          "command": "python3",
          "args": ["/home/user/my_server.py", "--port", "8080"],
          "env": {
            "PYTHONPATH": "/home/user/mcp"
          }
        }
      }
    }
    ```

    Dieses Beispiel bietet Nutzern Flexibilität bei gleichzeitiger Wahrung der Sicherheit:

    * Der Regex `/.*\\.py` passt auf jeden Python-Dateipfad wie `/home/user/my_server.py`
    * Der Regex `[0-9]+` passt auf jeden numerischen Port wie `8080` oder `3000`
    * Nutzer können Dateipfade und Ports anpassen, während Admins sicherstellen, dass nur Python-Skripte ausgeführt werden
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Häufige Regex-Muster
</div>

| Muster          | Entspricht                   | Beispiel                   |
| --------------- | ---------------------------- | -------------------------- |
| `.*`            | Beliebige Zeichenfolge       | `/home/user/script.py`     |
| `[0-9]+`        | Beliebige Zahl               | `8080`, `3000`             |
| `[a-zA-Z0-9_]+` | Alphanumerisch + Unterstrich | `api_key_123`              |
| `\\$HOME`       | Wörtliches `$HOME`           | `$HOME` (nicht expandiert) |
| `\\.py`         | Wörtliches `.py`             | `script.py`                |
| `\\[cli\\]`     | Wörtliches `[cli]`           | `mcp[cli]`                 |

<div id="notes">
  ## Anmerkungen
</div>

<div id="admin-configuration-guidelines">
  ### Richtlinien für die Admin-Konfiguration
</div>

* **Umgebungsvariablen**: Der Abschnitt `env` wird nicht per Regex abgeglichen und kann von Nutzerinnen und Nutzern frei konfiguriert werden
* **Deaktivierte Tools**: Das Array `disabledTools` wird separat behandelt und ist nicht Teil des Whitelist-Abgleichs
* **Groß-/Kleinschreibung**: Alle Abgleiche sind case-sensitiv
* **Fehlerbehandlung**: Ungültige Regex-Muster werden protokolliert und führen zur Zugriffsverweigerung
* **Tests**: Testen Sie Ihre Regex-Muster sorgfältig – zu restriktive Muster können legitime Anwendungsfälle blockieren

<div id="troubleshooting">
  ### Fehlerbehebung
</div>

Wenn Nutzer melden, dass ihre MCP-Server nach dem Zulassen per Allowlist nicht funktionieren:

1. **Exakte Übereinstimmung prüfen**: Stellen Sie sicher, dass das Allowlist-Muster exakt der Nutzerkonfiguration entspricht
2. **Regex-Escaping prüfen**: Sonderzeichen müssen ggf. maskiert werden (z. B. `\.` für echte Punkte)
3. **Logs prüfen**: Ungültige Regex-Muster werden mit Warnungen protokolliert
4. **Muster testen**: Verwenden Sie einen Regex-Tester, um zu prüfen, ob Ihre Muster wie erwartet funktionieren

Denken Sie daran: Sobald Sie einen Server auf die Allowlist setzen, **werden alle anderen Server für Ihre Teammitglieder automatisch blockiert**.

<div id="general-information">
  ### Allgemeine Informationen
</div>

* Da MCP-Toolaufrufe Code ausführen können, der von beliebigen Serverimplementierenden geschrieben wurde, übernehmen wir keine Haftung für Fehler bei MCP-Toolaufrufen. Zur Klarstellung:
* Derzeit unterstützen wir die [Tools](https://modelcontextprotocol.io/docs/concepts/tools), [Resources](https://modelcontextprotocol.io/docs/concepts/resources) und [Prompts](https://modelcontextprotocol.io/docs/concepts/prompts) eines MCP-Servers.