# Ableton MCP: Controlling Ableton Live from Claude and Other LLM Clients

> Ableton MCP is an open-source Python package that connects Ableton Live 10 and above to any MCP-compatible language model client. Producers can direct Claude Desktop, Cursor, or Claude Code to create tracks, build MIDI clips, and arrange full songs directly in the running DAW.

**ahujasid/ableton-mcp** — Control Ableton Live with any LLM: create tracks, arrange clips & compose music via MCP

- Repository: https://github.com/ahujasid/ableton-mcp
- Stars: 3,122 · Forks: 421
- Language: Python
- License: MIT
- Published: 2026-09-09 · Updated: 2026-09-09 · Language: en
- Canonical page: https://hysenlabs.com/projects/ahujasid-ableton-mcp

## What Ableton MCP Solves and Who It Is For

Ableton MCP addresses the problem of manually building up tracks, clips, and arrangements inside Ableton Live from scratch. Instead of clicking through menus to add instruments, configure MIDI clips note by note, or lay out song sections by hand, a producer describes what they want in natural language and an LLM works through the session. The project targets producers who already own Ableton Live 10 or later, have Python 3.10 or above on their machine, and want to use an MCP-compatible client such as Claude Desktop, Cursor, or Claude Code to drive composition.

It is not an AI generative audio model; it does not synthesize sound. It moves data in and out of an already-running Ableton session based on whatever the LLM decides to do with a prompt. That distinction matters for anyone expecting something closer to a text-to-audio pipeline. What Ableton MCP actually provides is programmatic control of Live's session state, directed by natural language rather than hand-written scripts.

## Remote Script and MCP Server: A Two-Component Architecture

The system has two distinct parts. The first is the Ableton Remote Script, located at AbletonMCP_Remote_Script/__init__.py in the repository. This script is installed into the User Library's Remote Scripts folder and Ableton loads it as a control surface named AbletonMCP. That script creates a socket server inside Live's Python environment and listens for JSON commands. It is the only code with direct access to Ableton's Live Object Model, and writing into that environment from outside is how all third-party Remote Script developers extend Live programmatically.

The second part is the MCP server, which runs as a separate process in MCP_Server/server.py and implements the Model Context Protocol. When a client such as Claude Desktop connects to it, the LLM sends tool calls through MCP. The MCP server translates those into commands over the socket and forwards them to the Remote Script, which executes them inside Live. The result travels back along the same path.

This design means the LLM never has direct access to Ableton's internals; everything passes through the socket boundary between the two components. The pyproject.toml defines both entry points: ableton-mcp runs the MCP server and ableton-mcp-install-script copies the Remote Script into the correct User Library folder.

## Installing the Package and Connecting to Ableton Live

Installing Ableton MCP requires three explicit steps. First, install uv, the package manager the project depends on. On macOS:

```bash
brew install uv
```

Second, add the server to your MCP client configuration. For Claude Desktop, edit the claude_desktop_config.json file under Settings, Developer, Edit Config:

```json
{
    "mcpServers": {
        "AbletonMCP": {
            "command": "uvx",
            "args": [
                "ableton-mcp"
            ]
        }
    }
}
```

For Claude Code, run this in the terminal:

```bash
claude mcp add AbletonMCP uvx ableton-mcp
```

Third, install the Remote Script into Ableton's User Library:

```bash
uvx --from ableton-mcp ableton-mcp-install-script
```

The installer reads the User Library path from Ableton's Library.cfg, falling back to the platform default (~~/Music/Ableton/User Library on macOS, Documents\Ableton\User Library on Windows). If your User Library is in a non-standard location, pass the path directly:

```bash
uvx --from ableton-mcp ableton-mcp-install-script --target "/path/to/User Library/Remote Scripts"
```

After running the installer, restart Ableton Live, open Settings, go to Link, Tempo and MIDI, select AbletonMCP in the Control Surface dropdown, and set both Input and Output to None. At that point the socket connection is live.

## What You Can Direct Claude to Do in a Session

The README documents capabilities across both Session View and Arrangement View. In Session View, Claude can create MIDI and audio tracks, load instruments and effects from Ableton's library, create clips with MIDI notes, and fire or stop clips. The library access means the LLM can select specific instruments and effects by name rather than leaving placeholder slots, which is the difference between arriving at a rough sketch and a playable arrangement.

In Arrangement View the project goes further: the LLM can build a full song structure autonomously, placing sections such as an intro, a buildup, a drop, a breakdown, and an outro in sequence. Session control includes starting and stopping playback and controlling transport across both views.

The README also lists example commands as a starting point for prompts. Because the LLM interprets the prompt and decides which socket commands to send, the actual output depends on how well the prompt is written and how the model interprets it. The result is not deterministic in the way a scripted automation would be.

## Single-Client Constraint and Version Coupling

