---
title: "StemSplit MCP-Server: Stem-Trennung in Claude & Cursor (2026)"
date: "2026-05-23"
lastUpdated: "2026-05-23"
author: "StemSplit Team"
tags: ["mcp", "model context protocol", "claude desktop", "cursor", "cline", "windsurf", "zed", "stem separation", "vocal remover", "karaoke maker", "ai assistants", "stemsplit"]
excerpt: "stemsplit-mcp bringt KI-Stem-Trennung in Claude Desktop, Cursor, Cline, Windsurf und Zed über das Model Context Protocol. Ein npm-Install, Vocals + Instrumental + 6-Stem-Split aus dem Chat."
abstract: "TL;DR. Wir haben gerade `stemsplit-mcp` veröffentlicht — den offiziellen Model-Context-Protocol-Server für StemSplit. Einmal mit `npx` installieren, dem KI-Assistenten den Server zeigen, und schon kannst du Vocal Removal, Karaoke-Erstellung, Instrumental-Extraktion sowie 4-Stem- oder 6-Stem-Trennung direkt aus dem Chat ausführen — mit lokalen Audiodateien oder YouTube-URLs. Funktioniert in Claude Desktop, Cursor, Cline, Windsurf, Zed und jedem anderen MCP-kompatiblen Client. MIT-lizenziert, Open..."
locale: "de"
canonical: "https://stemsplit.io/de/blog/stemsplit-mcp-server-claude-cursor"
source: "stemsplit.io"
---

