Ableton MCP Extended

The ableton-songwriter skill is designed to convert open-ended songwriting requests into playable, editable Ableton Live drafts. It focuses on creating coherent song forms, intentional section contrast, and professional gain baselines rather than final mastering.

When to use this skill

• When you want to compose, arrange, rewrite, or "start a song" in Ableton.
• When you provide broad musical direction and want structured clarification.
• When you need a practical draft with a fast polish pass.

When NOT to use this skill

• For purely technical or debugging tasks (e.g., "rename track 3").
• For single, isolated operations.
• For free-form brainstorming that does not involve DAW execution.

The system operates through a multi-layered communication chain:

1. User: Issues a command in natural language (e.g., "Create a new MIDI track").
2. AI Assistant (Claude/Cursor): Interprets the intent and calls a tool from the MCP Server.
3. MCP Server (server.py): Receives the tool call and constructs a JSON command.
4. Ableton Remote Script (__init__.py): Runs inside Ableton Live and receives the JSON command via a socket connection.
5. Ableton Live API: The Remote Script executes the command using the official API to modify the session instantly.

The system follows specific logic when interpreting your MCQ selections:

• Defaulting: If you select Use a proven default, the system uses a Pop/Electronic hybrid genre, driving energy, and a 32-bar length.
• Acoustic handling: If you select an acoustic palette but have not provided any recordings, the system will build a MIDI placeholder arrangement and explicitly notify you of the placeholders.
• Conflict Resolution: If your choices conflict, the system prioritizes them in this order:
  1. Explicit user text
  2. Genre
  3. Energy
  4. Defaults

To resolve high-impact unknowns, the skill uses a targeted intake protocol. If you are looking for speed, the skill will prioritize asking only about:

• Genre family
• Energy target
• Section length target

Clarifications are typically provided in an MCQ (Multiple Choice Question) format using 1. 2. 3. numbering. The skill aims to ask exactly 3 questions first, with at most 2 follow-ups, and always includes one safe default option.

The system uses two different protocols to balance reliability and speed:

1. TCP (Port 9877): Used for the initial setup phase. It handles reliable communication for browsing tracks, devices, and parameters to ensure the client and Ableton are synchronized.
2. UDP (Port 9878): Used for the real-time control loop. It sends high-frequency parameter updates (as JSON datagrams) without waiting for acknowledgments, providing the low-latency response required for smooth mouse control.

Data Flow:

• Client: Normalizes mouse X/Y to [0.0, 1.0], applies the --change-threshold and --update-interval, then sends a set_device_parameter or batch_set_device_parameters JSON message via UDP.
• Server (Ableton): The __init__.py script receives the UDP datagram and schedules the parameter changes on Ableton Live's main thread.

The skill follows a Plugin-Aware Policy:

• It checks availability before assuming a plugin can be used.
• If a named plugin is requested, it seeks an exact match.
• If multiple close matches exist, it will request specificity rather than guessing.
• If loading fails: The skill will continue using the best available substitute and report the fallback clearly.

To ensure effective arrangement and mixing, follow these guidelines:

Contrast Rules

• Section A: Use fewer layers and lower high-end intensity.
• Section B: Use a fuller rhythm, stronger hook, and denser arrangement.
• Consistency: Maintain one clear motif so sections feel connected.

Quick Mix Heuristics

• Set drums and bass first.
• Keep the low end centered.
• Pan support layers lightly for width.
• Use gentle compression and saturation where the style requires it.
• Preserve headroom for later mastering.

To allow Ableton to communicate with the MCP server, you must install a Remote Script into your Ableton User Library.

1. Locate your Remote Scripts directory

• Windows: %USERPROFILE%\Documents\Ableton\User Library\Remote Scripts
• macOS: ~/Library/Preferences/Ableton/Live [Version]/User Remote Scripts/

2. Install the Main Script

1. Create a folder named AbletonMCP inside your Remote Scripts directory.
2. Copy the file AbletonMCP_Remote_Script/__init__.py from the repository into the AbletonMCP folder.

Required Structure:

Remote Scripts/
├── AbletonMCP/
│   └── __init__.py

Note: You can also install the UDP version by creating an AbletonMCP_UDP folder and placing its corresponding __init__.py inside. Both can co-exist.

The skill follows a structured 7-step lifecycle to move from a request to a finished draft:

1. Parse request: Extract fixed constraints.
2. Targeted intake: Run clarification for missing high-impact decisions.
3. Emit production brief: Output a concise plan (proceeds automatically unless review is requested).
4. Build foundations: Create rhythm, harmony, and hooks in Session or Arrangement.
5. Arrange: Organize into form with section contrast and transitions.
6. Quick mix: Apply a baseline mix and playback-ready positioning.
7. Handoff: Return a structured recap with revision options.

To use Ableton MCP with Claude Desktop, add the server configuration to your claude_desktop_config.json. Ensure you provide the absolute path to the server.py file within the cloned repository.

Note: Replace C:/path/to/... with your actual local path.

{
  "mcpServers": {
    "AbletonMCP": {
      "command": "python",
      "args": ["C:/path/to/ableton-mcp-extended/MCP_Server/server.py"]
    }
  }
}

Upon completion, the skill provides a structured Handoff containing:

• What was built (sections, bars, key tracks).
• Plugins/instruments used (including fallbacks).
• Current limitations/assumptions.
• 2-4 concrete revision options.

Revision Rules

• Preservation: On revision, preserve successful sections and only change the requested scope.
• Identity: Reuse existing motifs/harmony to maintain song identity.
• Brief Updates: If a revision changes core dimensions (Genre, BPM, Key), an updated Production Brief will be emitted first.

You can combine Ableton MCP with the ElevenLabs MCP server to generate spoken-word audio and import it directly into your Ableton session. To do this, update your AI assistant's configuration file to include both servers. You must provide your ELEVENLABS_API_KEY in the environment variables for the ElevenLabs server.

{
  "mcpServers": {
    "AbletonMCP": {
      "command": "python",
      "args": ["/path/to/ableton-mcp-extended/server.py"]
    },
    "ElevenLabs": {
      "command": "python",
      "args": ["/path/to/elevenlabs_mcp/server.py"],
      "env": {
        "ELEVENLABS_API_KEY": "your-api-key-here"
      }
    }
  }
}