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

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

**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 Tools zuzugreifen, die diese bereitstellen.
Cascade unterstützt MCP jetzt nativ, sodass Sie Ihre eigene Auswahl an MCP-Servern einbinden können, die Cascade nutzen kann.
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">
  ## Hinzufügen eines neuen MCP
</div>

Neue MCPs können über den MCP-Marketplace hinzugefügt werden. Diesen erreichen Sie,
indem Sie im Cascade-Bereich oben rechts im Menü auf das Symbol `MCPs` klicken oder zum
Abschnitt `Devin Settings` > `Cascade` > `MCP Servers` wechseln.

Wenn Sie das gewünschte MCP nicht finden, können Sie es manuell hinzufügen, indem Sie die Datei `mcp_config.json` direkt bearbeiten.

Offizielle MCPs werden mit einem blauen Häkchen angezeigt. Das bedeutet, dass sie vom Unternehmen hinter dem jeweiligen Dienst erstellt wurden.

Wenn Sie auf ein MCP klicken, klicken Sie einfach auf `Install`, um den Server und seine Tools in Cascade verfügbar zu machen.

<div id="one-click-install-via-deeplink">
  ### Ein-Klick-Installation per Deeplink
</div>

Devin Desktop unterstützt die Ein-Klick-Installation von MCP-Servern über Deeplinks. Sie können diese Links verwenden, um die MCP-Registry-Seite direkt in Devin Desktop zu öffnen. Das ist nützlich, um Empfehlungen für MCP-Server weiterzugeben oder Installationsschaltflächen in die Dokumentation einzubetten.

Das Deeplink-Format lautet:

```
windsurf://windsurf-mcp-registry?serverName=<server-name>
```

* **Mit `serverName`**: Öffnet die MCP-Registry-Seite für den angegebenen Server, auf der der Nutzer ihn ansehen und installieren kann.
* **Ohne `serverName`**: Öffnet die MCP-Marketplace-Seite.

Zum Beispiel öffnet `windsurf://windsurf-mcp-registry?serverName=github-mcp-server` die Registry-Seite des GitHub-MCP-Servers in Devin Desktop.

<Note>Deeplinks für die Installation mit einem Klick setzen voraus, dass für das Team des Nutzers der MCP-Zugriff aktiviert ist. Wenn der MCP-Zugriff von einem Administrator deaktiviert wurde, öffnet der Deeplink die Registry-Seite nicht.</Note>

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

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

Bei `http`-Servern sollte die URL der des Endpunkts entsprechen und etwa wie `https://<your-server-url>/mcp` aussehen.

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

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

Jedes MCP hat Zugriff auf eine bestimmte Anzahl von Tools. Cascade kann insgesamt auf maximal 100 Tools gleichzeitig zugreifen.