The README contains an explicit warning: only one instance of the MCP server should run at once. Running it in both Cursor and Claude Desktop simultaneously is not supported. This is a meaningful constraint for producers whose workflow involves multiple AI clients open at the same time.

A second limitation is version coupling between the Remote Script and the MCP server. When the package is upgraded via uv or pip, the install script must be re-run to copy the matching Remote Script version into Ableton's User Library. The server logs a warning when the loaded script version does not match what it expects, but it does not enforce a hard stop. If the two components fall out of sync after an upgrade and a re-run of the installer is skipped, behavior may be undefined.

The installer does back up the existing script to __init__.py.bak before replacing it, which provides one level of rollback. The README notes explicitly that the server does not install the script on startup: writing into Ableton's preferences directory is an explicit action, not a side effect of launching the server. That decision keeps the server's footprint small but places the maintenance burden on the user to remember to re-run the installer after each upgrade.

Shallow cloning is not mentioned in the project documentation. The project also has no GitHub releases; all versioned distributions are on PyPI under the package name ableton-mcp.

## Ableton MCP versus Direct Python Scripting in Live

Before Ableton MCP, developers who wanted to automate Live programmatically would write Python scripts directly against Ableton's Remote Script API, the same mechanism that the AbletonMCP Remote Script component uses internally. That approach gives complete, deterministic control over what each line of code does and requires no ongoing API calls to an external LLM service. The trade-off is that it demands knowledge of Ableton's Python environment and its Live Object Model, and every automation must be written and tested by a human.

Ableton MCP replaces the human-authored script with an LLM turn loop. The LLM decides which socket commands to send based on the prompt. This is faster for exploration and sketching but less predictable: what the LLM builds depends on its interpretation of the prompt, and there is no guarantee that two identical prompts produce the same arrangement. For reproducible production workflows or for teams that need to version-control their automation logic, hand-authored Remote Scripts remain the more auditable path.

The practical split is that Ableton MCP works well for ideation phases where a producer wants to try an arrangement idea quickly, while direct scripting is better suited to repetitive tasks that should behave identically every time.

## Telemetry, Maintenance, and License Notes

The repository includes a TERMS.md file alongside the MIT LICENSE. Anonymous telemetry is enabled by default and can be disabled, though the README does not document the specific configuration setting for doing so. Anyone working in an environment with strict data-handling policies should review TERMS.md before deploying the tool.

Ableton MCP version 1.4.5 is distributed on PyPI under the package name ableton-mcp. The project has no GitHub releases; all releases happen through PyPI. The MIT license permits commercial use, modification, and distribution. The last push to the repository was on 2026-09-22, and the project is not archived.

The project has a Dockerfile in the repository generated by Smithery, which runs the MCP server via python -m MCP_Server.server. The server is designed to communicate over a socket with Ableton, so containerized use is only meaningful if network access to the Ableton machine is available.

## Conclusion

Ableton MCP suits producers who want to sketch arrangements quickly without manually clicking through every step in Ableton Live. Anyone already comfortable with Claude Desktop or Cursor and willing to maintain the version alignment between the Remote Script and the MCP server will find setup manageable. The project is not a fit for studio engineers who need reproducible, deterministic results, or for anyone running multiple MCP clients simultaneously, since only one server instance is supported at a time. Before adopting it for real sessions, verify that your Ableton Live version is 10 or newer, that Python 3.10 is available, and that the installed Remote Script version matches the PyPI package version you have installed.

## FAQ

### Is there an MCP for Ableton?

Yes. Ableton MCP is a Python package that implements the Model Context Protocol and connects Ableton Live to MCP-compatible clients such as Claude Desktop, Cursor, and Claude Code. It requires Ableton Live 10 or newer, Python 3.10 or above, and the uv package manager.

### What is an MCP plugin in the context of Ableton MCP?

MCP stands for the Model Context Protocol, a standard that lets LLM clients communicate with external tools through a defined interface. The ableton-mcp package implements an MCP server that translates LLM tool calls into commands Ableton Live can execute via a socket-based Remote Script.

### How do you install Ableton MCP?

Install uv, add the ableton-mcp entry to your MCP client configuration (Claude Desktop, Cursor, or Claude Code), then run uvx --from ableton-mcp ableton-mcp-install-script to copy the Remote Script into Ableton's User Library. After restarting Ableton and selecting AbletonMCP as a Control Surface under Settings, the connection is ready.

## Sources

- [ahujasid/ableton-mcp on GitHub](https://github.com/ahujasid/ableton-mcp)
- [Issues](https://github.com/ahujasid/ableton-mcp/issues)
- [License: MIT](https://github.com/ahujasid/ableton-mcp/blob/main/LICENSE)
- [README](https://github.com/ahujasid/ableton-mcp/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ahujasid-ableton-mcp