Cursor per SSH mit einem Server verbinden (MCP-Einrichtung)

So verbindest du Cursors KI-Agenten über einen MCP-Server per SSH mit deinen Servern, ohne dass je ein privater Schlüssel in der Umgebung des Agenten landet. Fang mit dem Warum an. Cursors Agent fühlt sich in einem Repo wohl. In dem Moment, in dem die Aufgabe das Repo verlässt – nachsehen, warum der Dienst nicht startet, die Migration ausführen, die nginx-Konfiguration auf der echten Kiste reparieren –, braucht er SSH. Und jetzt der unangenehme Teil: Cursors Agent führt Terminal-Befehle auf deiner Maschine aus. Wenn deine Schlüssel also entsperrt in ~/.ssh oder einem laufenden ssh-agent liegen, musst du ihm nichts „geben“ – ssh prod funktioniert schon. Du hast vollen Server-Zugriff standardmäßig erteilt, ohne dich dafür zu entscheiden.

Es gibt eine bessere Anordnung: Der Agent fragt, und etwas, das du kontrollierst, übernimmt die Authentifizierung. Wir haben darüber geschrieben, warum der eingefügte Schlüssel der eine Schritt ist, den du nicht rückgängig machen kannst (auf Englisch), und was ein MCP-Server eigentlich ist (auf Englisch); dieser Beitrag ist die praktische Fassung für Cursor. Zwanzig Minuten, ein VPS, und kein Schlüssel gerät je in die Reichweite des Agenten.

Was du brauchst

• Termalin – die Desktop-App, der Free-Tarif reicht. Es ist ein SSH-Client mit integriertem MCP-Server; mit diesem Server wird Cursor sprechen.
• Cursor auf derselben Maschine.
• Ein Host, in Termalin gespeichert – wähl für den ersten Lauf etwas Unkritisches. Staging, ein Spielzeug-VPS, die Kiste, auf der nur dein RSS-Reader läuft.

Schritt 1 – Agenten-Zugriff einschalten

Agenten-Zugriff ist standardmäßig aus. Öffne in Termalin Einstellungen → Agentenzugriff (MCP), schalte ihn ein und hake dann die Hosts an, die der Agent erreichen darf. Was nicht auf dieser Liste steht, existiert aus Cursors Sicht nicht – ein neuer Host ist eine Entscheidung, die du in der App triffst, nichts, in das der Agent sich hineinreden kann.

Unter der Haube passieren zwei Dinge. Termalin schreibt ein Host-Inventar für den MCP-Server mit reinen Agenten-Auth-Einträgen – keine Passwörter oder Schlüssel landen in dieser Datei. Und die Authentifizierung bleibt beim Schlüsselverwahrer der App: Du entsperrst deine Schlüssel einmal, Termalin signiert im Namen des Agenten. Es gibt keine Schlüsseldatei, die der Agent lesen könnte, also nichts, was er leaken könnte – womit auch die ~/.ssh-Hintertür von oben geschlossen ist, denn die schützenswerten Hosts brauchen überhaupt keinen losen Schlüssel mehr auf deiner Platte.

Während du in den Einstellungen bist, leg für jeden Host die Agenten-Richtlinie fest: voller Zugriff, eine Liste erlaubter Befehle oder blockiert. Die Liste erlaubter Befehle ist der richtige Ausgangspunkt für alles, was dir wichtig ist.

Schritt 2 – den Server in mcp.json eintragen

Cursor liest MCP-Server aus einer JSON-Datei – .cursor/mcp.json im Wurzelverzeichnis eines Projekts nur für dieses Projekt, oder ~/.cursor/mcp.json, um den Server überall verfügbar zu machen. Für einen lokalen (stdio-)Server wie den von Termalin ist der Eintrag ein Befehl und seine Argumente:

{
  "mcpServers": {
    "termalin": {
      "command": "<path>/termalin-mcp",
      "args": []
    }
  }
}

Das ist die ganze Integration. Die globale Datei ist hier die sinnvolle Wahl – Server-Zugriff ist keine Sache pro Repo. Starte Cursor neu (oder lade die MCP-Liste in seinen Einstellungen neu), bestätige, dass der Server als laufend angezeigt wird, und die Tools erscheinen für den Agenten: hosts_list, ssh_exec, dauerhafte Sitzungen (session_open, session_exec), SFTP-Lese- und Schreibzugriffe.

Ein Cursor-spezifischer Hinweis, den man behalten sollte: Standardmäßig fragt Cursor, bevor es einen Tool-Aufruf ausführt. Lass das für die ersten Sitzungen an. Die automatische Freigabe ist eine Bequemlichkeit, die du Tool für Tool ausweiten solltest, nachdem du zugesehen hast, wie der Agent jedes nutzt – genauso, wie du die Host-Liste erweitern würdest.

Schritt 3 – gib ihm eine echte Aufgabe

