Cursor IDE mit MCP-Servern erweitern: So binden Sie Tools nativ ein

Mit dem Model Context Protocol (MCP) erhält der KI-Code-Editor Cursor Zugriff auf externe Ent­wick­lungs­werk­zeu­ge, APIs und Da­ten­quel­len. Der in­te­grier­te KI-Agent kann dadurch bei­spiels­wei­se Dateien außerhalb des Projekts lesen, Da­ten­bank­in­for­ma­tio­nen abrufen oder externe Dienste nutzen. MCP-Server erweitern so die Mög­lich­kei­ten der KI-ge­stütz­ten Soft­ware­ent­wick­lung.

Was steckt hinter der MCP-In­te­gra­ti­on in Cursor?

Als MCP-In­te­gra­ti­on in Cursor be­zeich­net man die native Ein­bin­dung von Servern über das Model Context Protocol (MCP) in den KI-Code-Editor. Dadurch erhält der in­te­grier­te KI-Agent auch außerhalb des ge­öff­ne­ten Workspace-Ver­zeich­nis­ses stan­dar­di­sier­ten Zugriff auf externe Ent­wick­lungs­werk­zeu­ge, APIs und lokale Da­ten­quel­len. Die ver­füg­ba­ren Funk­tio­nen lassen sich direkt in Ent­wick­lungs­auf­ga­ben einbinden.

MCP bildet dabei die Schnitt­stel­le zwischen Cursor und den an­ge­bun­de­nen Systemen. Ein MCP-Server stellt bei­spiels­wei­se Funk­tio­nen zum Lesen von Dateien, zum Abrufen von Da­ten­bank­in­for­ma­tio­nen oder zur Kom­mu­ni­ka­ti­on mit externen Diensten bereit. Cursor kann diese Funk­tio­nen bei Bedarf über den KI-Agenten aufrufen.

Wie lassen sich MCP-Server in Cursor kon­fi­gu­rie­ren?

Die Ver­wal­tung von MCP-Servern erfolgt in Cursor über „Customize“ → „MCPs“ in der Sei­ten­leis­te. Dort lassen sich ver­füg­ba­re Server durch­su­chen, hin­zu­fü­gen sowie ak­ti­vie­ren oder de­ak­ti­vie­ren. Über den Cursor Mar­ket­place können un­ter­stütz­te In­te­gra­tio­nen direkt in­stal­liert werden. Al­ter­na­tiv lassen sich MCP-Server manuell über die JSON-Kon­fi­gu­ra­ti­ons­da­tei mcp.json ein­rich­ten. Dafür stehen zwei Spei­cher­or­te zur Verfügung:

• Pro­jekt­spe­zi­fisch: .cursor/mcp.json im Stamm­ver­zeich­nis des Projekts. Die Kon­fi­gu­ra­ti­on gilt für den je­wei­li­gen Workspace.
• Global: ~/.cursor/mcp.json im Be­nut­zer­ver­zeich­nis. Die dort ein­ge­tra­ge­nen Server stehen pro­jekt­über­grei­fend zur Verfügung.

Cursor un­ter­stützt drei Trans­port­ar­ten für die Kom­mu­ni­ka­ti­on mit MCP-Servern:

Für lokal aus­ge­führ­te Ent­wick­lungs­werk­zeu­ge bietet sich stdio an. Für entfernte MCP-Server empfiehlt sich Strea­ma­ble HTTP. Der ältere SSE-Transport gilt in­zwi­schen als veraltet, wird von Cursor aber weiterhin aus Kom­pa­ti­bi­li­täts­grün­den un­ter­stützt.

Schritt-für-Schritt-Anleitung: MCP-Server in Cursor ein­rich­ten

Die Ein­rich­tung lässt sich anhand des of­fi­zi­el­len File­sys­tem-MCP-Servers de­mons­trie­ren. Dieser stellt Werkzeuge bereit, mit denen der Cursor-Agent Dateien und Ver­zeich­nis­se außerhalb des ge­öff­ne­ten Projekts lesen, durch­su­chen und be­ar­bei­ten kann. Der Zugriff wird auf die für den Server frei­ge­ge­be­nen Ver­zeich­nis­se be­schränkt.

Schritt 1: Vor­aus­set­zun­gen prüfen

Für die Ein­rich­tung werden eine aktuelle Cursor-In­stal­la­ti­on sowie Node.js und der zu­ge­hö­ri­ge Pa­ket­ma­na­ger npm benötigt. Der File­sys­tem-MCP-Server lässt sich an­schlie­ßend über npx starten, ohne dass das Paket zuvor separat in­stal­liert werden muss.

