# 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 Entwicklungswerkzeuge, APIs und Datenquellen. Der integrierte KI-Agent kann dadurch beispielsweise Dateien außerhalb des Projekts lesen, Datenbankinformationen abrufen oder externe Dienste nutzen. MCP-Server erweitern so die Möglichkeiten der KI-gestützten Softwareentwicklung.

## Was steckt hinter der MCP-Integration in Cursor?

Als MCP-Integration in Cursor bezeichnet man die native Einbindung von Servern über das [Model Context Protocol (MCP)](https://www.ionos.de/digitalguide/server/knowhow/model-context-protocol/) in den KI-Code-Editor. Dadurch erhält der integrierte [KI-Agent](https://www.ionos.de/digitalguide/websites/web-entwicklung/ki-agenten/) auch außerhalb des geöffneten Workspace-Verzeichnisses **standardisierten Zugriff** auf externe Entwicklungswerkzeuge, APIs und lokale Datenquellen. Die verfügbaren Funktionen lassen sich direkt in Entwicklungsaufgaben einbinden.

MCP bildet dabei die **Schnittstelle** zwischen Cursor und den angebundenen Systemen. Ein MCP-Server stellt beispielsweise Funktionen zum Lesen von Dateien, zum Abrufen von Datenbankinformationen oder zur Kommunikation mit externen Diensten bereit. Cursor kann diese Funktionen bei Bedarf über den KI-Agenten aufrufen.

## Wie lassen sich MCP-Server in Cursor konfigurieren?

Die Verwaltung von MCP-Servern erfolgt in Cursor über „Customize“ → „MCPs“ in der Seitenleiste. Dort lassen sich verfügbare Server durchsuchen, hinzufügen sowie aktivieren oder deaktivieren. Über den Cursor Marketplace können unterstützte Integrationen direkt installiert werden. Alternativ lassen sich MCP-Server manuell über die [JSON](https://www.ionos.de/digitalguide/server/knowhow/was-ist-json/)-Konfigurationsdatei `mcp.json` einrichten. Dafür stehen zwei Speicherorte zur Verfügung:

- **Projektspezifisch**: `.cursor/mcp.json` im Stammverzeichnis des Projekts. Die Konfiguration gilt für den jeweiligen Workspace.
- **Global**: `~/.cursor/mcp.json` im Benutzerverzeichnis. Die dort eingetragenen Server stehen projektübergreifend zur Verfügung.

Cursor unterstützt **drei Transportarten für die Kommunikation mit MCP-Servern**:

<table>
  <thead>
    <tr>
      <th>Transportart</th>
      <th>Funktionsweise</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>stdio</td>
      <td>Cursor startet einen lokalen MCP-Server über einen Kommandozeilenbefehl, beispielsweise mit Node.js, npx oder Python. Die Kommunikation erfolgt über Standardeingabe und Standardausgabe.</td>
    </tr>
    <tr>
      <td>SSE</td>
      <td>Cursor verbindet sich über einen HTTP-Endpunkt mit einem MCP-Server, der Server-Sent Events für die Kommunikation verwendet.</td>
    </tr>
    <tr>
      <td>Streamable HTTP</td>
      <td>Cursor kommuniziert über einen HTTP-Endpunkt mit einem MCP-Server. Das neuere Transportverfahren unterstützt HTTP-basierte Anfragen und optional das Streaming von Antworten.</td>
    </tr>
  </tbody>
</table>

Für lokal ausgeführte Entwicklungswerkzeuge bietet sich stdio an. Für entfernte MCP-Server empfiehlt sich Streamable HTTP. Der ältere SSE-Transport gilt inzwischen als veraltet, wird von Cursor aber weiterhin aus Kompatibilitätsgründen unterstützt.

## Schritt-für-Schritt-Anleitung: MCP-Server in Cursor einrichten

Die Einrichtung lässt sich anhand des offiziellen Filesystem-MCP-Servers demonstrieren. Dieser stellt Werkzeuge bereit, mit denen der Cursor-Agent Dateien und Verzeichnisse außerhalb des geöffneten Projekts lesen, durchsuchen und bearbeiten kann. Der Zugriff wird auf die für den Server freigegebenen Verzeichnisse beschränkt.

### Schritt 1: Voraussetzungen prüfen

Für die Einrichtung werden eine aktuelle Cursor-Installation sowie [Node.js](https://www.ionos.de/digitalguide/websites/web-entwicklung/einfuehrung-in-nodejs/) und der zugehörige Paketmanager npm benötigt. Der Filesystem-MCP-Server lässt sich anschließend über `npx` starten, ohne dass das Paket zuvor separat installiert werden muss.

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

```bash
node --version
npm --version
```

Beide Befehle sollten die jeweils installierte Versionsnummer ausgeben. Erstellen Sie anschließend ein Verzeichnis, auf das der MCP-Server zugreifen soll, beispielsweise C:\MCP-Daten unter Windows oder /home/user/mcp-daten unter Linux. Das Verzeichnis muss bereits existieren, bevor der Server gestartet wird.

### Schritt 2: MCP-Konfigurationsdatei erstellen

Öffnen Sie Ihr Projekt in Cursor und erstellen Sie im **Projektstammverzeichnis** den Ordner `.cursor`, sofern dieser noch nicht vorhanden ist. Legen Sie darin die Datei `mcp.json` an. Fügen Sie für Windows folgende Konfiguration ein:

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

Unter macOS oder Linux kann der Server beispielsweise so konfiguriert werden:

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

Passen Sie den Verzeichnispfad an Ihr System an. Unter Windows können Sie npx über cmd /c starten, um mögliche Ausführungsprobleme zu umgehen. Der Parameter -y ermöglicht die automatische Bestätigung einer gegebenenfalls erforderlichen Paketinstallation.

### Schritt 3: Konfigurationsfelder verstehen

Die Datei `mcp.json` enthält die Angaben, die Cursor für die Verbindung zum MCP-Server benötigt.

<table>
  <thead>
    <tr>
      <th>Feld</th>
      <th>Bedeutung</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>mcpServers</td>
      <td>Enthält die konfigurierten MCP-Server.</td>
    </tr>
    <tr>
      <td>filesystem</td>
      <td>Frei wählbarer Name des Servers innerhalb der Konfiguration.</td>
    </tr>
    <tr>
      <td>type</td>
      <td>Legt den Transporttyp fest, hier stdio.</td>
    </tr>
    <tr>
      <td>command</td>
      <td>Gibt den ausführbaren Befehl zum Starten des Servers an.</td>
    </tr>
    <tr>
      <td>args</td>
      <td>Enthält die Argumente für den Startbefehl, einschließlich des freigegebenen Verzeichnisses.</td>
    </tr>
    <tr>
      <td>env</td>
      <td>Optionales Feld zur Übergabe von Umgebungsvariablen.</td>
    </tr>
    <tr>
      <td>envFile</td>
      <td>Optionaler Pfad zu einer Datei mit Umgebungsvariablen für lokale stdio-Server.</td>
    </tr>
    <tr>
      <td>url</td>
      <td>Gibt bei HTTP- oder SSE-Servern den Verbindungsendpunkt an.</td>
    </tr>
    <tr>
      <td>headers</td>
      <td>Ermöglicht bei HTTP-Verbindungen die Übergabe zusätzlicher Header, beispielsweise eines [API-Keys](https://www.ionos.de/digitalguide/websites/web-entwicklung/api-key/) für die Authentifizierung.</td>
    </tr>
  </tbody>
</table>

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

### Schritt 4: Verbindung in Cursor überprüfen

Speichern Sie die Konfigurationsdatei und starten Sie Cursor neu, damit die Konfiguration eingelesen wird. Öffnen Sie anschließend „Customize“ → „MCPs“ und überprüfen Sie, ob der Server `filesystem` **angezeigt** wird und **aktiviert** ist. Cursor sollte die vom Server bereitgestellten Werkzeuge erkennen.

Der Filesystem-MCP-Server stellt unter anderem Funktionen zum Auflisten von Verzeichnissen, zum Lesen von Dateien und zum Bearbeiten von Dateiinhalten bereit. Welche Verzeichnisse zugänglich sind, richtet sich nach den Startargumenten und gegebenenfalls den vom MCP-Client übermittelten Roots. Übermittelt der Client gültige Roots, können diese die ursprünglich konfigurierten Verzeichnisfreigaben ersetzen. Mit dem Tool `list_allowed_directories` lässt sich überprüfen, ob das gewünschte Verzeichnis tatsächlich freigegeben ist.

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

Nach der erfolgreichen Einrichtung stehen die freigegebenen MCP-Tools im Cursor-Agent zur Verfügung. Der Agent kann sie anhand der Aufgabenstellung selbstständig auswählen und aufrufen. Dies funktioniert sowohl bei einfachen Anfragen im Chat als auch bei komplexeren Entwicklungsaufgaben, bei denen mehrere Dateien analysiert oder verändert werden.

Mit dem eingerichteten Filesystem-MCP-Server lässt sich beispielsweise folgende Anfrage stellen:

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

Cursor kann daraufhin die verfügbaren Filesystem-Tools nutzen, um das Verzeichnis zu durchsuchen und die relevanten Dateien auszulesen. Ebenso lassen sich Aufgaben formulieren, bei denen **Informationen aus externen Dateien in die Entwicklung eines Projekts einfließen**.

Cursor zeigt **MCP-Tool-Aufrufe direkt im Chat** an. Die übergebenen Argumente und Ergebnisse lassen sich aufklappen. Einzelne Tools können über die Werkzeugliste aktiviert oder deaktiviert werden. Standardmäßig fordert Cursor vor MCP-Tool-Aufrufen eine Bestätigung an. Unter „Settings“ → „Agents“ → „Approvals &amp; Execution“ lässt sich festlegen, welche Aufrufe automatisch ausgeführt werden dürfen. Im Modus „Auto-review“ werden freigegebene Tools unmittelbar ausgeführt, während andere Aufrufe einer automatischen Sicherheitsprüfung unterliegen.

## Häufige Fehler bei der MCP-Verbindung beheben

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

- **Fehlerhafte Befehle oder Pfade**: Kontrollieren Sie, ob der unter `command` angegebene Befehl ausgeführt werden kann. Gegebenenfalls muss der vollständige Pfad zur ausführbaren Datei angegeben werden. Auch die in `args` verwendeten Verzeichnisse müssen existieren.
- **Fehlende Umgebungsvariablen**: Prüfen Sie, ob benötigte Zugangsdaten oder Konfigurationswerte in der Cursor-[Laufzeitumgebung](https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-eine-laufzeitumgebung/) verfügbar sind. Für lokale Server können diese über `env` oder `envFile` bereitgestellt werden.
- **Fehlerhafte JSON-Konfiguration**: Kontrollieren Sie die Syntax der Datei `mcp.json`, insbesondere Anführungszeichen, Kommata und korrekt maskierte Windows-Pfade.
- **Verbindungs- oder Authentifizierungsfehler**: Überprüfen Sie bei entfernten MCP-Servern die konfigurierte URL sowie erforderliche Zugangsdaten und Berechtigungen. Cursor unterstützt für die Authentifizierung auch [OAuth](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-oauth/).

Zur genaueren Fehlersuche stehen Ihnen detaillierte [Logs](https://www.ionos.de/digitalguide/online-marketing/web-analyse/logfiles-die-protokolle-der-computerprozesse/) zur Verfügung. Öffnen Sie das Output-Panel und wählen Sie im Dropdown-Menü „MCP Logs“. Dort lassen sich unter anderem Fehler beim Serverstart, Verbindungsprobleme und fehlgeschlagene Tool-Aufrufe nachvollziehen.

Hinweis Bei der Einbindung externer MCP-Server sollten die Berechtigungen möglichst eng begrenzt werden. Zugangsdaten gehören nicht direkt in gemeinsam genutzte Konfigurationsdateien. Insbesondere bei Tools mit Schreib- oder Löschrechten empfiehlt es sich, die angeforderten Aktionen vor der Ausführung zu überprüfen.

## Fazit: MCP erweitert die Möglichkeiten von Cursor

Durch die Integration von MCP-Servern kann Cursor zusätzliche Entwicklungswerkzeuge und Datenquellen direkt in KI-gestützte Arbeitsabläufe einbeziehen. Der Agent ist dadurch nicht ausschließlich auf den geöffneten Projektkontext angewiesen, sondern kann bei entsprechender Berechtigung auch externe Informationen abrufen und Aktionen ausführen. Die Einrichtung erfolgt entweder über den Cursor Marketplace oder manuell über die Datei `mcp.json`. Lokale Server lassen sich mit `stdio` anbinden, während für entfernte Dienste HTTP-basierte Transportarten zur Verfügung stehen.


This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/cursor-mcp/](https://www.ionos.de/digitalguide/server/konfiguration/cursor-mcp/) for AI/LLM consumption.