Auf jeder MCP-Settings-Seite können Sie die Tools aktivieren, die Sie verwenden möchten. Um
die Settings für ein MCP zu öffnen, klicken Sie im Cascade-Bereich oben rechts im Menü auf das
`MCPs`-Icon und dann auf das gewünschte MCP.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=81513e7073b00eb6d9c53017789b08c1" width="893" height="639" data-path="desktop/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, 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>"
      }
    }
  }
}
```

Stellen Sie sicher, dass Sie die erforderlichen Argumente und Umgebungsvariablen für die Server bereitstellen, die Sie verwenden möchten.

Einige Beispiel-Server finden Sie im [offiziellen Referenz-Repository für MCP-Server](https://github.com/modelcontextprotocol/servers) oder bei [OpenTools](https://opentools.com/).

<div id="popular-mcp-server-examples">
  ### Beliebte MCP-Server-Beispiele
</div>

Nachfolgend finden Sie Konfigurationsbeispiele für einige häufig verwendete MCP-Server. Diese können Ihrer Datei `mcp_config.json` hinzugefügt werden.

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

    **Mit npx:**

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

    **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, rufen Sie [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens) auf.
  </Accordion>

  <Accordion title="Slack" description="Channel-Verwaltung und Messaging-Funktionen für Slack-Workspaces.">
    Der Slack MCP-Server ermöglicht die Verwaltung von Channels, Messaging und Interaktionen im 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-Geltungsbereiche 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 Funktionen zur 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 Ihre Verbindungszeichenfolge geeignete 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 zulässige 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 über die Search API von Brave.">
    Der Brave Search MCP-Server ermöglicht Websuche über die Search API von Brave.

    ```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 key zu erhalten, registrieren Sie sich unter [brave.com/search/api](https://brave.com/search/api/).
  </Accordion>

  <Accordion title="Memory" description="Persistentes Speichersystem auf Basis eines Wissensgraphen.">
    Der Memory MCP-Server bietet ein persistentes Speichersystem auf Basis eines Wissensgraphen, sodass Cascade Informationen sitzungsübergreifend speichern kann.

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

    Der Memory-Server speichert Daten lokal und bleibt sitzungsübergreifend erhalten. Dadurch eignet er sich gut, um Kontext zu Projekten, Präferenzen und erlernten Informationen beizubehalten.
  </Accordion>
</AccordionGroup>

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

Wichtig ist, dass die Konfiguration bei Remote-HTTP-MCPs etwas 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">
  ### Konfigurationsinterpolation
</div>

Die Datei `~/.codeium/windsurf/mcp_config.json` unterstützt Variableninterpolation
in den folgenden Feldern: `command`, `args`, `env`, `serverUrl`, `url` und
`headers`. So können Sie vermeiden, Secrets direkt in der Konfigurationsdatei zu hinterlegen.

Es werden zwei Interpolationsmuster unterstützt:

* **`${env:VAR_NAME}`** — wird durch den Wert der Umgebungsvariable `VAR_NAME` ersetzt. Wenn die Variable nicht gesetzt ist, ergibt sich ein leerer String.
* **`${file:/path/to/file}`** — wird durch den Inhalt der Datei am angegebenen Pfad ersetzt, wobei führende und nachgestellte Leerzeichen entfernt werden. Tilde-Pfade (z. B. `~/secrets/key.txt`) werden unterstützt. Wenn die Datei nicht gelesen werden kann, bleibt das Muster unverändert.

Hier ist ein Beispiel für die Verwendung einer Umgebungsvariable in `headers`:

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

Hier ist ein Beispiel dafür, wie ein API key aus einer Datei gelesen wird:

```json theme={null}
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}
```

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

Team-Admins können den MCP-Zugriff für ihr Team aktivieren oder deaktivieren und eine Whitelist genehmigter MCP-Server für ihr Team festlegen:

<div id="mcp-registry">
  ### MCP Registry
</div>

Enterprise-Teams können benutzerdefinierte MCP-Registries konfigurieren, um den Standard-MCP-Marketplace von Devin Desktop zu ersetzen. Teams können ihre eigenen Registry-URLs verknüpfen, um zu steuern, welche MCPs ihren Nutzern zur Verfügung stehen.

<Note>Registries sind der bevorzugte Weg, den Zugriff auf MCPs zu verwalten, aber auch Whitelists funktionieren.</Note>

<div id="configuring-custom-registries">
  #### Benutzerdefinierte Registries konfigurieren
</div>

1. Navigieren Sie zu Team Settings
2. Suchen Sie nach der Einstellung **MCP Registry URLs**
3. Fügen Sie eine oder mehrere Registry-URLs hinzu

Wenn mehrere Registry-URLs konfiguriert sind, verwendet Devin Desktop die **Vereinigung** aller Registries – Nutzer sehen also MCPs aus allen konfigurierten Quellen zusammen. Der MCP Marketplace des Teams bezieht seine Daten dann aus diesen internen Registries statt aus der Standard-Registry von Devin Desktop.

<Note>Benutzerdefinierte Registries müssen dem [offiziellen MCP-Registry-Schema](https://modelcontextprotocol.io/) folgen. Dadurch werden Kompatibilität und standardisierte Serverdefinitionen sichergestellt.</Note>

<div id="mcp-whitelist">
  ### MCP-Whitelist
</div>

<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 in einem Team ihre eigenen MCP-Server konfigurieren. Sobald Sie jedoch auch nur einen einzigen MCP-Server auf die Whitelist setzen, **werden für Ihr Team alle Server blockiert, die nicht auf der Whitelist stehen**.

<Note>Die Server-ID in der Whitelist muss unter Beachtung der Groß-/Kleinschreibung exakt mit dem Schlüsselnamen übereinstimmen, der in der `mcp_config.json` des Nutzers verwendet wird.</Note>

<div id="how-server-matching-works">
  ### Wie der Serverabgleich funktioniert
</div>

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

* **Abgleich der gesamten Zeichenfolge**: 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 zugehörigen Muster abgeglichen
* **Array-Länge**: Die Anzahl der Argumente in der Whitelist und in der Nutzerkonfiguration muss exakt übereinstimmen
* **Sonderzeichen**: Zeichen wie `$`, `.`, `[`, `]`, `(`, `)` haben in Regex eine besondere Bedeutung und sollten mit `\` maskiert werden, wenn Sie einen wörtlichen Abgleich 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, damit die Standardkonfiguration aus dem Devin Desktop MCP Plugin Store verwendet werden kann.">
    **Admin-Whitelist-Konfiguration:**

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

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

    **Entsprechende 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"
          }
        }
      }
    }
    ```

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

  <Accordion title="Option 2: Konfiguration mit exakter Übereinstimmung" description="Geben Sie die genaue Konfiguration an, 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": ""
      }
    }
    ```

    **Entsprechende 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 dabei die Sicherheitsvorgaben einzuhalten.">
    **Admin-Whitelist-Konfiguration:**

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

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

    **Entsprechende 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 bietet Nutzern Flexibilität und wahrt gleichzeitig die Sicherheit:

    * Die Regex `/.*\\.py` passt auf jeden Python-Dateipfad wie `/home/user/my_server.py`
    * Die 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_]+` | Alphanumerische Zeichen + Unterstrich | `api_key_123`                   |
| `\\$HOME`       | Wörtliches `$HOME`                    | `$HOME` (wird 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**: Beim Abgleich wird zwischen Groß- und Kleinschreibung unterschieden
* **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 Hinzufügen zur Whitelist nicht funktionieren:

1. **Exakten Abgleich prüfen**: Stellen Sie sicher, dass das Whitelist-Muster genau der Konfiguration des Nutzers entspricht
2. **Regex-Escaping überprüfen**: Sonderzeichen müssen möglicherweise maskiert werden (z. B. `\.` für einen wörtlichen Punkt)
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 irgendeinen 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 Ausfälle 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.