Skip to main content
Glama

ableton-mcp-loopback

A loopback-bound Model Context Protocol (MCP) server for Ableton Live. It lets an MCP client (Claude, an agent, an LLM tool runner) drive Ableton Live — set tempo, create tracks and clips, add MIDI notes, start/stop playback — over the standard MCP stdio transport.

This is a security-fix fork of ahujasid/ableton-mcp (MIT). The one material change is the network bind: the upstream Remote Script binds its control socket to 0.0.0.0 (every network interface), exposing unauthenticated Ableton control to the LAN. This fork binds 127.0.0.1 (loopback) as a hard constant — the kernel refuses any non-loopback peer at the socket layer, with no firewall rule required. See Security below.

Why two parts

Ableton's Live Object Model (LOM) is reachable only from a MIDI Remote Script loaded into Live's embedded Python — there is no out-of-process LOM API. So the project is irreducibly two pieces:

  1. RemoteScript/ — a MIDI Remote Script that runs inside Ableton Live. It opens a small loopback TCP socket (127.0.0.1:9877) and translates incoming JSON commands into LOM calls (mutating calls run on Live's main thread).

  2. ableton_mcp_loopback/ — the stdio MCP server. It runs as a normal process, connects to 127.0.0.1:9877 as a client, and relays MCP tool calls to the Remote Script.

MCP client  <—stdio—>  ableton-mcp-loopback server  <—TCP 127.0.0.1:9877—>  Remote Script (in Live)  —>  LOM

Related MCP server: ableton-mcp

Setup

1. Install the MCP server

With uv (recommended — no manual venv):

uvx --from git+https://github.com/applicate2628/ableton-mcp-loopback ableton-mcp-loopback

Or with pip:

pip install git+https://github.com/applicate2628/ableton-mcp-loopback
ableton-mcp-loopback

Then point your MCP client at the ableton-mcp-loopback command (stdio). For example, in an MCP client config:

{
  "mcpServers": {
    "ableton": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/applicate2628/ableton-mcp-loopback", "ableton-mcp-loopback"]
    }
  }
}

2. Install the Remote Script into Ableton Live

This is the one irreducible manual Ableton step — the LOM is only reachable from a Control Surface script loaded by Live itself.

  1. Copy the RemoteScript/ folder into Ableton's MIDI Remote Scripts directory, renaming it to a clear name such as ableton_mcp_loopback:

    • Windows: C:\ProgramData\Ableton\Live <version>\Resources\MIDI Remote Scripts\ or \Users\<you>\Documents\Ableton\User Library\Remote Scripts\

    • macOS: /Applications/Ableton Live <version>.app/Contents/App-Resources/MIDI Remote Scripts/ or ~/Music/Ableton/User Library/Remote Scripts/

    The result should be a folder like .../MIDI Remote Scripts/ableton_mcp_loopback/ containing __init__.py.

  2. Start (or restart) Ableton Live.

  3. Open Preferences → Link / Tempo / MIDI (the MIDI tab), and under Control Surface select ableton_mcp_loopback (the folder name you used). Leave Input/Output set to None. Live then loads the script and you should see ableton-mcp-loopback: Listening on 127.0.0.1:9877 flash in Live's status bar.

That's it — the MCP server will connect to the Remote Script automatically. If the server starts before the Control Surface is loaded, it retries the connection.

Tools

This release ships the full upstream ahujasid/ableton-mcp tool surface — it is a drop-in replacement minus the upstream wide-bind network exposure and minus telemetry. All 21 tools are present:

Tool

What it does

get_session_info

Tempo, time signature, track counts, transport state

get_track_info

A track's clip slots, devices, mixer state

set_tempo

Set session BPM

start_playback

Start the session transport

stop_playback

Stop the session transport

create_midi_track

Add a MIDI track

set_track_name

Rename a track

create_clip

Create an empty MIDI clip in a slot

create_audio_clip

Import an audio file into an audio clip slot (Live 12.0.5+)

add_notes_to_clip

Write MIDI notes into a clip

set_clip_name

Rename a clip

fire_clip

Launch a clip

stop_clip

Stop a clip

load_instrument_or_effect

Load a device onto a track by browser URI

load_drum_kit

Load a drum rack and a drum kit into it

get_browser_tree

List the browser's category tree

get_browser_items_at_path

List browser items at a category path

switch_to_arrangement_view

Switch Live's window to the Arrangement view

set_arrangement_time

Move the arrangement playhead (beats)

get_arrangement_clips

List a track's Arrangement-timeline clips

duplicate_to_arrangement

Copy a Session clip into the Arrangement

