# Windsurf MCP einrichten 2026: neuer Config-Pfad, Regeln

> Windsurf MCP einrichten nach der Umbenennung in Devin Desktop: welche mcp_config.json Devin Local liest, ein JSON-Eintrag, Regeldateien und typische Fehler.

- Autor: [Serban Rusu](https://wingo-ui.com/blog/authors/serban), Founder of Wingo UI
- Veröffentlicht: 6. Nov. 2026
- Kategorie: [UI mit KI-Agenten bauen](https://wingo-ui.com/de/blog/category/ai-agents)
- Lesezeit: 10 Min.
- Kanonische URL: https://wingo-ui.com/de/blog/windsurf-mcp
- Englische Fassung: https://wingo-ui.com/blog/windsurf-mcp

## Kurz gesagt

Windsurf heißt seit dem 2. Juni 2026 Devin Desktop, und Cascade wurde am 8. September 2026 entfernt. MCP-Server gehören deshalb jetzt zum Agenten Devin Local: ~/.config/devin/mcp_config.json für deinen Benutzer, .devin/mcp_config.json für ein Projekt. Die alte ~/.codeium/windsurf/mcp_config.json wird standardmäßig weiter importiert, deshalb scheinen alte Guides noch zu funktionieren. Leg einen stdio-Eintrag für npx -y wingo-ui@latest mcp an, aktualisier die MCP-Liste und schreib eine Regel in die AGENTS.md, die sagt, dass der Agent vor jeder UI zuerst die Registry durchsucht.

Die meisten Guides zu Windsurf MCP sagen dir noch, du sollst `~/.codeium/windsurf/mcp_config.json` bearbeiten, das MCP-Menü im Cascade-Panel öffnen und unter 100 Tools bleiben. 2026 haben sich drei Dinge geändert: Windsurf heißt seit dem 2. Juni Devin Desktop, Cascade wurde am 8. September entfernt, und MCP-Server gehören jetzt zu einem neuen Agenten, Devin Local, mit eigenen Config-Dateien. Wer Windsurf MCP einrichten will, bekommt in diesem Tutorial die Antworten: wo die Config heute liegt, wie das JSON aussieht, wie du eine Komponenten-Registry (unsere, Wingo UI) und den shadcn-Server anbindest, welche Regeldatei der Agent liest und welche Fehler dir wahrscheinlich begegnen.

Was wir geprüft haben, und wie: Am 6. November 2026 haben wir Cognitions Doku unter docs.devin.ai gelesen (docs.windsurf.com leitet inzwischen dorthin weiter): das FAQ zu Devin Desktop, die Seiten zu MCP, Berechtigungen und Enterprise für Devin Local und die Devin CLI und das stabile Changelog bis v3.11.238 (30. Oktober 2026). Devin Desktop haben wir für diesen Beitrag nicht installiert. Jeder Pfad unten stammt also aus dieser Doku, nicht von unserer Festplatte. Selbst ausgeführt haben wir nur unseren Teil: unseren MCP-Server, der an diesem Tag auf `tools/list` mit 10 Tools geantwortet hat. Warum ein Coding-Agent überhaupt einen Server für Komponenten braucht, steht in unserem [Guide zu MCP für Komponentenbibliotheken](https://wingo-ui.com/de/blog/component-library-mcp-guide).

## Ist Windsurf noch Windsurf?

Der Editor schon. Name und Agent nicht. Cognitions [FAQ zu Devin Desktop](https://docs.devin.ai/desktop/devin-desktop-faq) beschreibt Devin Desktop als den neuen Namen von Windsurf, ausgeliefert am 2. Juni 2026 als Over-the-Air-Update, mit übernommenen Einstellungen, Extensions und Plänen. Der Agent kam später dran. Laut dem Eintrag für v3.9.19 (8. September 2026) im [stabilen Changelog](https://docs.devin.ai/desktop/changelog) wurde Cascade entfernt, und Devin Local ist der einzige verfügbare Agent. Devin Local läuft auf demselben Harness wie die Devin CLI, die Doku der CLI gilt also auch dafür.

Für MCP zählt das mehr als die Umbenennung. Cascade hat eine Datei gelesen. Devin Local liest drei Scopes, importiert Configs aus anderen Tools und fragt vor jedem Tool-Aufruf nach.

## Wo liegt die MCP-Config-Datei von Windsurf jetzt?

Laut der [Seite zu Customizations in Devin Local](https://docs.devin.ai/desktop/devin-local/customizations) und der [Doku zur MCP-Konfiguration](https://docs.devin.ai/cli/extensibility/mcp/configuration), Stand 6. November 2026:

| Scope | Datei | In Git? |
| --- | --- | --- |
| Benutzer | `~/.config/devin/mcp_config.json` (`%APPDATA%\devin\mcp_config.json` auf Windows) | Nein |
| Projekt | `.devin/mcp_config.json` | Ja, mit dem Team geteilt |
| Lokaler Override | `.devin/mcp_config.local.json` | Nein, per `.gitignore` ausgeschlossen |
| Altes Windsurf | `~/.codeium/windsurf/mcp_config.json` (`windsurf-next` für Next-Builds) | Nein, wird beim Start importiert |

In der App öffnest du das Fenster Agents, klickst auf **Customize** und dann auf den Tab **MCPs**. Ist im Auswahlfeld **Install MCPs for** der Eintrag **This computer** gewählt, zeigt die Liste die Server, die der Agent für die in diesem Fenster geöffneten Ordner lädt. Dort kannst du einen Server ein- und ausschalten, seine Config-Datei öffnen oder die Liste aktualisieren.

### Warum nennen Guides unterschiedliche Pfade?

Weil jeder für ein anderes Jahr stimmt. `~/.codeium/windsurf/mcp_config.json` war die Datei von Cascade. Devin Local liest sie weiterhin: Die [Doku zum Config-Import](https://docs.devin.ai/cli/reference/configuration/read-config-from) führt `~/.codeium/<channel>/mcp_config.json` unter Windsurf auf, standardmäßig eingeschaltet. Deshalb scheint ein alter Guide noch zu funktionieren. Das bedeutet aber auch: Ein Server, den du aus der neuen Datei entfernst, kann über die alte zurückkommen. Wenn du nur eine Quelle haben willst, zieh deine Einträge um und schalte den Import in `~/.config/devin/config.json` ab:

```json
{
  "read_config_from": {
    "windsurf": false
  }
}
```

Dieser Schalter verhindert auch, dass `.windsurf/rules/` und `.windsurf/skills/` geladen werden. Lass ihn an, wenn deine Regeln noch dort liegen.

## Was gehört in die Windsurf MCP Config?

Eine Map unter `mcpServers`, ein Eintrag pro Server. Ein stdio-Eintrag hat `command`, `args` und optional `env`. Ein Remote-Eintrag hat `url`, optional `transport` (standardmäßig `"http"`, `"sse"` für alte Server) und optional `headers`. Beide akzeptieren `"disabled": true`. Ältere Guides zeigen `serverUrl`: Die alte Cascade-Doku hat das akzeptiert, die aktuelle Doku nutzt `url`.

Das ist der Eintrag im Benutzer-Scope für unseren Server:

```json
{
  "mcpServers": {
    "wingo-ui": {
      "command": "npx",
      "args": ["-y", "wingo-ui@latest", "mcp"]
    }
  }
}
```

Das `-y` muss bleiben. Ohne es hält npx an und fragt, bevor es das Paket herunterlädt, und auf einen Server, den der Agent im Hintergrund gestartet hat, antwortet niemand.

Wenn du die Devin CLI hast, schreibt sie denselben Eintrag für dich. Der Standard-Scope ist local, also gib `-s user` oder `-s project` mit:

```bash
devin mcp add -s user wingo-ui -- npx -y wingo-ui@latest mcp
devin mcp list
```

## Remote-Eintrag oder npx-stdio: Was ist besser?

Unser Server funktioniert auf beiden Wegen. Der stdio-Eintrag startet einen kleinen Proxy, der an `https://wingo-ui.com/mcp` weiterleitet und den Key mitschickt, den `npx wingo-ui@latest login` auf deinem Rechner gespeichert hat. Der Remote-Eintrag spricht direkt mit dem Server:

```json
{
  "mcpServers": {
    "wingo-ui": {
      "url": "https://wingo-ui.com/mcp",
      "headers": { "Authorization": "Bearer wui_your_key" }
    }
  }
}
```

Dieser Eintrag gehört in `.devin/mcp_config.local.json` oder in die Benutzerdatei, nie in die geteilte Projektdatei. Die Doku beschreibt die Ersetzung von `${env:VAR}` und `${file:/path}` für die OAuth-Felder; dass sie auch für `headers` gilt, steht dort nicht, Stand 6. November 2026. Geh also davon aus, dass der Header genau so gesendet wird, wie er dasteht. Deshalb empfehlen wir stdio: Der Key bleibt im Login-Speicher der CLI oder in `WINGO_UI_API_KEY`, außerhalb jeder JSON-Datei.

Ohne Key verbindet sich der Proxy trotzdem. Er schreibt `anonymous: docs only` nach stderr und bietet dieselben 10 Read-only-Tools an: `search_components`, `list_categories`, `get_component`, `get_block`, `get_design_rules`, `get_theme_tokens`, `get_install_instructions`, `check_updates`, `get_changelog` und `get_account_status`. Doku, Props und Suche funktionieren; für den Quellcode brauchst du einen Key, von einem kostenlosen Konto für die kostenlosen Komponenten und von einem Pro-Konto für die Pro-Komponenten. Alle Optionen stehen in der [Doku zum MCP-Server](https://wingo-ui.com/docs/mcp).

## Wie lege ich einen shadcn-MCP-Eintrag in Windsurf an?

Von Hand, neben unserem. Ein fertiges Setup für Windsurf shadcn MCP gibt es nicht: Die [MCP-Doku von shadcn](https://ui.shadcn.com/docs/mcp) beschreibt das Setup für Claude Code, Cursor, VS Code und Codex, aber nicht für Windsurf oder Devin Desktop, Stand 6. November 2026:

```json
{
  "mcpServers": {
    "shadcn": {
      "command": "npx",
      "args": ["-y", "shadcn@latest", "mcp"]
    }
  }
}
```

Der shadcn-Server durchsucht die Registries aus deiner `components.json` und installiert daraus. Hast du beide Bibliotheken in einem Projekt, bringen beide eine `button.tsx` mit unterschiedlichen Props mit. Leg in deinen Regeln also fest, welche Registry für `components/ui` zuständig ist.

## Gibt es noch ein Limit von 100 Tools?

Keins, das heute dokumentiert ist. Die Grenze von 100 Tools über alle Server war eine Regel von Cascade; der [Windsurf-Guide von fast.io](https://fast.io/resources/windsurf-mcp-setup-guide/) (aktualisiert am 9. Februar 2026) nennt sie noch. Cascade gibt es nicht mehr, und die MCP-Doku zu Devin Local und zur Devin CLI nennt kein Limit, Stand 6. November 2026. Was als Budget bleibt, ist der Kontext: Jedes eingeschaltete Tool schickt sein Schema in jeder Runde ans Modell. Schalte Server, die du gerade nicht nutzt, mit dem Schalter unter **This computer** oder mit `devin mcp disable <name>` ab.

Geändert hat sich dagegen die Freigabe. Devin Local fragt standardmäßig vor jedem MCP-Tool-Aufruf nach, und in der Abfrage erlaubst du ein einzelnes Tool oder alle Tools des Servers, für die Session oder dauerhaft, laut der [Doku zu Berechtigungen in der Devin CLI](https://docs.devin.ai/cli/reference/permissions). Für einen Server, der nur liest, kannst du die Abfrage abschalten. Trag dazu ein Muster in `~/.config/devin/config.json` oder in die `.devin/config.json` des Projekts ein:

```json
{
  "permissions": {
    "allow": ["mcp__wingo-ui__*"]
  }
}
```

Bei Shell-Befehlen, auch bei `npx wingo-ui@latest add`, lässt du die Abfrage an, bis du dem Ergebnis vertraust.

## Was sollten die Windsurf Rules sagen?

Wann der Agent sucht, wie er installiert und welche Tokens er nutzt. Laut FAQ liest Devin Desktop die `AGENTS.md`, die alten `.windsurfrules` und `.windsurf/rules/*.md` und dazu das neue `.devin/rules/*.md`, das Vorrang hat, wenn beide Ordner existieren. Regeldateien kennen im Frontmatter das Feld `trigger`: `always_on`, `glob`, `model_decision` oder `manual`. Unsere CLI hat kein Ziel für Devin (`agents install` kennt Claude Code, Codex, Gemini CLI, Grok und Cursor), also hol dir den Block, den sie für Codex schreibt:

```bash
curl -s https://wingo-ui.com/agents/AGENTS.md >> AGENTS.md
```

Er steht zwischen den Markierungen `<!-- wingo-ui:start v=3 -->` und `<!-- wingo-ui:end -->`. Seine Kernzeile:

```md
- Before writing UI, use the `wingo-ui` MCP tools: `search_components` to find what exists (blocks for whole screens), `get_component` / `get_block` for props and usage, `get_design_rules` for tokens, sizes, motion and mobile rules. Never recreate a component the library has.
```

Die `AGENTS.md` lesen auch Codex und Cursor, eine Datei reicht also für ein gemischtes Team. Liegen die Windsurf-Regeln deines Teams schon in `.windsurf/rules/`, funktionieren sie weiter; neue Regeln kommen nach `.devin/rules/`. Ein ausführlicheres Template steht in unserem [Vergleich von AGENTS.md und CLAUDE.md](https://wingo-ui.com/de/blog/agents-md-vs-claude-md-react).

## Mit welchen Prompts installiert der Agent echte Komponenten?

Nenn den Screen, die Daten und was der Agent dir zurückmelden soll. Die Regel schickt ihn zu `search_components`, dann zu `get_component` oder `get_block`, dann zum Installationsbefehl. Der Prompt liefert, was eine Regel nicht kann: Texte, Routen und Verhalten.

### Prompt 1: ein Bestätigungsdialog

```text
Bau in app/projects/[id]/settings eine Löschbestätigung mit dem Dialog und dem Button von Wingo UI.
Lies vorher beide mit get_component. Der Dialog nennt das Projekt, nutzt den Ton danger, lässt sich
nicht schließen, solange der Request läuft, und zeigt einen Ladezustand auf dem Button Löschen. Installier mit der CLI.
```

[Dialog](https://wingo-ui.com/components/dialog) und [Button](https://wingo-ui.com/components/button) sind beide kostenlos. Ein gutes Ergebnis sieht so aus:

```tsx
// app/projects/[id]/settings/delete-project.tsx
"use client";

import { useState } from "react";
import { Trash2 } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Dialog, DialogClose } from "@/components/ui/dialog";

type Props = { name: string; onDelete: () => Promise<void> };

export function DeleteProject({ name, onDelete }: Props) {
  const [open, setOpen] = useState(false);
  const [deleting, setDeleting] = useState(false);

  async function confirm() {
    setDeleting(true);
    try {
      await onDelete();
      setOpen(false);
    } finally {
      setDeleting(false);
    }
  }

  return (
    <Dialog
      open={open}
      onOpenChange={setOpen}
      dismissible={!deleting}
      tone="danger"
      icon={<Trash2 />}
      title={`${name} löschen?`}
      description="Damit werden das Projekt und seine Deployments entfernt. Das lässt sich nicht rückgängig machen."
      trigger={
        <Button variant="outline" tone="danger">
          Projekt löschen
        </Button>
      }
      footer={
        <>
          <DialogClose asChild>
            <Button variant="soft" disabled={deleting}>
              Abbrechen
            </Button>
          </DialogClose>
          <Button tone="danger" loading={deleting} loadingText="Wird gelöscht" onClick={confirm}>
            Löschen
          </Button>
        </>
      }
    />
  );
}
```

Was ein Modell aus dem Gedächtnis meist vergisst: `dismissible`, das Escape und Klicks außerhalb in ein kurzes Wackeln verwandelt, solange der Request läuft, und das Layout auf dem Smartphone: Unter 768px öffnet sich der Dialog als Bottom Sheet mit untereinander gestapelten Aktionen in voller Breite.

> Live-Demo (Dialog): Öffne den Dialog und mach das Fenster dann schmaler als 768px: Die Karte wird zu einem Bottom Sheet, das du zum Schließen nach unten ziehen kannst. Probier sie unter [Dialog](https://wingo-ui.com/components/dialog) aus und installier sie mit `npx wingo-ui@latest add dialog`.

### Prompt 2: ein Login-Screen

```text
Bau /login aus dem Wingo-UI-Block login-page, Card-Layout, Passwort und 6-stelliger E-Mail-Code,
keine Social-Buttons. Schick alles an unsere /api/auth-Routen und geh bei Erfolg zu /dashboard.
Ersetze jeden Northwind-String in den Labels durch Harbor und liste jeden Handler auf, der noch auf seinem Beispiel-Default steht.
```

Die [Login Page](https://wingo-ui.com/components/login-page) bringt Beispiel-Handler mit, damit ihre Demo läuft, und ihre Default-Labels nennen Northwind CRM. Deshalb verlangt der Prompt einen Bericht: Ohne `onVerifyCode` akzeptiert die Code-Ansicht bei jeder Person den Beispielcode 123456. Prüf, ob `layout="card"`, `methods={["password", "otp"]}`, `showProviders={false}`, `labels` mit `appName` und echte Handler für `onSignIn`, `onSendCode`, `onVerifyCode` und `onSuccess` dastehen. Ein Handler, der einen `Error` wirft, zeigt dessen Meldung im Formular. Die komplette Komponente mit diesen Handlern steht in unserem [Gemini-CLI-Setup mit shadcn](https://wingo-ui.com/de/blog/gemini-cli-shadcn-mcp).

> Live-Demo (Login Page): Gib eine beliebige E-Mail und ein Passwort mit weniger als 8 Zeichen ein, dann erscheint der Fehlerhinweis. Öffne danach Forgot password: Die E-Mail wird übernommen. Probier sie unter [Login Page](https://wingo-ui.com/components/login-page) aus und installier sie mit `npx wingo-ui@latest add login-page`.

### Prompt 3: einen selbstgebauten Spinner ersetzen

```text
Finde jeden Button in app/account, der beim Speichern seinen eigenen Spinner rendert, und ersetze ihn
durch den Wingo-UI-Button. Lies vorher seine Props mit get_component und zeig mir den Diff.
```

Die Props `loading` und `loadingText` des Buttons ersetzen das Spinner-Markup und das Jonglieren mit `disabled`, und die Breite bleibt beim Speichern gleich.

## Was geht schief, und wie behebe ich es?

- **Der Server taucht nicht in der MCP-Liste auf.** Du hast eine Datei bearbeitet, die der Agent für diesen Ordner nicht liest, oder die Liste wurde seit dem Speichern nicht neu geladen. Prüf die Scope-Tabelle oben und klick unter **This computer** auf Refresh.
- **Ein gelöschter Server kommt immer wieder.** Er steht noch in `~/.codeium/windsurf/mcp_config.json`. Entfern ihn dort oder setz `read_config_from.windsurf` auf `false`.
- **Der stdio-Server startet nicht.** Meist wartet npx auf eine Antwort zur Installation: Ergänz `-y`. Führ den Befehl im Terminal aus, um seine eigene Fehlermeldung zu sehen.
- **Ein Remote-Server verbindet sich nicht.** Lass `url` auf den Streamable-HTTP-Endpunkt zeigen (meist `/mcp`). Der Client versucht zuerst Streamable HTTP und weicht erst nach einem 404 oder 405 auf SSE unter derselben URL aus. Für einen Server, der nur SSE kann, setz also `"transport": "sse"`.
- **Ein OAuth-Server meldet, dass er eine Authentifizierung braucht.** Klick in der Liste daneben auf **Authenticate** oder führ `devin mcp login <name>` aus. Laut der [MCP-Übersicht von Devin](https://docs.devin.ai/cli/extensibility/mcp/overview) werden Tokens aus Windsurf oder Claude Code nicht übernommen, du meldest dich hier also noch einmal an.
- **Server im Team-Plan blockiert.** Enterprise-Admins können unter **Settings → Enterprise → Devin Desktop** in den MCP/ACP-Einstellungen erlaubte MCP-Server und URLs von MCP-Registries festlegen, und diese Vorgaben gehen deiner lokalen Config vor. Bitte sie, den Server freizugeben.
- **Verbunden, aber kein Quellcode.** Kein Key: Führ `npx wingo-ui@latest login` aus (ein kostenloses Konto braucht nur eine E-Mail-Adresse) und aktualisier die Liste. Button und Dialog sind kostenlos; die Login Page ist eins von über 290 Pro-Items in einem Katalog mit mehr als 360 ($8 im Monat, $80 im Jahr oder einmalig $150, auf der [Preisseite](https://wingo-ui.com/de/pricing)).

## Wo fange ich an?

Leg ein kostenloses Konto an, führ `npx wingo-ui@latest login` aus, trag den stdio-Eintrag in `~/.config/devin/mcp_config.json` ein, ergänz den Block in der `AGENTS.md` und probier Prompt 1 mit dem kostenlosen Dialog und Button aus. Die [Doku zu Coding-Agenten](https://wingo-ui.com/docs/agents) deckt die anderen Agenten ab. Dasselbe Setup für andere Editoren findest du in unserem [Antigravity-MCP-Setup](https://wingo-ui.com/de/blog/antigravity-mcp), im [Cursor-Setup mit shadcn](https://wingo-ui.com/de/blog/cursor-shadcn-mcp-rules) und im [Codex-MCP-Setup](https://wingo-ui.com/de/blog/codex-mcp-setup-react-ui), und den Rest der Serie findest du unter [UI mit KI-Agenten bauen](https://wingo-ui.com/de/blog/category/ai-agents).

## Komponenten in diesem Artikel

- [Button](https://wingo-ui.com/components/button) (Free): The React button component every screen starts with: five variants, six tones, all sizes, and a loading state that never jumps. Installation: `npx wingo-ui@latest add button`
- [Login Page](https://wingo-ui.com/components/login-page) (Pro): A React login page with password, magic link or code sign-in, Google, Apple and Microsoft buttons, two-step codes and password recovery. Installation: `npx wingo-ui@latest add login-page`
- [Dialog](https://wingo-ui.com/components/dialog) (Free): A React modal dialog for focused tasks: a spring-scaled card on desktop and a bottom sheet on phones, with nesting and scrolling. Installation: `npx wingo-ui@latest add dialog`

## Häufige Fragen

### Wo liegt die MCP-Config-Datei von Windsurf 2026?

Für den Agenten Devin Local in Devin Desktop (dem neuen Namen von Windsurf) unter ~/.config/devin/mcp_config.json für deinen Benutzer, unter %APPDATA%\devin\mcp_config.json auf Windows und in einem Projekt unter .devin/mcp_config.json oder .devin/mcp_config.local.json. Die alte ~/.codeium/windsurf/mcp_config.json wird laut Cognitions Doku standardmäßig weiter importiert, Stand 6. November 2026.

### Gibt es in Windsurf noch ein Limit von 100 MCP-Tools?

Die Grenze von 100 Tools war ein dokumentiertes Limit von Cascade, und Cascade wurde am 8. September 2026 aus Devin Desktop entfernt. Die aktuelle Doku zu Devin Local nennt kein Tool-Limit, Stand 6. November 2026. Jedes Tool-Schema kostet aber weiter Kontext, also lass nur die Server eingeschaltet, die du wirklich nutzt.

### Braucht ein Remote-Server serverUrl oder url?

Nimm url. Die Doku zur Devin CLI und zu Devin Local nennt url mit optionalem transport und headers; serverUrl stammt aus der alten Cascade-Doku, die beides akzeptiert hat.

### Funktioniert der shadcn-MCP-Server mit Windsurf?

Ja, als stdio-Eintrag, den du selbst anlegst: command npx und args -y, shadcn@latest, mcp. Die MCP-Doku von shadcn führt Windsurf und Devin Desktop nicht auf, Stand 6. November 2026, also trägst du ihn von Hand ein.

### Werden .windsurfrules und .windsurf/rules noch gelesen?

Ja. Devin Desktop liest weiterhin .windsurfrules, .windsurf/rules/*.md und AGENTS.md und bevorzugt .devin/rules/*.md, wenn beide Regelordner existieren. So steht es in seinem FAQ, Stand 6. November 2026.

---

Quelle: https://wingo-ui.com/de/blog/windsurf-mcp