Skip to main content
Glama

ableton-mcp

MCP server that lets an MCP client (Claude Code) drive Ableton Live 12.1+ (Lite included) through a stdlib-only Remote Script. It also builds and reads presets for the free Vital synth, and has an offline .mid writer. Both work with Live closed.

Tested on Live 12.1.10 Lite (embedded Python 3.11.6) and Vital 1.5.5, macOS. Builds in Session View; arrange_scenes lays scenes out on the Arrangement and play_arrangement plays it.

How it works

  • remote_script/AbletonMCP/: Live loads this as a Control Surface. It listens on 127.0.0.1 on a random port. It writes {port, token} to ~/.ableton-mcp/connection.json (mode 0600) and removes the file when Live quits. On each Live timer tick (~100 ms) it handles up to 64 pending JSON-lines requests on Live's main thread. Each change is one undo step. A request that arrives after its deadline is refused, so a timed-out write never lands late.

  • src/ableton_mcp/: the MCP server (stdio). It reads connection.json on every call and never retries a request.

  • src/ableton_mcp/vital.py: Vital has no remote control, so the Vital tools write .vital preset files (plain JSON) to ~/Music/Vital/User/Presets/, where Vital's browser finds them. If the Vital app is closed, the tool starts it with the new preset. Inside Live, load Vital on a track and pick the preset in its browser. Format notes: docs/vital-mcp-research.md.

Related MCP server: ableton-live-mcp

Install

Requires uv and Live 12.1 or newer.

uv sync
uv run ableton-mcp install-script          # copies the script to ~/Music/Ableton/User Library/Remote Scripts/AbletonMCP
# other User Library location: uv run ableton-mcp install-script --user-library "/path/to/User Library"

Restart Live. Open Settings → Link, Tempo & MIDI, and pick AbletonMCP in a Control Surface slot (leave Input/Output as None). Log.txt (~/Library/Preferences/Ableton/Live 12.x.y/Log.txt) should then show AbletonMCP listening on 127.0.0.1:<port> (Python 3.11.x).

Re-run install-script and restart Live after every change to remote_script/.

Register with Claude Code:

claude mcp add ableton -- uv --directory /path/to/ableton-mcp run ableton-mcp

Optional: analyze_sample (tempo and key from a sample's audio) needs the hearing extra, which installs librosa with numpy, scipy, scikit-learn, numba and soundfile. The base install stays mcp only.

uv sync --extra hearing

Check the whole setup:

uv run ableton-mcp doctor    # add --user-library "/path/to/User Library" if you installed elsewhere

It checks the Live app version, Live's Log.txt, the installed script against the repo, connection.json, a read-only hello to Live, and the Claude Code registration (claude mcp get ableton). Each line is PASS, WARN, FAIL or SKIP, and each FAIL or WARN prints its fix. Exit code 1 means at least one FAIL.

Check the bridge without an MCP client:

uv run ableton-mcp call hello
uv run ableton-mcp call browse '{"root":"drums","path":[]}'

Tools

uv run ableton-mcp runs the stdio server with 41 tools, in this order:

Tool

What it does

Read-only

live_status

Live version, edition, features, edition limits (audio_midi_tracks, scenes; null = no cap); error if the installed Remote Script is out of date

yes

get_set_overview

Tempo, tracks, devices, Drum Rack pads (drum_pads), clip slots, each track's mix, scenes, return_tracks

yes

create_midi_track

Add a MIDI track (refused in Lite once 8 audio+MIDI tracks exist)

no

create_audio_track

Add an audio track, for audio clips (same Lite 8-track check)

no

create_midi_clip

Empty MIDI clip in a slot (length in beats)

no

delete_track

Delete a track with its clips and devices; refuses group tracks (destructive, one undo step)

no

delete_clip

Delete the clip in a slot (destructive, one undo step)

no

create_scene

Add a scene at an index, or copy_of a scene with its clips (copy goes directly below; refused in Lite at 16 scenes)

no

copy_clip

Copy a clip to an empty slot; an occupied target is refused

no

write_notes

Replace all notes in a clip (beats; pitches from drum_pads; destructive)

no

read_notes

Clip length and notes, in the shape write_notes takes

yes

read_clip

A clip's markers, loop, looping; for audio also file, gain (raw + dB text), pitch, warping, warp mode and the modes it allows

yes

set_clip

Trim (start/end markers), loop, and on audio clips gain, pitch, warping and warp mode, by name; warping goes in its own call; all-or-nothing, one undo step

no

set_scale

Set the Set's key (root + scale) and turn on Scale Mode; the melodic generators default to it

no

create_drum_pattern

Drum beat in a style (rock, house, hip_hop, trap, reggaeton, breakbeat), plus optional Euclidean layers, on a Drum Rack track or to a .mid (destructive)

no

create_bassline

Bassline from scale degrees, one per bar (patterns: quarters, eighths, octaves, offbeat, arpeggio), into a slot or a .mid (destructive)

no

create_chord_progression

Held root-position chords from scale degrees (optional sevenths), into a slot or a .mid (destructive)

no

browse_library

List one level of Live's browser

yes

load_from_library

Load a browser item onto a track; returns device_index of the first added device

no

load_instrument

Load an instrument by kind (drift, simpler, impulse, drum_rack, ...), optionally a preset by name; refuses non-Lite kinds on Lite

no

read_device

A device's parameters (name, raw value, min/max, Live's display text, switch items) and a rack's chains; device_path reaches into racks

