Zum Hauptinhalt springen

Documentation Index

Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt

Use this file to discover all available pages before exploring further.

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.
Enterprise-Nutzer müssen dies manuell über die Settings aktivieren

​
Hinzufügen eines neuen MCP

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 Windsurf 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. 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.
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.
Devin Desktop unterstützt drei Transporttypen 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.

​
MCP-Tools konfigurieren

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.

​
mcp_config.json

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: 
{
  "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 oder bei OpenTools. Nachfolgend finden Sie Konfigurationsbeispiele für einige häufig verwendete MCP-Server. Diese können Ihrer Datei mcp_config.json hinzugefügt werden.
Der GitHub MCP-Server stellt Tools für die Repository-Verwaltung, Dateioperationen, Issue-Tracking und Pull-Request-Verwaltung bereit.Mit npx:
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
Mit Docker:
{
  "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 auf.
Der Slack MCP-Server ermöglicht die Verwaltung von Channels, Messaging und Interaktionen im Workspace.
{
  "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
  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
Der PostgreSQL MCP-Server bietet schreibgeschützten Zugriff auf PostgreSQL-Datenbanken, einschließlich Schema-Inspektion und Abfrageausführung.
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
      }
    }
  }
}
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.
Der Filesystem MCP-Server bietet sicheren Zugriff auf lokale Dateien und Verzeichnisse mit konfigurierbaren Zugriffskontrollen.
{
  "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.
Der Memory MCP-Server bietet ein persistentes Speichersystem auf Basis eines Wissensgraphen, sodass Cascade Informationen sitzungsübergreifend speichern kann.
{
  "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.

​
Remote-HTTP-MCPs

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: 
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}

​
Konfigurationsinterpolation

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: 
{
  "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: 
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}

​
Admin-Einstellungen (Teams & Enterprises)

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:

​
MCP Registry

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.
Registries sind der bevorzugte Weg, den Zugriff auf MCPs zu verwalten, aber auch Whitelists funktionieren.

​
Benutzerdefinierte Registries konfigurieren

  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.
Benutzerdefinierte Registries müssen dem offiziellen MCP-Registry-Schema folgen. Dadurch werden Kompatibilität und standardisierte Serverdefinitionen sichergestellt.

​
MCP-Whitelist

MCP Team Settings

Konfigurierbare MCP-Einstellungen für Ihr Team.
Der obige Link funktioniert nur, wenn Sie Admin-Rechte für Ihr Team haben.
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.
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.

​
Wie der Serverabgleich funktioniert

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

​
Konfigurationsoptionen

Admin-Whitelist-Konfiguration:
  • Server ID: github-mcp-server
  • Server Config (JSON): (leer lassen)
{}
Entsprechende Nutzerkonfiguration (mcp_config.json):
{
  "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.
Admin-Whitelist-Konfiguration:
  • Server ID: github-mcp-server
  • Server Config (JSON):
{
  "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):
{
  "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.
Admin-Whitelist-Konfiguration:
  • Server ID: python-mcp-server
  • Server Config (JSON):
{
  "command": "python3",
  "args": ["/.*\\.py", "--port", "[0-9]+"]
}
Entsprechende Nutzerkonfiguration (mcp_config.json):
{
  "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

​
Häufige Regex-Muster

MusterEntsprichtBeispiel
.*Beliebige Zeichenfolge/home/user/script.py
[0-9]+Beliebige Zahl8080, 3000
[a-zA-Z0-9_]+Alphanumerische Zeichen + Unterstrichapi_key_123
\\$HOMEWörtliches $HOME$HOME (wird nicht expandiert)
\\.pyWörtliches .pyscript.py
\\[cli\\]Wörtliches [cli]mcp[cli]

​
Hinweise

​
Richtlinien für die Admin-Konfiguration

  • 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

​
Fehlerbehebung

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.

​
Allgemeine Informationen

  • 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, Ressourcen und Prompts eines MCP-Servers.