Über­prü­fen Sie zunächst im Terminal, ob Node.js und npm verfügbar sind:

node --version
npm --version

Beide Befehle sollten die jeweils in­stal­lier­te Ver­si­ons­num­mer ausgeben. Erstellen Sie an­schlie­ßend ein Ver­zeich­nis, auf das der MCP-Server zugreifen soll, bei­spiels­wei­se C:\MCP-Daten unter Windows oder /home/user/mcp-daten unter Linux. Das Ver­zeich­nis muss bereits exis­tie­ren, bevor der Server gestartet wird.

Schritt 2: MCP-Kon­fi­gu­ra­ti­ons­da­tei erstellen

Öffnen Sie Ihr Projekt in Cursor und erstellen Sie im Pro­jekt­stamm­ver­zeich­nis den Ordner .cursor, sofern dieser noch nicht vorhanden ist. Legen Sie darin die Datei mcp.json an. Fügen Sie für Windows folgende Kon­fi­gu­ra­ti­on ein:

{
  "mcpServers": {
    "filesystem": {
      "type": "stdio",
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "C:\\MCP-Daten"
      ]
    }
  }
}

Unter macOS oder Linux kann der Server bei­spiels­wei­se so kon­fi­gu­riert werden:

{
  "mcpServers": {
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/home/user/mcp-daten"
      ]
    }
  }
}

Passen Sie den Ver­zeich­nis­pfad an Ihr System an. Unter Windows können Sie npx über cmd /c starten, um mögliche Aus­füh­rungs­pro­ble­me zu umgehen. Der Parameter -y er­mög­licht die au­to­ma­ti­sche Be­stä­ti­gung einer ge­ge­be­nen­falls er­for­der­li­chen Pa­ke­t­in­stal­la­ti­on.

Schritt 3: Kon­fi­gu­ra­ti­ons­fel­der verstehen

Die Datei mcp.json enthält die Angaben, die Cursor für die Ver­bin­dung zum MCP-Server benötigt.

Für den gezeigten File­sys­tem-Server werden type, command und args verwendet. Die Felder url und headers sind dagegen für entfernte MCP-Server relevant.

Schritt 4: Ver­bin­dung in Cursor über­prü­fen

Speichern Sie die Kon­fi­gu­ra­ti­ons­da­tei und starten Sie Cursor neu, damit die Kon­fi­gu­ra­ti­on ein­ge­le­sen wird. Öffnen Sie an­schlie­ßend „Customize“ → „MCPs“ und über­prü­fen Sie, ob der Server filesystem angezeigt wird und aktiviert ist. Cursor sollte die vom Server be­reit­ge­stell­ten Werkzeuge erkennen.

Der File­sys­tem-MCP-Server stellt unter anderem Funk­tio­nen zum Auflisten von Ver­zeich­nis­sen, zum Lesen von Dateien und zum Be­ar­bei­ten von Da­tei­in­hal­ten bereit. Welche Ver­zeich­nis­se zu­gäng­lich sind, richtet sich nach den Start­ar­gu­men­ten und ge­ge­be­nen­falls den vom MCP-Client über­mit­tel­ten Roots. Über­mit­telt der Client gültige Roots, können diese die ur­sprüng­lich kon­fi­gu­rier­ten Ver­zeich­nis­frei­ga­ben ersetzen. Mit dem Tool list_allowed_directories lässt sich über­prü­fen, ob das ge­wünsch­te Ver­zeich­nis tat­säch­lich frei­ge­ge­ben ist.

Wie lassen sich MCP-Tools im Cursor-Agent verwenden?

Nach der er­folg­rei­chen Ein­rich­tung stehen die frei­ge­ge­be­nen MCP-Tools im Cursor-Agent zur Verfügung. Der Agent kann sie anhand der Auf­ga­ben­stel­lung selbst­stän­dig auswählen und aufrufen. Dies funk­tio­niert sowohl bei einfachen Anfragen im Chat als auch bei kom­ple­xe­ren Ent­wick­lungs­auf­ga­ben, bei denen mehrere Dateien ana­ly­siert oder verändert werden.

Mit dem ein­ge­rich­te­ten File­sys­tem-MCP-Server lässt sich bei­spiels­wei­se folgende Anfrage stellen:

