> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/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-Kontrollen für Teams und Enterprise.

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

<Note>Enterprise-Nutzer müssen dies manuell über die Settings aktivieren</Note>

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

Neue MCP-Plugins können hinzugefügt werden, indem Sie zum Abschnitt `Settings` > `Tools` > `Windsurf Settings` > `Add Server` navigieren.

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

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

<Frame>
  <img src="https://mintcdn.com/cognitionai/-PTA3zzo2bR9Qfc8/desktop/assets/plugins/mcp-server-templates.jpg?fit=max&auto=format&n=-PTA3zzo2bR9Qfc8&q=85&s=011ca9d571dfa249d10d9f34b7287642" width="1666" height="1388" data-path="desktop/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.

Bei `http`-Servern sollte die URL dem Endpunkt entsprechen und in etwa wie `https://<your-server-url>/mcp` aussehen.

<Note>Achten Sie darauf, nach dem Hinzufügen eines neuen MCP-Plugins auf die Schaltfläche zum Aktualisieren zu klicken.</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 Cascade eine Verbindung herstellen 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": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
```

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

Im [offiziellen Referenz-Repo für MCP-Server](https://github.com/modelcontextprotocol/servers) oder bei [OpenTools](https://opentools.com/) findest du einige Beispielserver.

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

Wichtig ist, dass die Konfiguration bei Remote-HTTP-MCPs leicht anders ist und ein Feld `serverUrl` oder `url` erfordert.

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

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

<div id="config-interpolation">
  ### Interpolation in der Konfiguration
</div>

Die Datei `~/.codeium/mcp_config.json` unterstützt die Interpolation von
Umgebungsvariablen in diesen Feldern: `command`, `args`, `env`, `serverUrl`, `url` und
`headers`.

Hier ist eine Beispielkonfiguration, die in `headers` die Umgebungsvariable
`AUTH_TOKEN` 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-Einstellungen (Teams & Unternehmen)
</div>

Team-Admins können den MCP-Zugriff für ihr Team umschalten und außerdem genehmigte MCP-Server für ihr Team auf die Whitelist setzen:

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

<Warning>Der obige Link funktioniert nur, wenn Sie Admin-Rechte für Ihr Team haben.</Warning>

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

<div id="how-server-matching-works">
  ### So funktioniert der Server-Abgleich
</div>

Wenn Sie einen MCP-Server auf die Whitelist setzen, verwendet das System **Regex-Abgleich** nach den folgenden Regeln:

* **Vollständiger String-Abgleich**: Alle Muster werden automatisch verankert (in `^(?:pattern)$` eingeschlossen), um Teiltreffer zu verhindern
* **Befehlsfeld**: Muss exakt oder entsprechend Ihrem Regex-Muster übereinstimmen
* **Argument-Array**: Jedes Argument wird einzeln mit dem entsprechenden Muster abgeglichen
* **Array-Länge**: Die Anzahl der Argumente muss in der Whitelist und in der Nutzerkonfiguration exakt übereinstimmen
* **Sonderzeichen**: Zeichen wie `$`, `.`, `[`, `]`, `(`, `)` haben in Regex eine besondere Bedeutung und sollten mit `\` maskiert werden, wenn Sie eine wörtliche Übereinstimmung möchten

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

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

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

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

    **Passende Nutzerkonfiguration (`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"
          }
        }
      }
    }
    ```

    Dadurch 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: Konfiguration mit exakter Übereinstimmung" description="Geben Sie die exakte Konfiguration an, die Nutzer verwenden müssen. Nutzer müssen dieser Konfiguration genau entsprechen.">
    **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 Nutzerkonfiguration (`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 Abweichungen in Nutzerkonfigurationen 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 Nutzerkonfiguration (`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 gibt Nutzern Flexibilität und wahrt gleichzeitig die Sicherheit:

    * Die Regex `/.*\\.py` entspricht jedem Pfad zu einer Python-Datei wie `/home/user/my_server.py`
    * Die Regex `[0-9]+` entspricht jedem 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_]+` | Alphanumerische Zeichen + 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">
  ## Hinweise
</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 Nutzern frei konfiguriert werden
* **Deaktivierte Tools**: Das Array `disabledTools` wird separat behandelt und ist nicht Teil des Whitelist-Abgleichs
* **Groß-/Kleinschreibung**: Der Abgleich berücksichtigt die Groß- und Kleinschreibung
* **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 Whitelisting nicht funktionieren:

1. **Exakten Abgleich prüfen**: Stellen Sie sicher, dass das Whitelist-Muster genau mit der Konfiguration des Nutzers übereinstimmt
2. **Regex-Escaping überprüfen**: Sonderzeichen müssen möglicherweise maskiert werden (z. B. `\.` für literale 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 Whitelist setzen, werden **alle anderen Server für Ihre Teammitglieder automatisch blockiert**.

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

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