yes

set_device_parameters

Set several parameters of one device by name, in one undo step; all-or-nothing

no

list_samples

Audio files under an absolute folder, recursively (hidden and .asd files skipped), sorted by path and capped by limit (default 100; scan a subfolder for big libraries), with total; each with duration_s (PCM WAV, or any format with the hearing extra; else null) and filename guesses at role, kind (loop, one_shot, unknown), bpm and key; works without Live

yes

analyze_sample

Tempo (bpm with bpm_half / bpm_double, and bpm_loop: the whole-bar tempo for a loop) and key (key such as "A minor", key_confidence) estimated from an absolute file_path's audio, plus duration_s; needs the hearing extra; works without Live

yes

create_audio_clip

Put a library sample (samples / user_library root + path) or an absolute file_path into an empty Session slot of an audio track; reports warping and length_beats (Live 12.4+)

no

replace_sample

Swap the sample of a Simpler, by device_path or by Drum Rack pad_note (destructive, one undo step; Live 12.4+)

no

set_simpler

A Simpler's playback mode (Classic, One-Shot, Slicing), slicing style, beat division, sensitivity, region count, slicing playback mode, warping and warp mode; optional reverse / crop (destructive with crop); returns slice_count and slice_times_s; by device_path or pad_note, one undo step

no

insert_device

Add a native Live device (e.g. Limiter, Channel EQ) after the existing ones, or at index, without replacing the instrument; track="main" is the Main track (Live 12.3+)

no

delete_device

Remove one device (effect or instrument) by device_path, also inside rack chains; track="main" is the Main track (destructive, one undo step)

no

set_track_mix

Set a track's volume (dB), pan (-50..50), mute, solo and sends (dB, by return letter); one undo step

no

set_clip_envelope

Automate a Session clip's own track volume (dB), pan (-50..50) or send A.. (dB), or with device_path a parameter of a device on that track by its read_device name (raw min..max, or an item name for a switch), from points [{time, value}] (beats, rising, inside the clip): ramps in 1/16-note steps (a switch holds each point's item), holds the last value to the clip end; replaces that envelope, points=[] clears it; all-or-nothing (destructive, one undo step; Live 12.4+)

no

set_label

Rename and/or colour a track, a clip (track + slot) or a scene

no

set_tempo

Set BPM (20-999)

no

play_clip

Fire a clip

no

fire_scene

Launch every clip in a scene (not an undo step)

no

stop

Stop playback

no

arrange_scenes

Lay scenes end to end on the Arrangement from bar 1 as sections [{scene, bars}] (bars 1-256, 4/4); each clip repeats to fill its section, an empty slot is silent; returns each section's start_bar and total_bars. A non-empty Arrangement is refused unless replace=true, which deletes its clips first (destructive, one undo step; Live 12.4+)

no

play_arrangement

Stop all Session clips and play the Arrangement from from_bar (default 1, 4/4); not an undo step. Needs features.arrangement in live_status (Live 12.4+)

no

undo_last

Undo the last change

no

write_midi_file

Write a .mid to ~/Music/ableton-mcp/midi/ without Live

no

vital_create_preset

Build a Vital synth preset (controls, modulation routes, saw/square/triangle/sine waves, a silent or white-noise sample) in ~/Music/Vital/User/Presets/ without Live; opens the Vital app with it if the app is closed

no

vital_read_preset

Controls, routes, wavetable names and sample name of a .vital preset, by name or path

yes

If Live or the Remote Script is not reachable, or the script reports an error, the tool returns an isError result with the reason.