„Lies die Dateien im freigegebenen Verzeichnis MCP-Daten und fasse die enthaltenen Konfigurationsinformationen zusammen.“

Cursor kann daraufhin die ver­füg­ba­ren File­sys­tem-Tools nutzen, um das Ver­zeich­nis zu durch­su­chen und die re­le­van­ten Dateien aus­zu­le­sen. Ebenso lassen sich Aufgaben for­mu­lie­ren, bei denen In­for­ma­tio­nen aus externen Dateien in die Ent­wick­lung eines Projekts ein­flie­ßen.

Cursor zeigt MCP-Tool-Aufrufe direkt im Chat an. Die über­ge­be­nen Argumente und Er­geb­nis­se lassen sich auf­klap­pen. Einzelne Tools können über die Werk­zeug­lis­te aktiviert oder de­ak­ti­viert werden. Stan­dard­mä­ßig fordert Cursor vor MCP-Tool-Aufrufen eine Be­stä­ti­gung an. Unter „Settings“ → „Agents“ → „Approvals & Execution“ lässt sich festlegen, welche Aufrufe au­to­ma­tisch aus­ge­führt werden dürfen. Im Modus „Auto-review“ werden frei­ge­ge­be­ne Tools un­mit­tel­bar aus­ge­führt, während andere Aufrufe einer au­to­ma­ti­schen Si­cher­heits­prü­fung un­ter­lie­gen.

Häufige Fehler bei der MCP-Ver­bin­dung beheben

Falls ein MCP-Server nicht startet oder seine Werkzeuge nicht verfügbar sind, sollten zunächst folgende Feh­ler­quel­len überprüft werden:

• Feh­ler­haf­te Befehle oder Pfade: Kon­trol­lie­ren Sie, ob der unter command an­ge­ge­be­ne Befehl aus­ge­führt werden kann. Ge­ge­be­nen­falls muss der voll­stän­di­ge Pfad zur aus­führ­ba­ren Datei angegeben werden. Auch die in args ver­wen­de­ten Ver­zeich­nis­se müssen exis­tie­ren.
• Fehlende Um­ge­bungs­va­ria­blen: Prüfen Sie, ob benötigte Zu­gangs­da­ten oder Kon­fi­gu­ra­ti­ons­wer­te in der Cursor-Lauf­zeit­um­ge­bung verfügbar sind. Für lokale Server können diese über env oder envFile be­reit­ge­stellt werden.
• Feh­ler­haf­te JSON-Kon­fi­gu­ra­ti­on: Kon­trol­lie­ren Sie die Syntax der Datei mcp.json, ins­be­son­de­re An­füh­rungs­zei­chen, Kommata und korrekt maskierte Windows-Pfade.
• Ver­bin­dungs- oder Au­then­ti­fi­zie­rungs­feh­ler: Über­prü­fen Sie bei ent­fern­ten MCP-Servern die kon­fi­gu­rier­te URL sowie er­for­der­li­che Zu­gangs­da­ten und Be­rech­ti­gun­gen. Cursor un­ter­stützt für die Au­then­ti­fi­zie­rung auch OAuth.

Zur genaueren Feh­ler­su­che stehen Ihnen de­tail­lier­te Logs zur Verfügung. Öffnen Sie das Output-Panel und wählen Sie im Dropdown-Menü „MCP Logs“. Dort lassen sich unter anderem Fehler beim Ser­ver­start, Ver­bin­dungs­pro­ble­me und fehl­ge­schla­ge­ne Tool-Aufrufe nach­voll­zie­hen.

Fazit: MCP erweitert die Mög­lich­kei­ten von Cursor

Durch die In­te­gra­ti­on von MCP-Servern kann Cursor zu­sätz­li­che Ent­wick­lungs­werk­zeu­ge und Da­ten­quel­len direkt in KI-gestützte Ar­beits­ab­läu­fe ein­be­zie­hen. Der Agent ist dadurch nicht aus­schließ­lich auf den ge­öff­ne­ten Pro­jekt­kon­text an­ge­wie­sen, sondern kann bei ent­spre­chen­der Be­rech­ti­gung auch externe In­for­ma­tio­nen abrufen und Aktionen ausführen. Die Ein­rich­tung erfolgt entweder über den Cursor Mar­ket­place oder manuell über die Datei mcp.json. Lokale Server lassen sich mit stdio anbinden, während für entfernte Dienste HTTP-basierte Trans­port­ar­ten zur Verfügung stehen.