Overview

The MCP (Model Context Protocol) server for Ableton Live is a lightweight networked bridge that exposes Ableton Live controls over TCP/UDP/WebSocket protocols. It is designed to make MIDI and OSC mapping fast and declarative, enable custom control surfaces, and automate set management from external applications or hardware controllers. Developers can use the server to script Live actions, route control messages, and integrate touch/mobile surfaces without writing low-level remote scripts for every client.

The server acts as a middle layer between external controllers/apps and Ableton Live. It translates incoming OSC/MIDI/WebSocket messages into Live operations (track fader, clip launch, device parameters, scenes, etc.) and provides a programmable API for state queries and automated workflows. This is useful for live performers, installations, and studio automation where flexible, networked control and repeatable set management are required.

Features

Fast mapping of OSC/MIDI/WebSocket messages to Ableton Live controls
Declarative control surface configuration (JSON/YAML mapping files)
API endpoints to query and manipulate Live state (tracks, clips, scenes)
Support for custom control surfaces and mobile interfaces (TouchOSC, Lemur)
Optional Remote Script / Max for Live helper to bridge Live’s Python API
Hot-reloadable mappings for quick iteration during setup or performance
Logging and debug modes to inspect message flow and mapping decisions

Installation / Configuration

Clone the repository and install dependencies. The server can be run with Python (example) — replace with Node if you use the corresponding implementation.

git clone https://github.com/Simon-Kansara/ableton-live-mcp-server.git
cd ableton-live-mcp-server
# Python example
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Basic configuration is provided via a JSON file. Create a config.json and adjust ports, endpoints and mapping file paths:

{
  "live_helper": {
    "enabled": true,
    "port": 9001
  },
  "osc": {
    "listen_port": 8000,
    "address": "0.0.0.0"
  },
  "http_api": {
    "host": "127.0.0.1",
    "port": 3000
  },
  "mappings": "mappings/default.json"
}

Start the server:

# With Python entrypoint
python server.py --config config.json

If the project exposes a Node entrypoint:

npm install
node server.js --config config.json

Enable the provided Ableton helper (if included) by placing the Remote Script folder into Ableton Live’s MIDI Remote Scripts directory and enabling it in Live’s Preferences → Link/MIDI. Alternatively, if a Max for Live device is supplied, load it into your set to bridge the Live API.

Default Endpoints / Ports

Service	Default Port	Protocol
HTTP API	3000	HTTP/JSON
OSC listen	8000	UDP/OSC
Live helper	9001	TCP/WebSocket
MIDI	system MIDI	MIDI

(Adjust ports in config to avoid conflicts.)

Available Resources

GitHub repository (source, issues, examples): https://github.com/Simon-Kansara/ableton-live-mcp-server
Example mapping files: mappings/default.json (contains common control-to-action mappings)
Optional Max for Live device or Remote Script helper (check the repo’s helpers/ directory)
API documentation: run the server and visit the HTTP API root (e.g., http://127.0.0.1:3000/) for runtime discovery

Use Cases

Live performance: Route a MIDI encoder bank from a hardware controller to track volumes across multiple tracks. Use hot-reloadable mappings to switch layouts between sets without restarting Ableton.
- Example: map incoming OSC path /fader/1 to track[0].mixer.volume via mappings/default.json.
Mobile control surfaces: Use TouchOSC or Lemur on a tablet; send OSC messages to the MCP server which forwards them to Live. Prevents custom remote script development for each mobile layout.
- Example: TouchOSC sends /track/2/arm 1 → MCP server translates to arm track 2.
Automated set management: Trigger scene launches, mute/solo groups, or recall saved track routings from external scripts or CI-like tooling (useful for installations or recurring shows).
- Example curl call to launch a scene:
```
curl -X POST http://127.0.0.1:3000/api/scene/launch -d '{"scene": 3}'
```
Collaborative setups: Multiple operators control different aspects (mix, clips, effects) through the same MCP server with role-aware mappings and namespaces.

Mapping Example

A simple mapping file (JSON) binds input messages to Live actions:

{
  "mappings": [
    {
      "input": { "type": "osc", "path": "/fader/1" },
      "action": { "type": "set", "target": "track[0].mixer.volume", "scale": [0, 1] }
    },
    {
      "input": { "type": "osc", "path": "/clip/1/launch" },
      "action": { "type": "launch_clip", "target": "track[0].clip_slot[0]" }
    }
  ]
}

Adjust mappings to match your controller’s OSC/MIDI messages and the Live targets you want to control.

Tips for Developers

Test mappings locally with an OSC client (e.g., oscsend) or a MIDI loopback to verify translation before connecting hardware.
Use the server’s debug/log mode to trace messages and returned Live state.
Keep mappings modular; separate device/control mappings from scene/set automation so you can reuse control layouts across projects.

For code examples, issues, and the latest usage notes, refer to the project repository: https://github.com/Simon-Kansara/ableton-live-mcp-server.

MCP Server for Ableton Live Remote Control