Tools that delete tracks or clips (arrange_scenes with replace=true deletes the Arrangement's clips), replace a clip's notes or an envelope (set_clip_envelope), or write a generated clip (create_drum_pattern, create_bassline, create_chord_progression replace any clip in the target slot) carry destructive_hint: true, so the client can ask before it runs them. Every other write tool carries destructive_hint: false.

Lessons and resources

The server also sends instructions to the agent once per session (src/ableton_mcp/lessons.py). They tell it to check Live before changing anything, explain each change in plain words, reuse tracks under Lite's limits, offer undo_last, and remind you once to press Cmd+S at the end of a task that changed the Set.

Guided lessons are MCP prompts. In Claude Code, type / and pick one. They take no arguments: the lesson asks you instead.

Command

What you build

/ableton:lesson-first-beat

A one-bar drum loop: kick, snare, hi-hats, tempo

/ableton:lesson-notes-and-scales

Hear a scale, compare major and minor, pick a key

/ableton:lesson-chords

A four-chord progression in your key

/ableton:lesson-bassline

A bassline that follows the chords

/ableton:lesson-melody

A short melody over the chords

/ableton:lesson-song-structure

Song sections as scenes, played in order

/ableton:explain-my-set

A plain-words tour of your Set; changes nothing

/ableton:make-track-from-samples

A 2-4 minute arranged track from your own sample folder

The lessons follow the chapter order of Ableton's Learning Music and link each chapter for hands-on practice. The site states no licence, so the lesson texts are our own words and only link to it.

Full track from your samples

/ableton:make-track-from-samples (or asking "make a track from my samples") asks for an absolute sample folder and a genre, then:

  1. Scans the folder with list_samples, and runs analyze_sample on loops whose names give no BPM or key. Without the hearing extra it passes on the install hint and goes on from the filename guesses.

  2. Sets the tempo and key from the main loop with set_tempo and set_scale.

  3. Puts the drum one-shots in one Drum Rack (load_instrument, replace_sample per pad, create_drum_pattern), and each loop on an audio track (create_audio_track, create_audio_clip). Loops are warped and looped with set_clip so their length divides each section. It stays within Lite's 8 tracks and 16 scenes.

  4. Builds scenes Intro, Build, Drop, Break and Outro, and varies them with create_scene copies, copy_clip, delete_clip and set_clip.

  5. Adds a build-up to the Build clips with set_clip_envelope: a volume rise, or an Auto Filter cutoff sweep (insert_device, read_device).

  6. Lays out Intro, Build, Drop, Break, Drop, Outro with arrange_scenes, sized for 2-4 minutes (minutes = bars x 4 / BPM), and plays it with play_arrangement.

It adds no locators. Save with Cmd+S and render with File > Export Audio/Video in Live.

Two read-only resources return the same JSON as their tools. Attach one to a message with @:

  • @ableton:live://capabilities: same as live_status.

  • @ableton:live://set/overview: same as get_set_overview.

The ableton: prefix is the name the server was registered under (claude mcp add ableton ... in Install). Under another name, the commands and mentions use that name instead.

Limits

  • Live Lite allows 8 audio+MIDI tracks. create_midi_track and create_audio_track check this before they call Live; free a track with delete_track or reuse one.

  • Live Lite allows 16 scenes. create_scene checks this before it calls Live; name and reuse empty scenes with set_label.

  • Live Lite allows 2 return tracks (A and B). Return and Main track mixing is not supported; set_track_mix covers audio, MIDI and group tracks. insert_device and delete_device are the only tools that take track="main".

  • Volume and send levels are in dB. In get_set_overview, null means -inf (silent). set_track_mix takes numbers only; to silence a track, use mute.

  • Solo is not exclusive: set_track_mix(solo=true) does not unsolo other tracks. Unsolo them yourself.

  • Colours are 10 names (red, orange, yellow, lime, green, cyan, blue, purple, pink, grey). Live snaps each to the nearest colour in its chooser.

  • live_status compares the Remote Script's protocol version with the server's. After an upgrade, run install-script again and restart Live.

  • read_notes does not return mute or probability, so a read_notes + write_notes round trip resets them. Notes that start at or after the clip length never play; write_notes reports them as notes_outside_clip.

  • drum_pads comes from the first Drum Rack on the track: top level first, then one level inside other racks (many Lite kits wrap their Drum Rack in an Instrument Rack). Deeper nesting is not searched.

  • The LOM cannot save the Set. Press Cmd+S yourself.

  • Devices load only through the browser (load_from_library, load_instrument), so a load replaces the current instrument and is one undo step. insert_device adds native Live devices by name without replacing anything; it refuses plug-ins, and Lite lacks some devices (e.g. EQ Eight: use Channel EQ). live_status features reports insert_device, replace_sample, audio_clip, arrangement (gates arrange_scenes) and clip_envelopes (gates set_clip_envelope); those tools refuse before calling Live when theirs is false. play_arrangement is not gated.

  • load_instrument kinds: drift, simpler, impulse, drum_rack, drum_sampler and instrument_rack are in every edition. operator, wavetable, analog and meld (use drift) and sampler (use simpler) are refused on Lite before Live is called. On Standard/Suite they load by browser name; that path is untested.

  • load_instrument presets: it searches the kind's browser folder and each folder one level below it (drum_rack: the drums root), one browse call per folder (14 for Drift on Lite). The first name match in browser order wins; the result returns the loaded path. Other presets: browse_library + load_from_library.

  • Device parameters are raw values between min and max, not units. Read display (Live's own text) after a set and adjust. display_value (Live 12.2+) is not used. A parameter with enabled: false is controlled by a macro or locked; set_device_parameters refuses it.

  • Some Core Library rack presets (e.g. "Basic Analog Bass", "808 Drifter") hide their chains: Live shows only the macros and the LOM reports chains: []. Use the macros. Racks with visible chains (e.g. "Ahlimba Kit") can be read inside with device_path [0, chain, device].

  • A .mid from write_midi_file holds notes only. Drop it on a track with an instrument, or it plays silent. It never overwrites an existing file; reuse of a name returns an error.

  • Vital presets are files: Vital has no remote control, so the agent cannot tweak a sound live or hear it. vital_create_preset opens the Vital standalone with the preset only when Vital is closed (a second launch would start a second instance). If Vital is open, or runs inside Live, pick the preset in Vital's preset browser under User. Vital's --render crashes on 1.5.5, so there is no offline preview. Presets never overwrite an existing file. Waves are saw, square, triangle and sine only. The sample source plays silence or 1 s of white noise (a loop you may hear as a repeat on long notes); no audio files. 94 common controls are accepted, including the comb and formant filter controls, and unknown names are refused.

  • load_from_library with an instrument replaces the track's current instrument. undo_last restores it.

  • Generators are 4/4 only and refuse a Set in another signature. Their .mid files are always 4/4 at 120 BPM.

  • Scales: Major, Minor, Dorian, Phrygian, Lydian, Mixolydian, Locrian, Harmonic Minor, Melodic Minor, Major Pentatonic, Minor Pentatonic, Minor Blues. Any other name is refused before Live is called. create_chord_progression needs a 7-note scale.

  • create_drum_pattern picks each voice's pad by a keyword in the pad name first (e.g. "Kick", "Snare", "Hihat Closed"), then by its General MIDI note (36 kick, 38 snare, 42 closed hat, 46 open hat, ...) if no other voice claims that pad by name. Kits with odd or empty pad names can leave voices unresolved; the result lists them in missing_voices.

  • Generators replace the clip in the target slot as one undo step. They never create tracks or load instruments. Melodic clips need an instrument on the track, or they play silent.

  • Samples: the server finds a samples name by exact file name in Live's Core Library, ~/Music/Ableton/Factory Packs and the User Library (a full folder walk per call). A name found twice is refused with the paths; pass one as file_path. user_library paths are joined onto the User Library folder. Only .wav, .aif, .aiff, .flac, .mp3 and .ogg files are taken.

  • Clips are made in Session slots; arrange_scenes copies them onto the Arrangement. It refuses, before placing anything, a clip whose length does not divide its section (Live cannot trim an Arrangement copy: loop the clip with set_clip), an unwarped audio clip (its length is in seconds), and an Arrangement that already has clips unless replace=true. Group tracks are skipped. It adds no locators: Live 12.4 placed none when set_or_delete_cue ran after setting the song time while stopped. Other Arrangement editing is not supported. create_audio_clip leaves warping to Live; set_clip then changes markers, loop, gain, pitch, warping and warp mode. Warp markers are not supported.

  • set_clip_envelope refuses unwarped audio clips and writes Session clip envelopes only (Live has none for Arrangement clips) and only for the clip's own track: its volume, pan, sends and the parameters of its devices. Device parameter values are raw (read_device min..max), not units, and a ramp is linear in raw units, so a cutoff sweep may not sound even. Ramps are 1/16-note steps, not smooth curves. Before the first point the envelope holds the control's value at write time. arrange_scenes copies keep the envelope: checked 2026-11-10 on Live 12.4.16 Lite, a volume rise and an Auto Filter sweep both play in the Arrangement.

  • analyze_sample is an estimate. Beat trackers often land on half or double the tempo, so it returns both candidates; the key often comes out as its relative major or minor (A minor vs C major). It reads the whole file, a few seconds each. Without the hearing extra it returns the install command instead.

  • Live has no API to reverse an audio clip: load the sample into a Simpler and use set_simpler(reverse=true). "Slice to Drum Rack" has no API either: set_simpler slices inside one Simpler instead.

  • Turning warping off converts an audio clip's markers from beats to seconds (4 beats became 2 s at 120 BPM on 12.4.16), so set_clip takes warping in its own call; read_clip it before setting markers.

  • set_clip gain is Live's raw 0..1; Live's dB curve is undocumented, so the result shows Live's own gain_display text instead of converting.

  • If Live shows a modal dialog, calls time out. A timed-out change may still have run: check get_set_overview before retrying.

Manual smoke checklist (real Live)

  1. Upgrade only: with the old script still installed, live_status returns the install-script hint.

  2. install-script, restart Live, select AbletonMCP. Log.txt shows AbletonMCP listening and Python 3.11. doctor prints no FAIL and exits 0.

  3. call hello shows your Live version, edition (variant) and protocol_version: 9.

  4. call browse '{"root":"drums","path":[]}' lists the drum kits.

  5. In Claude Code, ask "make a 1-bar 4/4 drum beat on a new track and play it". You get a new track, a kit, a clip with notes, and sound. Cmd+S still saves.

  6. undo_last removes only the last tool's change.

  7. Lite only: with 8 tracks, asking for another returns the edition-limit error and Live shows no dialog. In Claude Code, "add a bass track" makes the agent delete or reuse a track.

  8. call get_overview shows drum_pads names (e.g. "Kick", "Snare") for a kit track. call get_notes '{"track":N,"slot":0}' lists the drum clip's notes.

  9. call delete_track '{"track":N}' removes the track; one call undo restores it with its clip and kit.

  10. Quit Live. get_set_overview returns the Control Surface hint, and write_midi_file still writes a .mid that you can drag into Live.

  11. A uv run python -c loop calls LiveClient().call("set_scale", ...) for each of the 12 scales and prints any whose returned intervals differ from theory.SCALES. It prints nothing; the MIDI editor highlights the last scale.

  12. On an 808 Core Kit track, create_drum_pattern(style="house", bars=2, track=0, slot=1) returns no missing_voices and plays as house. One undo_last removes the clip. On an occupied slot, one undo_last restores the old clip and its notes.

  13. Load a Lite kit with empty pad names (e.g. "Ahlimba Kit"). create_drum_pattern(style="rock") resolves kick, snare and closed_hat.

  14. In a fresh Claude Code session, "make a hip hop beat, a bassline and chords in A minor" calls set_scale, create_drum_pattern, create_bassline and create_chord_progression (no write_notes). All three clips play in key.

  15. With Live closed, "write me a house beat as a MIDI file" writes a .mid in ~/Music/ableton-mcp/midi/ that plays on a kit when dragged in.

  16. call get_overview (read-only) shows mix.volume_db 0.0 and pan 0 for a default track, return_tracks A/B with their names, and 8 scenes. A dB parse error shows here, before any setter runs.

  17. set_track_mix(track=0, volume_db=-6, pan=25, sends={"A": -12}): Live shows -6.0 dB, 25R and send A at -12 dB. One undo_last restores all three.

  18. create_scene(copy_of=0) adds a copy below scene 0 with the same clips. fire_scene(scene=1) plays that row.

  19. set_label with color="red" on a track, a clip and a scene shows red in Live. copy_clip into an empty slot plays. Cmd+S still saves.

  20. Lite only: with 16 scenes, create_scene returns the Lite error and Live shows no dialog.

  21. In Claude Code, "turn my loop into a song with intro, verse and chorus" names the scenes, copies or varies the clips, colours them by role and fires the scenes in order.

  22. call get_device '{"track":1,"device_path":[0]}' on a rack preset (e.g. "Basic Analog Bass") lists its macro parameters and chains: [] (its chains are hidden). On "Ahlimba Kit", [0,0,0] reaches the Drum Rack and [0,0,1] the Saturator. No display is blank.

  23. In Claude Code, "put a Drift on track 5" calls load_instrument(4, "drift") and track 5 shows Drift. "load the Deep Bass preset on track 6" loads it with one load_instrument call and no browse_library.

  24. set_device_parameters on two Drift parameters: the returned display matches Live's UI. One undo_last restores both.

  25. Lite only: "use Operator for the lead" gets the refusal, and the agent loads Drift instead.

  26. uv run python -c "import asyncio; from ableton_mcp import server; print(asyncio.run(server.mcp.read_resource('live://capabilities')))" shows your Live version, edition and limits ("audio_midi_tracks": 8 on Lite).

  27. In Claude Code, after /mcp reconnect: typing /lesson lists the six /ableton:lesson-* commands, /ableton:explain-my-set and /ableton:make-track-from-samples are there, and typing @ableton: offers both live:// resources.

  28. /ableton:lesson-first-beat builds a playing beat step by step, explains the drum roles and tempo, links the Beats chapter, and ends with one Cmd+S reminder and the next lesson's command. /ableton:explain-my-set makes no write tool call.

  29. In a fresh session with no lesson, "add an open hi-hat on the off-beats" gets a plain-words summary of the change and one save reminder at the end, not one after each tool call.

  30. With the Vital app closed, ask Claude Code for "a warm detuned supersaw pad". Vital opens with the new preset, and its values match the tool call. With Vital open, the same request starts no second instance, and the preset is in the browser under User. In Live, Vital loaded with load_from_library plays the preset with notes from create_chord_progression.

  31. With the Vital app closed, ask for "a plucked string from a noise burst". The sample panel shows White Noise on, filter 1 shows a comb style, and C3 and C4 ring at different pitches and decay like a pluck. Then ask for "a vowel 'ah' to 'ee' formant pad": filter 1 shows Formant with AOIE or AIUO, and moving the vowel pad in Vital changes the vowel from where the tool set it.

  32. Live 12.4+: live_status shows features.audio_clip, insert_device and replace_sample all true.

  33. Load the Garage Kit. read_device on a pad's chain (via device_path) shows the pad device's class_name: OriginalSimpler means replace_sample(pad_note=...) works on that kit.

  34. insert_device(track="main", device_name="Limiter") adds a Limiter on Main. One undo_last removes it. On Lite, device_name="EQ Eight" returns the native-devices hint. On a track that has an instrument, device_name="Drift" is refused ("Device chains cannot have more than one instrument each") and nothing changes. 33a. delete_device(track="main", device_path=[0]) removes that Limiter; the result lists the devices left. One undo_last brings it back. device_path=[0, 0, 1] on a rack with visible chains removes device 1 of chain 0.

  35. On an audio track, create_audio_clip(root="samples", path=["Atmos Calm 130 bpm.wav"]) plays in time at the Set's tempo; the result shows warping and length_beats.

  36. On the Garage Kit track, replace_sample(pad_note=36, root="samples", path=["<a Kick from browse_library samples>"]) changes the kick's sound. One undo_last brings the old kick back.

  37. create_audio_track(name="Loops") adds an audio track named "Loops". One undo_last removes it.

  38. On that track, create_audio_clip with a drum loop from the library, then set_clip(start_marker=4, end_marker=8, loop_start=4, loop_end=8, looping=true, pitch_coarse=-2, warp_mode="Complex"): the clip plays bar 2 only, 2 semitones down. read_clip shows the same values.

  39. Load a Simpler with load_instrument(kind="simpler"), replace_sample a drum loop into it, then set_simpler(device_path=[0], playback_mode="Slicing", slicing_style="Beat", slicing_beat_division="1/8"): slice_count > 1. A clip with note 36 plays the first slice, 37 the second.

  40. set_simpler(device_path=[0], reverse=true) plays the sample backwards. One undo_last restores it.

  41. Live 12.4 Lite: live_status shows features.arrangement: true. With a Session clip playing and material in the Arrangement, play_arrangement(from_bar=3) stops the Session clip, turns off Back to Arrangement and plays the Arrangement from bar 3. undo_last does not undo it.

  42. Live 12.4 Lite: with clips in scenes 0 and 1, arrange_scenes(sections=[{"scene":0,"bars":4},{"scene":1,"bars":8}]) shows 12 bars of clips in Arrangement View, each scene's clips repeated to fill its section. play_arrangement plays them. Calling it again returns the replace=true hint; with replace=true the old layout is replaced. One undo_last removes the whole layout.

  43. With the hearing extra, analyze_sample(file_path="<a loop whose name says its BPM>") gives that BPM as bpm_loop, or as bpm, bpm_half or bpm_double (no Live needed). Checked 2026-11-10 on Live 12.4 Lite's Core Library Samples/Loops (170 files with a BPM in their name): bpm_loop matched 158, the beat tracker 83.

  44. Live 12.4 Lite: live_status shows features.clip_envelopes: true. On a 16-beat Session clip, set_clip_envelope(track=0, slot=0, parameter="volume", points=[{"time":0,"value":-24},{"time":16,"value":0}]) returns steps: 64; the clip's Envelopes box shows a stepped volume rise over 4 bars, and it is audible when the clip plays. One undo_last removes it.

  45. Live 12.4 Lite: on a track with an Auto Filter after its instrument and a 16-beat Build clip in slot 0, read_device on the Auto Filter shows the cutoff name and range (Frequency). set_clip_envelope(track=0, slot=0, device_path=[1], parameter="Frequency", points=[{"time":0,"value":<near min>},{"time":16,"value":<max>}]) returns steps: 64; the clip's Envelopes box shows the Auto Filter cutoff rising, and the sweep is audible when the clip plays. A misspelled name returns a "did you mean" error. One undo_last removes it.

  46. Live 12.4 Lite: /ableton:make-track-from-samples on your own sample folder gives a 2-4 minute Arrangement with named sections that plays from start to end, then reminds you once of Cmd+S and File > Export Audio/Video.

Development

uv sync --extra hearing
uv run pytest -q

Without the extra, the librosa tests skip. CI (.github/workflows/test.yml) installs the extra and runs the suite on Python 3.11 (Live's embedded version, librosa 0.11) and 3.13 (librosa 1.0) for every push to main and every pull request. Keep src/ and remote_script/ working on 3.11.

License

MIT, see LICENSE. Some design patterns come from other MIT-licensed Live projects. They were re-implemented here, and no code was copied.

Available Tools

27 tools
browse_libraryA
Read-only

List one level of Live's browser. root is one of: instruments, drums, audio_effects, midi_effects, sounds, samples, clips, packs, user_library, plugins, max_for_live, current_project. path is the folder names to open, e.g. []. Navigate one level at a time: add one folder name per call.

Inputs: root (required), path.

copy_clipA

Copy the clip in track/slot to the empty slot to_track/to_slot, e.g. to reuse a loop in another scene. An occupied target is refused: delete_clip it first. A MIDI clip needs a MIDI target track.

Inputs: slot (required), track (required), to_slot (required), to_track (required).

create_basslineA
Destructive

Write a bassline in a key. degrees are scale degrees, one per bar, cycled (default [1]; e.g. [1, 6, 4, 5]). bars defaults to len(degrees). root and scale default to the Set's scale (see set_scale); without Live, give both. octave 1 puts A at MIDI 45. The track needs an instrument (e.g. a bass synth), or the clip plays silent. Destination: track + slot writes a clip into Live and replaces any clip in that slot (one undo_last restores it); file_name instead writes a 120 BPM .mid file to ~/Music/ableton-mcp/midi/ and works with Live closed. Never creates tracks. 4/4 only.

Inputs: bars, name, root, slot, +6 more.

create_chord_progressionA
Destructive

Write held root-position chords built from scale degrees, e.g. [1, 6, 4, 5] in C Major gives C Am F G. The result's chords names each chord. Needs a 7-note scale (not the pentatonics or Minor Blues). root and scale default to the Set's scale (see set_scale); without Live, give both. The track needs an instrument. Destination: track + slot writes a clip into Live and replaces any clip in that slot (one undo_last restores it); file_name instead writes a 120 BPM .mid file to ~/Music/ableton-mcp/midi/ and works with Live closed. Never creates tracks. 4/4 only.

Inputs: degrees (required), name, root, slot, +6 more.

create_drum_patternA
Destructive

Write a drum beat in a style, repeated over bars. The track must hold a Drum Rack kit; hits go to the pads that match each voice (kick, snare, hats...), and voices the kit lacks are listed in missing_voices. layers add Euclidean rhythms, e.g. {voice: "perc", pulses: 3, steps: 8}; a layer replaces the style's part for that voice. style null with layers gives layers only. The result's about explains the style for a beginner. Destination: track + slot writes a clip into Live and replaces any clip in that slot (one undo_last restores it); file_name instead writes a 120 BPM .mid file to ~/Music/ableton-mcp/midi/ and works with Live closed. Never creates tracks. 4/4 only.

Inputs: bars, name, slot, style, +3 more.

create_midi_clipB

Create an empty MIDI clip in an empty clip slot of a MIDI track. Length is in beats (4 beats = 1 bar in 4/4).

Inputs: slot (required), track (required), name, length_beats.

create_midi_trackA

Add a new MIDI track. index -1 puts it at the end. Live Lite allows only 8 audio+MIDI tracks, so reuse an existing empty track when you can.

Inputs: name, index.

create_sceneA

Add a scene (a row of clip slots across all tracks). index -1 or none puts it at the end. copy_of copies that scene with all its clips and puts the copy directly below it; later scenes shift down by one. Give index or copy_of, not both. Live Lite allows only 16 scenes, so name and reuse empty scenes when you can.

Inputs: name, index, copy_of.

delete_clipA
Destructive

Delete the clip in this clip slot. One undo_last restores it.

Inputs: slot (required), track (required).

delete_trackA
Destructive

Delete a track with its clips and devices. One undo_last restores it. Use it to free a track under Live Lite's 8-track limit. Group tracks are refused. Later tracks' indices shift down by one, so call get_set_overview again before the next delete.

Inputs: track (required).

fire_sceneA

Launch every clip in this scene (one song section). Live starts the transport if it is stopped. Not an undo step.

Inputs: scene (required).

get_set_overviewA
Read-only

Describe the open Set: tempo, time signature, playing state, and every track with its index, type, devices and clip slots. Indices are 0-based. drum_pads lists {note, name} for each used pad of the track's Drum Rack (null when the track has none): use those notes as pitches in write_notes. Each track's mix is {volume_db, pan, mute, solo, sends}: dB values with null = -inf, pan -50..50 (50L..50R), sends keyed by return letter ("A", "B"...). scenes lists {index, name}; return_tracks lists {send, name, devices}.

Inputs: no named parameters.

live_statusA
Read-only

Check that Live is reachable. Returns the Live version, edition ("Lite", "Standard", "Suite") and supported features. Call this first. limits gives the edition's caps: audio_midi_tracks and scenes (null = no cap).

Inputs: no named parameters.

load_from_libraryA

Load a browser item onto a track, e.g. a drum kit from root "drums". path must end at an item that browse_library marked is_loadable. Returns the names of the devices that were added and device_index, the position of the first one (use [device_index] as device_path in read_device). Loading an instrument replaces the track's current instrument; undo_last restores it. For instruments and their presets, load_instrument does this in one call.

Inputs: path (required), root (required), track (required).

load_instrumentA

Put an instrument on a MIDI track, replacing its current instrument; undo_last restores it. Without preset you get the bare device. preset is a preset name from the kind's browser folders, e.g. drift "Deep Bass" or drum_rack "808 Core Kit" (a kit); case and the .adv/.adg ending are ignored. Live Lite has drift, simpler, impulse, drum_rack, drum_sampler and instrument_rack only; other kinds are refused there. Returns the added devices, device_index (for read_device) and the browser root and path that were loaded.

Inputs: kind (required), track (required), preset.

play_clipB

Start playing the clip in this slot. Live starts the transport if it is stopped.

Inputs: slot (required), track (required).

read_deviceA
Read-only

Read one device's parameters: {index, name, value, min, max, display, quantized, enabled}; switches (quantized) also list their choices in items. display is Live's own text for the value, e.g. "1.20 kHz". device_path defaults to [0], the track's first device (get_set_overview lists the devices). Add [chain, device] to go into a rack: [0, 0, 1] is device 1 in chain 0 of rack 0. chains lists a rack's chains and their devices (null when the device is not a rack). enabled false means a macro or lock controls the parameter: change the macro instead.

Inputs: track (required), device_path.

read_notesA
Read-only

Return the clip's length and its notes, in the same shape write_notes takes, sorted by start_time then pitch. Mute and probability are not returned, so a read_notes + write_notes round trip resets them.

Inputs: slot (required), track (required).

set_device_parametersA

Change parameters of one device (device_path as in read_device), all in one undo step. values maps a parameter name from read_device (case ignored) to a raw value between its min and max, or, for a switch, one of its items, e.g. {"Filter Freq": 0.6, "Osc 1 Shape": "Saw"}. Raw values are not units: check display in the result and set again if it is off. If any entry is invalid, nothing changes. undo_last restores all of them.

Inputs: track (required), values (required), device_path (required).

set_labelA

Rename and/or colour a track (track alone), a clip (track + slot) or a scene (scene alone). Live snaps the colour to the nearest one in its chooser. Colour by role, e.g. drums red, bass blue, chords green, and scenes by song section (intro, verse, chorus).

Inputs: name, slot, color, scene, +1 more.

set_scaleA

Set the Set's key, e.g. root "A", scale "Minor", and turn on Scale Mode so Live's MIDI editor highlights the scale's notes. create_bassline and create_chord_progression use this key when you leave root and scale out.

Inputs: root (required), scale (required).

set_tempoA

Set the song tempo in BPM (20-999).

Inputs: bpm (required).

set_track_mixA

Set a track's mixer; give only what you want to change. volume_db in dB (0 is Live's default, max +6). pan -50..50 (-50 = 50L, 50 = 50R). sends maps a return letter to dB, e.g. {"A": -12}. To silence a track use mute. solo is not exclusive: Live does not unsolo other tracks, so unsolo them yourself. Returns the track's resulting mix.

Inputs: track (required), pan, mute, solo, +2 more.

stopB

Stop playback.

Inputs: no named parameters.

undo_lastA

Undo the last change in Live. Each tool call that changes the Set is one undo step.

Inputs: no named parameters.

write_midi_fileA

Save notes as a .mid file in ~/Music/ableton-mcp/midi/ without using Live (works even when Live is closed). The user can drag the file into Live. The file holds notes only, so tell the user to drop it on a track that has an instrument (e.g. a Drum Rack kit) or it plays silent. Times are in beats. name: letters, digits, space, '_' or '-'. An existing file with that name is never overwritten: pick a new name.

Inputs: name (required), notes (required), bpm.

write_notesA
Destructive

Replace ALL notes in the clip with these notes. To edit existing notes, read_notes first and send the full changed list. Times and durations are in beats (1.0 = one quarter note). For a Drum Rack, take pitches from drum_pads in get_set_overview. The result's notes_outside_clip counts notes that start at or after the clip length; they never play (assumes the loop starts at beat 0).

Inputs: slot (required), notes (required), track (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 27 tools

    Disambiguation4/5

    Most tools target a distinct resource+action (clips, tracks, scenes, devices, mix, transport), and the detailed descriptions draw lines carefully. The main fuzziness is the MIDI-content cluster: create_midi_clip + write_notes, write_midi_file, and the three generators (create_drum_pattern, create_bassline, create_chord_progression) all produce notes across overlapping destinations, and load_from_library overlaps load_instrument (the description even says 'load_instrument does this in one call').

    Naming Consistency4/5

    The set overwhelmingly follows verb_noun snake_case: create_/delete_/copy_/read_/write_/set_/get_/load_/browse_/play_. Deviations are minor and domain-justified: bare 'stop', 'undo_last', and 'fire_scene' alongside 'play_clip', plus the state-style 'live_status'.

    Tool Count3/5

    27 tools exceeds the comfortable band; the surface is genuinely broad (tracks, clips, notes, scenes, devices, mixer, browser, offline MIDI export), so each tool is defensible, but it is heavy for an agent to route through. Some consolidation is plausible, e.g. folding the three generators and write_midi_file into fewer entry points.

    Completeness4/5

    Strong session-view lifecycle coverage: create/delete tracks and clips, scene creation, note read/write, device read/write, mixer, transport, browser loading, undo, plus offline file output. Gaps remain: no scene deletion or clip move/duplicate (only copy to empty slot), no device removal, no per-clip stop or arrangement-view operations, so a few workflows dead-end.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      B
      quality
      D
      maintenance
      Control Ableton Live from Claude Code via the Model Context Protocol (MCP). Create/edit tracks, control plugins, fire clips, edit MIDI notes, capture audio — all through natural language.
      100
      -
    • A
      license
      B
      quality
      D
      maintenance
      Local MCP server for inspecting and controlling Ableton Live through a local HTTP bridge. Enables LLMs to perform production workflows like MIDI import, track editing, mixing, mastering, and export.
      59
      18 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP clients to control Ableton Live through a Max for Live device and optional Remote Script, covering tracks, clips, MIDI notes, mixer settings, transport, and plugin search and insertion.
      1
      MIT
    • A
      license
      C
      quality
      B
      maintenance
      Enables Claude or any AI agent to operate Live 12 Intro end to end: creating tracks and scenes, writing and quantizing MIDI clips, loading audio onto the Arrangement timeline, setting device parameters in real units, drawing clip automation, mixing with real sidechain, and rendering or analyzing audio so the agent can check its own work. It exposes 57 tools over MCP or a local JSON socket, working within the stock Intro edition's 16-track, 16-scene limits.
      57
      MIT