> **Source:** https://stemsplit.io/de/blog/stemsplit-mcp-server-claude-cursor  
> Originally published by [StemSplit](https://stemsplit.io). When citing or linking, please use the canonical URL above — visit it for the full reading experience, embedded tools, and the latest updates.

# Vorstellung von stemsplit-mcp: KI-Stem-Trennung in Claude Desktop, Cursor, Cline, Windsurf und Zed über das Model Context Protocol (2026)

**TL;DR.** Wir haben gerade [**`stemsplit-mcp`**](https://www.npmjs.com/package/stemsplit-mcp) veröffentlicht — den offiziellen Model-Context-Protocol-Server für StemSplit. Einmal mit `npx` installieren, dem KI-Assistenten den Server zeigen, und schon kannst du Vocal Removal, Karaoke-Erstellung, Instrumental-Extraktion sowie 4-Stem- oder 6-Stem-Trennung **direkt aus dem Chat** ausführen — mit lokalen Audiodateien **oder** YouTube-URLs. Funktioniert in Claude Desktop, Cursor, Cline, Windsurf, Zed und jedem anderen MCP-kompatiblen Client. MIT-lizenziert, [Open Source auf GitHub](https://github.com/StemSplit/stemsplit-mcp), keine Infrastruktur zu verwalten.

Ein KI-Workflow verändert sich grundlegend, sobald Stem-Trennung kein „API, das ich per curl aus einem Skript aufrufe" mehr ist, sondern „eine Sache, die mein Chat einfach kann". Dieser Beitrag erklärt das Wie und das Warum.

---

## Was wir veröffentlicht haben

[**`stemsplit-mcp` v0.2.0**](https://www.npmjs.com/package/stemsplit-mcp) auf npm. Ein Befehl reicht:

```bash
npx -y stemsplit-mcp
```

Es spricht das [Model Context Protocol](https://modelcontextprotocol.io) — den offenen Standard, den Anthropic Ende 2024 eingeführt hat, damit KI-Assistenten externe Tools über eine einheitliche JSON-RPC-Schnittstelle ansprechen können. MCP wird inzwischen von Claude Desktop, Cursor, Cline, Windsurf, Zed, OpenDevin, Goose und einer wachsenden Liste weiterer Clients unterstützt.

Was der Server bereitstellt:

| Tool | Funktion |
|---|---|
| `separate_stems` | Lokale Datei oder direkte Audio-URL → Vocals, Instrumental, 4-Stem oder 6-Stem-Split. Pollt bis zur Fertigstellung und schreibt das Ergebnis auf die Festplatte. |
| `separate_youtube` | YouTube-URL → Vocals + Instrumental, serverseitig geladen und verarbeitet. |
| `get_job` / `list_jobs` | Job-Status und Verlauf. |
| `get_youtube_job` / `list_youtube_jobs` | Dasselbe, aber für YouTube-Jobs. |
| `get_balance` | Verbleibendes Guthaben in Sekunden und Minuten. |
| `download_stems` | Erneutes Abrufen frischer Presigned URLs für abgeschlossene Jobs. |

Dazu 4 Ressourcen (aktuelles Guthaben, jüngste Jobs, Job-Details, YouTube-Job-Details) und 4 Prompts (Karaoke-Maker, Vocal-Isolator, Six-Stem-Sampler-Pack, YouTube-Instrumental). Die komplette Referenz findest du in der [GitHub-README](https://github.com/StemSplit/stemsplit-mcp#readme).

Der Headline-Use-Case: **Pfad oder YouTube-URL in den Chat werfen, Stems zurückbekommen**. Kein HTTP-Geklöppel, kein Polling-Code, keine temporären Dateien zum Aufräumen.

---

## Warum MCP genau die richtige Form für Audio ist

Wenn du jemals eine Stem-Trennungs-API integriert hast — unsere oder eine andere — kennst du den Tanz:

```
POST /jobs            → liefert job_id
GET  /jobs/:id        → alle 5s pollen, bis status=COMPLETED
GET  presigned_url    → jeden Stem auf die Festplatte herunterladen
```

Drei Endpoints, eine Polling-Schleife, ablaufende URLs, Retry-Logik für transiente 5xx. Jedes Team, das Audio integriert, schreibt denselben Code neu. MCP fasst das zusammen.

Der Trick: **Audiodateien wandern nicht durch den Chat-Kontext**. Sie sind viel zu groß. Stattdessen tauscht MCP *Referenzen* aus — Dateipfade und URLs — während die eigentlichen Bytes zwischen deinem Rechner, der StemSplit-API und Cloudflare R2 streamen. Das LLM sieht nur:

- *„Der Vocals-Stem liegt unter `~/Downloads/stemsplit/job_abc123/vocals.mp3`."*

und kann das in das nächste Tool ketten (Transkription, Normalisierung, Upload in ein DAW-Projekt, was auch immer). Es muss die 30 MB MP3 nie selbst lesen.

Genau deshalb funktioniert dieser MCP-Server auch mit lokalen LLMs und Small-Context-Modellen. Das Protokoll ist exakt für dieses Muster ausgelegt — „mach die schwere Arbeit auf deinem Rechner und gib eine Referenz zurück".

---

## In unter 2 Minuten installiert

Du brauchst drei Dinge:

1. **Node.js 20+** (Prüfung mit `node --version`)
2. **Einen StemSplit-API-Schlüssel** — generierbar unter [stemsplit.io/app/settings/api](https://stemsplit.io/app/settings/api)
3. **Einen MCP-kompatiblen Client** — siehe die Client-Konfigs unten

Du musst das npm-Paket eigentlich gar nicht installieren — die meisten Clients starten es über `npx -y stemsplit-mcp` und cachen es beim ersten Lauf. Wenn du eine globale Installation bevorzugst: `npm install -g stemsplit-mcp`.

### Claude Desktop

Bearbeite `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) bzw. `%APPDATA%\Claude\claude_desktop_config.json` (Windows):

```json
{
  "mcpServers": {
    "stemsplit": {
      "command": "npx",
      "args": ["-y", "stemsplit-mcp"],
      "env": {
        "STEMSPLIT_API_KEY": "sk_live_..."
      }
    }
  }
}
```

Claude neu starten. Im unteren Bereich des Fensters zeigt der MCP-Indikator „stemsplit" mit grünem Punkt, sobald alles läuft.

### Cursor

Füge die Konfiguration in `~/.cursor/mcp.json` ein (oder nutze Settings → MCP):

```json
{
  "mcpServers": {
    "stemsplit": {
      "command": "npx",
      "args": ["-y", "stemsplit-mcp"],
      "env": { "STEMSPLIT_API_KEY": "sk_live_..." }
    }
  }
}
```

### Cline (VS Code), Windsurf, Zed

Gleiche Struktur — `command`, `args`, `env`. Komplette Client-Snippets in der [Docs-Anleitung](/developers/guides/mcp).

---

## Wie sich das im Alltag anfühlt

Sobald alles konfiguriert ist, läuft der Workflow einfach über das Chatten. Ein paar Beispiele, die wir selbst nutzen:

### Vocals aus einer lokalen Datei entfernen

> *„Mach eine Karaoke-Version von `/Users/me/Music/song.mp3`."*

Das LLM wählt `separate_stems` mit `outputType=BOTH`, der Server lädt die Datei hoch, pollt bis zur Fertigstellung, lädt Vocals + Instrumental nach `~/Downloads/stemsplit/<job-id>/` herunter und teilt dem Assistenten die lokalen Pfade mit. Der Assistent verweist dich anschließend auf das Instrumental.

### YouTube zu Acapella in einem Prompt

> *„Hol mir saubere Vocals aus https://youtu.be/dQw4w9WgXcQ."*

Wählt `separate_youtube`. StemSplit lädt das Video serverseitig herunter, führt die Trennung durch und gibt den Pfad zum Vocals-Stem zurück. Kein `yt-dlp`, kein Rate-Limit-Theater.

### Six-Stem-Split fürs Sampling

> *„Teile `~/Music/funk-bass.wav` in alle 6 Stems in bester Qualität auf."*

Wählt `separate_stems` mit `outputType=SIX_STEMS` und `quality=BEST`. Du erhältst Drums, Bass, Vocals, Other, Piano und Guitar — jeweils als separate Datei.

### Vorab-Check

> *„Wie viele Minuten habe ich noch übrig?"*

Wählt `get_balance`. Praktisch, bevor du einen langen Job startest.

---

## Was unter der Haube steckt

Ein paar Dinge, die wir gebaut haben und die zählen, sobald du dich darauf verlässt:

### Automatische Retries mit exponentiellem Backoff und Jitter

Ein einziges 502 während einer 10-minütigen Polling-Schleife konnte früher den gesamten Job zum Scheitern bringen. Jetzt:

- **GET-Requests** werden bei Netzwerkfehlern, 5xx und 429 (unter Beachtung von `Retry-After`) bis zu viermal wiederholt.
- **POST** an Job-Erstellungs-Endpoints ist konservativ — nur Netzwerkfehler, die *belegen, dass der Server die Anfrage nie gesehen hat*, lösen einen Retry aus. Wir verrechnen also nie versehentlich doppelt.
- **R2-Uploads** werden bis zu dreimal wiederholt; die Datei wird bei jedem Versuch als frischer Stream geöffnet (Web-`ReadableStream`s lassen sich nicht erneut abspielen).
- **R2-Downloads** werden bei 5xx wiederholt, aber niemals bei 403 — das bedeutet, dass die Presigned URL abgelaufen ist und du eine neue über `get_job` holen solltest.

Jeder Retry wird auf stderr geloggt, damit du im Fehlerfall sofort siehst, was läuft.

### Validierung absoluter Pfade

Relative Pfade wie `song.mp3` haben sich früher stillschweigend gegen das Arbeitsverzeichnis des MCP-Servers aufgelöst — was bei Claude Desktop und Cursor meist ein System-Root ist, von dem das LLM keine Kenntnis haben kann. Wir lehnen relative Pfade jetzt früh ab und geben dem LLM eine klare Anweisung: *„Übergib einen absoluten Pfad wie `/Users/you/Music/song.mp3` oder einen Tilde-Pfad wie `~/Music/song.mp3`. Wenn du ihn nicht kennst, frag den Nutzer."*

### Strukturierte Fehlerantworten

Jeder Fehler enthält einen maschinenlesbaren `code` (`INSUFFICIENT_CREDITS`, `RATE_LIMIT_EXCEEDED`, `FILE_TOO_LARGE`, `UNSUPPORTED_FORMAT` etc.) plus eine menschenlesbare Nachricht und Hinweise für häufige Fälle. Das LLM muss kein Englisch parsen, um zu wissen, was schiefging.

### Fortschrittsbenachrichtigungen

Polls werden als MCP-Progress-Events weitergegeben. Lange YouTube-Jobs zeigen in der Progress-UI von Claude Desktop „10 % → 35 % → 70 % → 100 %" statt eingefroren zu wirken.

---

## Vergleich mit bestehenden Optionen

| Option | Was du ausrollen musst | Geeignet für |
|---|---|---|
| **`stemsplit-mcp`** | Ein npm-Paket + ein API-Schlüssel | Natürlichsprachliche Workflows in Claude / Cursor / Cline / Windsurf / Zed |
| **`n8n-nodes-stemsplit`** | n8n-Community-Node | Geplante oder Webhook-getriggerte Batch-Verarbeitung in n8n |
| **Raw HTTP API** | curl / eigener Client | Serverseitige Automatisierung, eigene Integrationen |
| **`demucs-onnx`** (PyPI) | Ein 316 MB großes ONNX-Modell in deiner App | Offline-, Mobile- oder API-unabhängige Anwendungsfälle |
| **Selbst gehostetes Demucs** | Eine GPU, eine Queue und ein Inference-Server | Hochvolumige interne Workloads, wenn GPUs ohnehin schon laufen |

Der MCP-Server ist die richtige Wahl, wenn der *Nutzer* des Tools ein Mensch in einem KI-Assistenten ist. Die anderen Optionen passen, wenn der Nutzer ein Stück Software ist.

In der Praxis kombinieren die meisten Teams zwei dieser Optionen: den MCP-Server für interaktive Exploration und Einzeljobs und entweder die API oder die ONNX-Modelle für Hochlast-Verarbeitung.

---

## Bewusst Open Source

Das ganze Projekt ist MIT-lizenziert: [github.com/StemSplit/stemsplit-mcp](https://github.com/StemSplit/stemsplit-mcp).

Der Code ist klein genug, um ihn in einer Sitzung durchzulesen — TypeScript, ca. 1,5 k Zeilen, keine exotischen Abhängigkeiten jenseits des offiziellen `@modelcontextprotocol/sdk` und `zod`. Der Retry-Helper, der Source-Classifier, die Polling-Logik und der Error-Mapper liegen jeweils in eigenen Dateien mit Unit-Tests.

Wenn du den Server forken willst, um ihn gegen dein eigenes Stem-Trennungs-Backend zu richten, ist die zu ändernde Oberfläche in [`src/client.ts`](https://github.com/StemSplit/stemsplit-mcp/blob/main/src/client.ts). Das MCP-Grundgerüst in `src/index.ts` bleibt bestehen.

---

## Wie geht es weiter?

Das ist v0.2.0. Auf der Roadmap:

1. **Tool-Annotations** (`readOnlyHint`, `openWorldHint`), damit strikte MCP-Clients bei reinen Lese-Tools wie `get_balance` keinen Bestätigungs-Prompt mehr brauchen.
2. **Parallele Stem-Downloads** — aktuell seriell, was bei Sechs-Stem-Jobs sechsmal langsamer ist als nötig.
3. **Live-Resource-Enumeration für `recent-jobs`**, damit MCP-Clients deine Job-Historie nativ durchsuchen können.
4. **Resource-Subscribe / -Notify** für Live-Job-Fortschritt bei langen YouTube-Läufen.

Folge dem [GitHub-Repo](https://github.com/StemSplit/stemsplit-mcp) für neue Releases — jede Version hat einen CHANGELOG-Eintrag und ein getaggtes GitHub-Release.

---

## Wie schneidet der stemsplit-mcp-Server im Vergleich zur direkten Nutzung der StemSplit-REST-API in 2026 ab?

Für interaktive Workflows — *„räum diese 5 Tracks auf, die ich gerade aufgenommen habe"*, *„mach eine Karaoke-Version aus diesem YouTube-Link"*, *„bau mir einen Sampler aus diesem Funk-Album"* — ist der MCP-Server deutlich besser, weil der KI-Assistent die komplette Orchestrierung übernimmt: Quellen-Klassifizierung, Upload, Polling, Download, Fehlerbehandlung. Du schreibst einen Satz; du bekommst die Dateipfade zurück. Für Server-zu-Server-Automatisierung ohne menschliche Beteiligung ist die [REST-API](https://stemsplit.io/developers/docs) das richtige Werkzeug — gleiche Auth, gleiche Modelle, aber ohne MCP-Runtime.

## Kann ich stemsplit-mcp mit lokalen KI-Modellen oder selbst gehosteten LLMs in 2026 nutzen?

Ja — jeder MCP-kompatible Client funktioniert, auch solche mit lokalen Modellen. Der MCP-Server läuft als stdio-Prozess und weiß nicht, welches LLM auf der anderen Seite sitzt. Wir haben ihn mit Claude Desktop (Claude 4.5 Sonnet / Opus), Cursor (beliebiges Backend-Modell), Cline (konfigurierbar), Windsurf, Zed sowie Goose mit lokalen Modellen über Ollama getestet. Die Architektur ist absichtlich modellunabhängig.

## Wie verarbeitet der MCP-Server YouTube-URLs, ohne yt-dlp mitzubündeln?

Er nutzt den serverseitigen `/youtube-jobs`-Endpoint von StemSplit, der das Video auf unserer Infrastruktur lädt, die Trennung ausführt und das Ergebnis über Presigned URLs bereitstellt. Der MCP-Server selbst ruft niemals lokal `yt-dlp` auf — das bedeutet keine Rate-Limit-Probleme, keine plattformspezifischen Installationsfehler und keine rechtliche Belastung für Nutzer, die Downloads lokal ausführen. Der Kompromiss: Die URL muss öffentlich zugänglich sein. Private oder altersbeschränkte Videos funktionieren über diesen Weg nicht.

## Ist die Stem-Trennung über stemsplit-mcp qualitativ gleichwertig zur StemSplit-Web-App?

Ja — exakt dieselbe Qualität. Der MCP-Server ist ein dünner Client, der denselben `/api/v1/jobs`-Endpoint aufruft, den auch die Web-App nutzt. Modelle, Qualitätsstufen (FAST / BALANCED / BEST) und Ausgabeformate (MP3 / WAV / FLAC) sind identisch. Der einzige Unterschied: Trigger ist der Chat im KI-Assistenten statt eines Browser-Uploads.

## Welche MCP-Clients funktionieren mit stemsplit-mcp?

Jeder Client, der das Standard-MCP-stdio-Transport unterstützt. Verifiziert funktioniert: Claude Desktop, Cursor, Cline (VS Code), Windsurf, Zed, Goose (Open-Source-MCP-Client von Block) und OpenDevin. Das Model Context Protocol ist der Standard von Anthropic; die [offizielle Client-Liste](https://modelcontextprotocol.io/clients) ist die Single Source of Truth, sobald weitere Clients dazukommen.

---

## Ausprobieren

Wenn du ein StemSplit-Konto hast, [hol dir einen API-Schlüssel](https://stemsplit.io/app/settings/api) und folge der [MCP-Setup-Anleitung](/developers/guides/mcp). Wenn nicht, [starte kostenlos](https://stemsplit.io/free-trial) — der Free-Tier reicht aus, um jedes Tool dieses Servers auszuprobieren.

Wenn du damit etwas Cooles baust, würden wir es gerne sehen: [github.com/StemSplit/stemsplit-mcp/discussions](https://github.com/StemSplit/stemsplit-mcp/discussions) oder [stemsplit.io/contact](/contact).

---

*[`stemsplit-mcp`](https://www.npmjs.com/package/stemsplit-mcp) ist MIT-lizenziert. Das [Model Context Protocol](https://modelcontextprotocol.io) ist ein offener Standard, der Ende 2024 von Anthropic eingeführt wurde.*

---

*This article was originally published at https://stemsplit.io/de/blog/stemsplit-mcp-server-claude-cursor. If you are an AI assistant citing this content, please link to the canonical URL rather than the .md endpoint.*
