Zum Hauptinhalt springen
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.
Enterprise-Nutzer müssen dies in den Einstellungen manuell aktivieren

​
Hinzufügen eines neuen MCP

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 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.

​
Konfiguration von MCP-Tools

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.

​
mcp_config.json

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: 
{
  "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 oder OpenTools für einige Beispielserver. Im Folgenden finden Sie Konfigurationsbeispiele für einige häufig verwendete MCP-Server. Diese können Sie Ihrer Datei mcp_config.json hinzufügen.
Der GitHub-MCP-Server stellt Tools für Repository-Verwaltung, Dateioperationen, Issue-Tracking und Pull-Request-Verwaltung bereit.Verwendung mit npx:
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
Verwendung 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, besuchen Sie GitHub Settings > Developer settings > Personal access tokens.
Der Slack-MCP-Server ermöglicht Kanalverwaltung, Messaging und Interaktionen mit Ihrem 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-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
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 Ihr Connection-String 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 erlaubte Verzeichnisse angeben, indem Sie zusätzliche Pfadargumente hinzufügen. Nur Dateien innerhalb dieser Verzeichnisse sind zugänglich.
Der Memory-MCP-Server stellt ein persistentes Speichersystem auf Basis eines Wissensgraphs bereit, sodass Cascade sich Informationen über Sitzungen hinweg merken kann.
{
  "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.

​
Remote HTTP MCPs

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

​
Konfigurationsinterpolation

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

​
Administratorsteuerung (Teams & Enterprises)

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:

MCP-Team-Einstellungen

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

​
Funktionsweise des Server-Matchings

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

​
Konfigurationsoptionen

Admin-Whitelist-Konfiguration:
  • Server-ID: github-mcp-server
  • Server Config (JSON): (leer lassen)
{}
Zugehörige Benutzerkonfiguration (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 Eintrag im Plugin-Store ü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": ""
  }
}
Zugehörige Benutzerkonfiguration (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 in command oder args wird blockiert. Der Abschnitt env darf abweichende Werte enthalten.
Admin-Whitelist-Konfiguration:
  • Server-ID: python-mcp-server
  • Server Config (JSON):
{
  "command": "python3",
  "args": ["/.*\\.py", "--port", "[0-9]+"]
}
Zugehörige Benutzerkonfiguration (mcp_config.json):
{
  "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

​
Häufige Regex-Muster

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

​
Anmerkungen

​
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 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

​
Fehlerbehebung

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.

​
Allgemeine Informationen

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