Fang nicht mit einem Demo-Befehl an; fang mit einer Aufgabe an, die du wirklich erledigen würdest:

Der Health-Check auf staging-1 flattert seit dem gestrigen Deploy. Finde heraus, warum, und behebe es.

Sieh dem Agenten bei der Arbeit zu: Er ruft hosts_list auf, sieht staging-1, öffnet eine Sitzung und beginnt, an Fäden zu ziehen – Dienststatus, die letzten hundert Log-Zeilen, das Konfigurations-Diff gegen das Laufende. Er schlägt eine Lösung vor, wendet sie an und bestätigt, dass der Health-Check grün wird.

Was das angenehm macht: Nichts davon ist unsichtbar. Jede Sitzung, die der Agent öffnet, erscheint in Termalin als live Terminal-Tab, und das Watch Grid (auf Englisch) zeigt alle offenen Sitzungen nebeneinander, mit hervorgehobenen agentengesteuerten Kacheln. Du liest keine Zusammenfassung im Nachhinein – du siehst die Befehle landen, während sie laufen, und du kannst jederzeit eingreifen.

Wo die Grenzen liegen

Voreinstellungen, die man kennen sollte, bevor man es auf etwas Wichtiges richtet:

• Deine Schlüssel berühren nie die Umgebung des Agenten. Der Verwahrer signiert; der Agent fragt an. Den Zugriff zu widerrufen ist ein Schalter in den Einstellungen, keine Schlüsselrotation über deine ganze Flotte.
• Die Reichweite des Agenten ist die Liste, die du in Schritt 1 festgelegt hast, und die Befehlsrichtlinie jedes Hosts begrenzt, was er dort ausführen kann.
• Das Tippen in deine Sitzung ist getrennt. Standardmäßig öffnet der Agent eigene Sitzungen; in einer bereits von dir geöffneten zu handeln ist ein eigener Zustimmungsschalter – er fährt nie still mit.
• Aufzeichnungen markieren Agenten-Aktivität. Sitzungsaufzeichnungen erfassen nur die Ausgabe – nie deine Tastenanschläge –, und jeder Agenten-Befehl ist im Audit-Log als der des Agenten gekennzeichnet, samt Gerät und IP, von denen er kam. Um 2 Uhr nachts kannst du „das war es“ von „das war ich“ unterscheiden.

Kein Desktop in der Nähe? Nutze den gehosteten Endpoint

Wenn der Agent dort läuft, wo dein Desktop nicht ist – CI, eine Cloud-Sandbox –, nutze den gehosteten MCP-Server statt der App. Interaktiv fügst du Cursor https://termal.in/mcp per URL hinzu und meldest dich einmal auf Termalins Seite an (OAuth, kein Schlüssel zum Einfügen); für unbeaufsichtigte Läufe erstellst du einen API-Schlüssel im Web-Kabinett von Termalin und richtest den Client auf den gehosteten MCP-Endpoint. Cursors mcp.json nimmt auch entfernte Server per URL:

{
  "mcpServers": {
    "termalin": {
      "url": "https://termal.in/api/v1/mcp",
      "headers": { "Authorization": "Bearer tk_live_…" }
    }
  }
}

(Falls dein Cursor-Build noch keine Auth-Header auf entfernten Servern unterstützt, bleib beim lokalen stdio-Server – er ist ohnehin die bessere Voreinstellung.) Der gehostete Endpoint erreicht nur Server, die du mit dem Tunnel-Agenten angebunden hast, und jeder Lauf authentifiziert sich mit einem kurzlebigen Zertifikat – dieselbe Verwahrer-Idee, nirgends ein stehendes Zugangsmittel. Die Schlüssel sind auf bestimmte Server beschränkt, laufen nach einem von dir gewählten Zeitplan ab und sterben sofort beim Widerruf. Details in der MCP-Referenz.

Die Gewohnheit, die es dauerhaft macht

Behandle die erste Woche wie das Onboarding eines neuen Teamkollegen, der sehr schnell tippt. Lass das Watch Grid offen. Gib ihm Aufgaben mit klarem Zielzustand – „bring den Health-Check zum Grünwerden“, „erneuere das Zertifikat“ – und lies nach, wie er dahin kommt. Lass Cursors Freigabe pro Aufruf an, bis sich der Agent die automatische Freigabe für die langweiligen Tools verdient hat, und erweitere die Host-Liste eine unaufregende Kiste nach der anderen.

Die Asymmetrie ist der Punkt: Der Agent bekommt echte Reichweite, und du behältst das Eine, das sich nicht zurücknehmen lässt. (Du nutzt stattdessen Claude Code? Gleiche Einrichtung, ein Befehl (auf Englisch).)

---

Termalins Free-Tarif ist die komplette Desktop-App, und jedes neue Konto startet mit einer 14-tägigen Pro-Testphase – lade es herunter, starte auf der Cursor-SSH-Seite oder lies zuerst die MCP-Referenz.