A typical end-to-end flow: create_midi_track → set_track_name → create_clip → add_notes_to_clip → fire_clip.

Input validation and message framing

Every command's parameters are validated before any Live Object Model call runs (indices are non-negative integers, tempo is within Live's range, MIDI pitch/velocity are 0–127, durations are positive and finite, note lists are well-formed). An invalid value returns a structured status: error response and never reaches Live.

The TCP link between the server and the Remote Script uses newline-delimited JSON framing: each message is one JSON object terminated by a single \n. Both ends buffer with a bounded receive buffer, parse each complete frame, reject a malformed frame without poisoning the stream, and handle multiple frames in one packet. The wire protocol changed in this release — if you are upgrading from the earlier P1 build, you must reload the Remote Script in Live (re-select the Control Surface, or restart Live) so both ends speak the same framing.

Security

Loopback by construction, not by firewall convention.

The Remote Script binds its socket with HOST = "127.0.0.1" as a hard constant. There is no operator override, no bind-address config key, and no environment variable that can widen it. Because the socket is bound to the loopback interface, the operating-system kernel never associates it with the host's LAN/routable interface, so a connection from any non-loopback address is refused at the socket layer — you do not need a firewall rule for this, and no firewall misconfiguration can undo it.

Contrast with upstream ahujasid/ableton-mcp, which binds 0.0.0.0 — that accepts connections from any interface, meaning any device on the same LAN can issue unauthenticated commands to Ableton. That is the exposure this fork removes.

This build also contains no telemetry — the upstream telemetry module, the user_prompt capture parameter, and the analytics dependency are all removed (not merely disabled).

Residual risk (local processes). Any process running on the same machine can still reach 127.0.0.1:9877. This is the same trust posture as every local stdio MCP server and every local development service. The loopback bind protects against remote/LAN attackers, not against other local processes on a machine you already trust. Finer per-tool consent is out of scope for this component.

License

MIT. See LICENSE. Forked from ahujasid/ableton-mcp (MIT, copyright (c) 2025 Siddharth Ahuja); the upstream copyright is preserved in LICENSE.

Development

pip install -e .[test]
pytest                       # security probe + tool-surface tests (no Ableton needed)
python -m ableton_mcp_loopback.server   # run the server (will retry to reach Live)

The tests under tests/ are all runnable without Ableton: they assert the loopback bind constant, scan the tree for any wide-bind literal, exercise a real loopback socket to prove a non-loopback connect is refused (plus an always-run structural guard that the bind is loopback, so the security check can never go green on a skip), check full upstream tool-surface parity on both the server and the Remote Script, exercise the newline-delimited message framing (partial / multi-frame / malformed / oversized handling), and exercise the parameter validation. The full LOM smoke (create track → notes → fire → audible) requires a live Ableton Live and is run separately.

Available Tools

21 tools
add_notes_to_clipA
Add MIDI notes to a clip.

Parameters:
- track_index: The index of the track containing the clip
- clip_index: The index of the clip slot containing the clip
- notes: List of note dictionaries, each with pitch, start_time, duration,
  velocity, and mute

Inputs: notes (required), clip_index (required), track_index (required). Returns: result

create_audio_clipA
Create a new audio clip in an audio track's clip slot by importing a file.

Requires Ableton Live 12.0.5 or newer — the underlying
ClipSlot.create_audio_clip Live API was introduced in 12.0.5 and is not
available in earlier 12.0.x releases.

Parameters:
- track_index: The index of the audio track to create the clip in
- clip_index: The index of the clip slot to create the clip in
- path: Absolute path to a supported audio file (e.g. a .wav). The target
  track must be an audio track and the clip slot must be empty.

Inputs: path (required), clip_index (required), track_index (required). Returns: result

create_clipA
Create a new MIDI clip in the specified track and clip slot.

Parameters:
- track_index: The index of the track to create the clip in
- clip_index: The index of the clip slot to create the clip in
- length: The length of the clip in beats (default: 4.0)

Inputs: clip_index (required), track_index (required), length. Returns: result

create_midi_trackA
Create a new MIDI track in the Ableton session.

Parameters:
- index: The index to insert the track at (-1 = end of list)

Inputs: index. Returns: result

duplicate_to_arrangementA
Copy a Session-view clip into the Arrangement timeline.

Uses Live's track.duplicate_clip_to_arrangement() API (Live 11 / 12). The
clip is placed at destination_time beats from the start of the arrangement on
the same track it lives in.

Typical workflow:
  1. create_clip / add_notes_to_clip to build a Session clip
  2. Call duplicate_to_arrangement once per bar/section you need
  3. Call switch_to_arrangement_view to confirm the result in Live

