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

> Integrieren Sie MCP-Server mit Cascade, um auf eigene Tools wie GitHub, Datenbanken und APIs zuzugreifen. Konfigurieren Sie stdio-, HTTP- und SSE-Transporte mit Admin-Kontrollen für Teams.

**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 die von ihnen bereitgestellten Tools zu nutzen.
Cascade bietet jetzt eine native MCP-Integration, sodass Sie Ihre eigene Auswahl an MCP-Servern für Cascade einbinden können.
Weitere Informationen finden Sie in den [offiziellen MCP‑Docs](https://modelcontextprotocol.io/).

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

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

Neue MCPs können über den MCP Marketplace hinzugefügt werden, den Sie erreichen,
indem Sie im Cascade-Panel oben rechts auf das Symbol `MCPs` klicken oder über
den Bereich `Windsurf Settings` > `Cascade` > `MCP Servers` navigieren.

Wenn Sie den gewünschten MCP nicht finden, können Sie ihn manuell hinzufügen, indem Sie die Konfigurationsdatei `mcp_config.json` im Rohformat bearbeiten.

Offizielle MCPs werden mit einem blauen Häkchen angezeigt, was darauf hinweist, dass sie vom jeweiligen Dienstanbieter stammen.

Wenn Sie auf einen MCP klicken, müssen Sie nur auf `Install` klicken, um den Server und seine Tools für Cascade verfügbar zu machen.

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

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

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

<Frame>
  <img src="https://mintcdn.com/codeium/Rm_zdSOuabDsfa9L/assets/windsurf/cascade/mcp/mcp-plugin-store.png?fit=max&auto=format&n=Rm_zdSOuabDsfa9L&q=85&s=1f6f2165d7017097ebb08cba65d43362" width="955" height="774" data-path="assets/windsurf/cascade/mcp/mcp-plugin-store.png" />
</Frame>

<div id="configuring-mcp-tools">
  ## Konfiguration von MCP-Tools
</div>

Jede MCP hat Zugriff auf eine bestimmte Anzahl von Tools. Cascade ist auf insgesamt 100 verfügbare Tools zu jedem Zeitpunkt begrenzt.

Auf jeder MCP-Einstellungsseite kannst du die Tools, die du verwenden möchtest, ein- oder ausschalten. Um die Einstellungen für eine MCP zu öffnen, klicke im Cascade-Panel oben rechts im Menü auf das Symbol `MCPs` und anschließend auf die gewünschte MCP.

<Frame>
  <img src="https://mintcdn.com/codeium/Rm_zdSOuabDsfa9L/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=Rm_zdSOuabDsfa9L&q=85&s=167fd87ffb6cf42228f6e62ff8cb6596" width="893" height="639" data-path="assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png" />
</Frame>

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

Die Datei `~/.codeium/windsurf/mcp_config.json` ist eine JSON-Datei mit einer Liste von Servern, 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="popular-mcp-server-examples">
  ### Beispiele für häufig genutzte MCP-Server
</div>

Im Folgenden finden Sie Konfigurationsbeispiele für einige häufig verwendete MCP-Server. Diese können Sie Ihrer Datei `mcp_config.json` hinzufügen.

<AccordionGroup>
  <Accordion title="GitHub" description="Repository-Verwaltung, Dateioperationen und GitHub-API-Integration.">
    Der GitHub-MCP-Server stellt Tools für Repository-Verwaltung, Dateioperationen, Issue-Tracking und Pull-Request-Verwaltung bereit.

    **Verwendung mit npx:**

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

    **Verwendung mit Docker:**

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

    Um ein Personal Access Token zu erstellen, besuchen Sie [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Kanalverwaltung und Messaging-Funktionen für Slack-Workspaces.">
    Der Slack-MCP-Server ermöglicht Kanalverwaltung, Messaging und Interaktionen mit Ihrem Workspace.

    ```json theme={null}
    {
      "mcpServers": {
        "slack": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-slack"],
          "env": {
            "SLACK_BOT_TOKEN": "<YOUR_SLACK_BOT_TOKEN>",
            "SLACK_TEAM_ID": "<YOUR_SLACK_TEAM_ID>"
          }
        }
      }
    }
    ```

    So richten Sie ein Slack-Bot-Token ein:

    1. Erstellen Sie eine Slack-App unter [api.slack.com/apps](https://api.slack.com/apps)
    2. Fügen Sie die erforderlichen OAuth-Scopes hinzu (z. B. `channels:read`, `chat:write`, `users:read`)
    3. Installieren Sie die App in Ihrem Workspace und kopieren Sie das Bot User OAuth Token
  </Accordion>

  <Accordion title="PostgreSQL" description="Schreibgeschützter Datenbankzugriff mit Schema-Inspektion.">
    Der PostgreSQL-MCP-Server bietet schreibgeschützten Zugriff auf PostgreSQL-Datenbanken, einschließlich Schema-Inspektion und Abfrageausführung.

    ```json theme={null}
    {
      "mcpServers": {
        "postgres": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-postgres"],
          "env": {
            "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
          }
        }
      }
    }
    ```

    <Warning>Der PostgreSQL-Server bietet aus Sicherheitsgründen standardmäßig schreibgeschützten Zugriff. Stellen Sie sicher, dass Ihr Connection-String Zugangsdaten mit eingeschränkten Berechtigungen verwendet.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Sichere Dateioperationen mit konfigurierbaren Zugriffskontrollen.">
    Der Filesystem-MCP-Server bietet sicheren Zugriff auf lokale Dateien und Verzeichnisse mit konfigurierbaren Zugriffskontrollen.

    ```json theme={null}
    {
      "mcpServers": {
        "filesystem": {
          "command": "npx",
          "args": [
            "-y", "@modelcontextprotocol/server-filesystem",
            "/path/to/allowed/directory"
          ]
        }
      }
    }
    ```

    Sie können mehrere erlaubte Verzeichnisse angeben, indem Sie zusätzliche Pfadargumente hinzufügen. Nur Dateien innerhalb dieser Verzeichnisse sind zugänglich.
  </Accordion>

  <Accordion title="Brave Search" description="Web- und lokale Suche mit der Brave Search API.">
    Der Brave-Search-MCP-Server ermöglicht Websuche mithilfe der Brave Search API.

    ```json theme={null}
    {
      "mcpServers": {
        "brave-search": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-brave-search"],
          "env": {
            "BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>"
          }
        }
      }
    }
    ```

    Um einen Brave-API-Schlüssel zu erhalten, registrieren Sie sich unter [brave.com/search/api](https://brave.com/search/api/).
  </Accordion>

  <Accordion title="Memory" description="Wissensgraphbasiertes System für persistenten Speicher.">
    Der Memory-MCP-Server stellt ein persistentes Speichersystem auf Basis eines Wissensgraphs bereit, sodass Cascade sich Informationen über Sitzungen hinweg merken kann.

    ```json theme={null}
    {
      "mcpServers": {
        "memory": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-memory"]
        }
      }
    }
    ```

    Der Memory-Server speichert Daten lokal und bleibt über Sitzungen hinweg erhalten, was ihn nützlich macht, um Kontext zu Projekten, Präferenzen und erlernten Informationen beizubehalten.
  </Accordion>
</AccordionGroup>

<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 `serverUrl`- oder `url`-Feld 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/windsurf/mcp_config.json` ist für die Interpolation von
Umgebungsvariablen in diesen Feldern verantwortlich: `command`, `args`, `env`, `serverUrl`, `url` und
`headers`.

Hier ist eine Beispielkonfiguration, die eine Umgebungsvariable namens `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">
  ## Administratorsteuerung (Teams & Enterprises)
</div>

Team-Admins können den MCP-Zugriff für ihr Team aktivieren oder deaktivieren sowie zulässige MCP-Server für ihr Team auf eine Whitelist setzen:

<Card title="MCP-Team-Einstellungen" 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 über Admin-Berechtigungen für Ihr Team verfügen.</Warning>

Standardmäßig können Benutzer 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.

<Note>Die Server-ID in der Whitelist muss exakt mit dem im `mcp_config.json` des Benutzers verwendeten Schlüsselnamen übereinstimmen; die Groß- und Kleinschreibung muss identisch sein.</Note>

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

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

* **Vollständiger Zeichenkettenabgleich**: Alle Muster werden automatisch verankert (mit `^(?:pattern)$` umschlossen), um Teiltreffer zu verhindern
* **Command-Feld**: Muss exakt oder gemäß Ihrem Regex-Muster übereinstimmen
* **Arguments-Array**: Jedes Argument wird einzeln mit seinem jeweiligen 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 `\` maskiert 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}
    {}
    ```

    **Zugehörige 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 verwendet werden muss. Nutzer müssen diese Konfiguration exakt einhalten.">
    **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": ""
      }
    }
    ```

    **Zugehörige 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 in command oder args wird blockiert. Der Abschnitt `env` darf abweichende 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]+"]
    }
    ```

    **Zugehörige 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 erlaubt Nutzern Flexibilität bei gleichzeitiger Wahrung der Sicherheit:

    * Der Regex `/.*\\.py` entspricht jedem Python-Dateipfad wie `/home/user/my_server.py`
    * Der Regex `[0-9]+` entspricht jeder numerischen Portangabe 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 Zeichenkette       | `/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 Nutzern frei konfiguriert werden
* **Deaktivierte Tools**: Das Array `disabledTools` wird separat behandelt und ist nicht Teil der Whitelist-Prüfung
* **Groß-/Kleinschreibung**: Alle Prüfungen 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 Whitelisting nicht funktionieren:

1. **Auf exakte Übereinstimmung prüfen**: Stellen Sie sicher, dass das Whitelist-Muster genau der Konfiguration des Nutzers entspricht
2. **Regex-Escaping prüfen**: Sonderzeichen müssen ggf. maskiert werden (z. B. `\.` für einen Punkt als Literale)
3. **Logs prüfen**: Ungültige Regex-Muster werden mit Warnungen protokolliert
4. **Muster testen**: Verwenden Sie einen Regex-Tester, um zu überprüfen, dass 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-Toolaufrufe Code ausführen können, der von beliebigen Server-Implementierenden geschrieben wurde, übernehmen wir keine Haftung für Ausfälle von 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.