How to split a song into stems from Claude with the Audial MCP server

Stem separation is usually a browser job: find the site, log in, drag the file in, wait, download a zip, unzip it, drag the files into your DAW. If you already keep an AI assistant open while you work, most of that is wasted motion. The Audial MCP server removes it. You say which file to split, the assistant runs the job, and the stems appear in a folder on your disk.

This post walks through the setup, the prompts that work, what the tool hands back, and how to get the stems onto a timeline.

What you need

Three things:

• An Audial account with an active subscription. Every tool except list_results calls the Audial API, and the API answers HTTP 402 with code SUBSCRIPTION_REQUIRED if the account has no subscription.
• Your User ID and API key from your Audial dashboard.
• The uv package manager, which runs the server without a permanent install.

Install uv first. On macOS or Linux:

curl -LsSf https://astral.sh/uv/install.sh | sh

On Windows:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Install the server

In Claude Code, one command registers it:

claude mcp add audial \
  -e AUDIAL_USER_ID=your-user-id -e AUDIAL_API_KEY=your-api-key -e AUDIAL_RESULTS_DIR=~/Audial \
  -- uvx audial-mcp

For Claude Desktop, Cursor, or any client that takes a JSON config, add this block. On macOS the Claude Desktop file is at ~/Library/Application Support/Claude/claude_desktop_config.json; on Windows it is %APPDATA%\Claude\claude_desktop_config.json. Cursor reads ~/.cursor/mcp.json.

{
  "mcpServers": {
    "audial": {
      "command": "uvx",
      "args": ["audial-mcp"],
      "env": {
        "AUDIAL_USER_ID": "your-user-id",
        "AUDIAL_API_KEY": "your-api-key",
        "AUDIAL_RESULTS_DIR": "~/Audial"
      }
    }
  }
}

If you would rather not edit config files, the Claude plugin does the same setup and prompts for your credentials:

claude plugin marketplace add AudialAI/audial-claude-plugin
claude plugin install audial@audial

Restart your client after any of these. The server is published on PyPI as audial-mcp and in the MCP registry as io.github.AudialAI/audial-mcp.

One central results folder

AUDIAL_RESULTS_DIR is the single most useful setting here. Audio does not come back inline as base64 in the conversation; every tool writes files to disk and returns paths. That keeps your assistant's context small and gives you one predictable place to look.

Results land in a per-tool, timestamped folder:

~/Audial/<tool>/<timestamp>_<name>/

So a split of midnight_take3.wav ends up somewhere like ~/Audial/stem_split/2026-10-09_142210_midnight_take3/, holding the stem files. Point AUDIAL_RESULTS_DIR at a folder your DAW already watches, or at a samples drive, and the files arrive where you want them without a second move. The default is ~/Audial.

Because every job is filed the same way, you can also ask for history later:

List my last five Audial results.

That calls list_results, which reads the folder locally and sends nothing to the API.

Example prompts

Give full paths. The tool expands ~, and it accepts .wav, .mp3, .aif, .aiff, .flac, .m4a, .ogg and .aac.

The basic one:

Split ~/Music/bootlegs/midnight_take3.wav into stems.

Picking stems:

Split ~/Music/bootlegs/midnight_take3.wav into just vocals and drums.

The stems argument takes vocals, drums, bass, other and full_song_without_vocals. The default is vocals, drums, bass and other.

Retiming or transposing while you split:

Split ~/Music/bootlegs/midnight_take3.wav into stems at 124 BPM in A minor.

That maps to target_bpm and target_key. Leave them out and the stems keep the tempo and key of the source.

Chaining work in one request is where this gets genuinely faster than a browser:

Analyze ~/Music/bootlegs/midnight_take3.wav, then split it into stems, then convert the bass stem to MIDI.

The assistant calls analyze for BPM and key, stem_split for the stems, and generate_midi on the bass file it just received a path to. You never typed a file path twice.

What comes back

A finished stem_split call returns a structured result with four parts worth knowing about:

• output_dir, the job folder described above.
• files, the list of files written into it, one per requested stem.
• metadata, the service response with the credential fields stripped out. Tempo and key are detected automatically and tagged on each stem, so this is where you read them back.
• summary, a one-line description the assistant will usually relay to you, including how long the job took.

Long jobs report progress with elapsed time while they run, and the call waits up to AUDIAL_JOB_TIMEOUT_S seconds, 900 by default. If a job fails before writing anything, the empty folder is cleaned up rather than left behind.

Getting the stems into a DAW

The stems are sample-aligned with each other, which is the part that matters for a DAW import. Drop all of them at the same bar position and they sum back to something very close to the original mix.

In Ableton Live, select every stem file in Finder or Explorer and drag them onto the arrangement at bar 1. Live creates one audio track per file. Set the project tempo to the BPM that came back from the analysis before you do anything time-based, then turn Warp off on each clip if you want the raw timing preserved.

In Logic Pro, use File then Import then Audio File, select all the stems, and choose to create new tracks. Logic will offer to adjust the project tempo if the files carry tempo information; otherwise set it by hand from the detected BPM.

In FL Studio, drag the files into the playlist as audio clips, one per track, all starting at bar 1.

Two habits that save time: keep the source mix on a muted track as a reference so you can A/B against it, and leave the stems in the job folder rather than copying them, so list_results can still find them later.

When something does not work

Four failures account for nearly all of them.

"spawn uvx ENOENT" or the server will not start. uv is not installed or not on the PATH your client sees. Install it, then restart the client rather than just the conversation.

Immediate credential errors. AUDIAL_USER_ID or AUDIAL_API_KEY is missing or wrong. Check both against your dashboard. Credentials in your MCP client config always win over any other config file on the machine.

HTTP 402 with SUBSCRIPTION_REQUIRED. The account has no active subscription. Everything except list_results needs one.

Timeouts on long jobs. Raise AUDIAL_JOB_TIMEOUT_S. Your client also keeps its own MCP log, which is the first place to look for anything else; the server writes diagnostics to stderr, and most clients capture that into the same log.

Where to go next

The same server exposes mastering, segmentation, sample packs, audio to MIDI, music generation, resynthesis and sung vocals, so stem splitting is usually the first step in a longer request rather than the whole job.

Setup details and the full tool list are on the MCP server page, the one-click plugin is at the Claude plugin page, and you can try separation in the browser first at the stem splitter.