Parameters:
- track_index:       Index of the track that owns the Session clip
- clip_index:        Index of the clip slot in that track (Session view)
- destination_time:  Beat position in the arrangement to place the clip
                     (e.g. 0.0 = start, 8.0 = bar 3 in 4/4)

Inputs: clip_index (required), track_index (required), destination_time (required). Returns: result

fire_clipB
Start playing a clip.

Parameters:
- track_index: The index of the track containing the clip
- clip_index: The index of the clip slot containing the clip

Inputs: clip_index (required), track_index (required). Returns: result

get_arrangement_clipsA
List all clips placed in the Arrangement timeline for a track.

Returns each clip's name, start_time, end_time, length, and type.

Parameters:
- track_index: The index of the track to inspect

Inputs: track_index (required). Returns: result

get_browser_items_at_pathA
Get browser items at a specific path in Ableton's browser.

Parameters:
- path: Path in the format "category/folder/subfolder" where category is one
  of the available browser categories in Ableton

Inputs: path (required). Returns: result

get_browser_treeA
Get a hierarchical tree of browser categories from Ableton.

Parameters:
- category_type: Type of categories to get ('all', 'instruments', 'sounds',
  'drums', 'audio_effects', 'midi_effects')

Inputs: category_type. Returns: result

get_session_infoB

Get detailed information about the current Ableton session.

Inputs: no named parameters. Returns: result

get_track_infoC
Get detailed information about a specific track in Ableton.

Parameters:
- track_index: The index of the track to get information about

Inputs: track_index (required). Returns: result

load_drum_kitA
Load a drum rack and then load a specific drum kit into it.

Parameters:
- track_index: The index of the track to load on
- rack_uri: The URI of the drum rack to load (e.g., 'Drums/Drum Rack')
- kit_path: Path to the drum kit inside the browser (e.g.,
  'drums/acoustic/kit1')

Inputs: kit_path (required), rack_uri (required), track_index (required). Returns: result

load_instrument_or_effectB
Load an instrument or effect onto a track using its URI.

Parameters:
- track_index: The index of the track to load the instrument on
- uri: The URI of the instrument or effect to load (e.g.,
  'query:Synths#Instrument%20Rack:Bass:FileId_5116')

Inputs: uri (required), track_index (required). Returns: result

set_arrangement_timeA
Move the arrangement playhead to a specific position.

Parameters:
- time: Position in beats from the start of the arrangement (e.g. 8.0 = bar 3
  in 4/4)

Inputs: time (required). Returns: result

set_clip_nameA
Set the name of a clip.

Parameters:
- track_index: The index of the track containing the clip
- clip_index: The index of the clip slot containing the clip
- name: The new name for the clip

Inputs: name (required), clip_index (required), track_index (required). Returns: result

set_tempoA
Set the tempo of the Ableton session.

Parameters:
- tempo: The new tempo in BPM

Inputs: tempo (required). Returns: result

set_track_nameB
Set the name of a track.

Parameters:
- track_index: The index of the track to rename
- name: The new name for the track

Inputs: name (required), track_index (required). Returns: result

start_playbackB

Start playing the Ableton session.

Inputs: no named parameters. Returns: result

stop_clipA
Stop playing a clip.

Parameters:
- track_index: The index of the track containing the clip
- clip_index: The index of the clip slot containing the clip

Inputs: clip_index (required), track_index (required). Returns: result

stop_playbackB

Stop playing the Ableton session.

Inputs: no named parameters. Returns: result

switch_to_arrangement_viewB

Switch Ableton's main window to the Arrangement view.

Inputs: no named parameters. Returns: result

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 21 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, from track/clip creation to playback and arrangement management. No overlapping or ambiguous tools.

    Naming Consistency4/5

    Most tools follow a verb_noun pattern (e.g., create_midi_track, set_tempo). Minor deviations like duplicate_to_arrangement and switch_to_arrangement_view are still clear and predictable.

    Tool Count5/5

    21 tools cover the essential operations for Ableton Live session control without being excessive or sparse. Each tool adds value.

    Completeness4/5

    The surface covers core workflows (create, edit, play, browse) but lacks delete/remove operations for tracks or clips, which is a minor gap.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      B
      quality
      D
      maintenance
      MCP server for controlling Ableton Live, enabling AI assistants to interact with Live sessions through tools for track/clip/scene management, playback control, and device parameter adjustments.
      48
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      An MCP server that exposes Ableton Live control (session state, transport, tracks, devices, clips, MIDI note editing) as tools for LLM agents, enabling natural language manipulation of a Live session.
      1
      MIT
    • 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