mcp-server-ableton-live 1.0.1__tar.gz

mcp_server_ableton_live-1.0.1/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Siddharth Ahuja
+Copyright (c) 2026 wstierhout
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_server_ableton_live-1.0.1/MCP_Server/__init__.py

@@ -0,0 +1,5 @@
+"""Ableton Live integration through the Model Context Protocol."""
+
+__version__ = "1.0.1"
+
+from .connection import AbletonConnection, get_ableton_connection  # noqa: F401

mcp_server_ableton_live-1.0.1/MCP_Server/app.py

@@ -0,0 +1,57 @@
+"""FastMCP application instance and server lifecycle."""
+
+import logging
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from .connection import disconnect_ableton, get_ableton_connection
+
+logger = logging.getLogger("AbletonMCPServer")
+
+
+@asynccontextmanager
+async def server_lifespan(server: FastMCP) -> AsyncIterator[dict[str, Any]]:
+    """Connect to Ableton on startup (best effort) and clean up on shutdown."""
+    try:
+        logger.info("AbletonMCP server starting up")
+        try:
+            get_ableton_connection()
+            logger.info("Successfully connected to Ableton on startup")
+        except Exception as e:
+            logger.warning(f"Could not connect to Ableton on startup: {str(e)}")
+            logger.warning("Make sure the Ableton Remote Script is running")
+        yield {}
+    finally:
+        disconnect_ableton()
+        logger.info("AbletonMCP server shut down")
+
+
+INSTRUCTIONS = """Control Ableton Live via a Remote Script socket. Conventions:
+
+- ALL indices are 0-based: track_index, clip_index (session slot), scene_index,
+  return_index (0 = Return A), device_index (position in the track's chain).
+- Times, lengths, and positions are in BEATS (quarter notes), floats allowed.
+- Volume faders are Live's normalized 0.0-1.0 range where 0.85 = 0 dB unity.
+  Device parameters use each parameter's native range - call get_device_parameters
+  first and read min/max/display before setting values.
+- MIDI notes: pitch 0-127 (60 = C3 in Live's naming), velocity 1-127,
+  start_time/duration in beats relative to clip start.
+- Typical workflow: create_midi_track -> load_instrument_or_effect (or
+  search_browser + load) -> create_clip -> add_notes_to_clip -> fire_clip /
+  duplicate_to_arrangement. Check get_session_info / get_track_info first.
+- add_notes_to_clip REPLACES the clip's entire note content (use edit_notes for
+  incremental changes). duplicate_to_arrangement OVERWRITES whatever overlaps the
+  destination range. delete_track / delete_arrangement_clip shift later indices.
+- Transport tools report the PRE-command state (start_playback may answer
+  "playing: false"); confirm with get_session_info.
+- Use batch_commands for multi-step edits: one round-trip, one undo step.
+- If every command suddenly times out, a modal dialog is open in Live (e.g. the
+  trial nag) - it freezes the Remote Script until dismissed. Ask the user to
+  press Enter in Live, then retry.
+- undo/redo are available; prefer batch_commands so one undo reverts a whole edit.
+"""
+
+mcp = FastMCP("AbletonMCP", lifespan=server_lifespan, instructions=INSTRUCTIONS)

mcp_server_ableton_live-1.0.1/MCP_Server/cli.py

@@ -0,0 +1,132 @@
+"""Setup helpers exposed as subcommands: install, uninstall, doctor.
+
+These make onboarding a one-liner instead of a manual file copy, and give users
+a way to diagnose a broken setup.
+"""
+
+import platform
+import socket
+import urllib.request
+from pathlib import Path
+
+from . import __version__
+from .connection import ABLETON_HOST, ABLETON_PORT
+
+SCRIPT_FOLDER = "AbletonMCP"
+RAW_BASE = "https://raw.githubusercontent.com/wstierhout/ableton-live-mcp"
+
+
+def _remote_scripts_dir() -> Path:
+    home = Path.home()
+    if platform.system() == "Windows":
+        return home / "Documents" / "Ableton" / "User Library" / "Remote Scripts"
+    return home / "Music" / "Ableton" / "User Library" / "Remote Scripts"
+
+
+def _fetch_remote_script() -> bytes:
+    # Pin to this package's exact version so the installed Remote Script always
+    # matches the server (no mutable-branch fallback).
+    url = f"{RAW_BASE}/v{__version__}/AbletonMCP_Remote_Script/__init__.py"
+    try:
+        with urllib.request.urlopen(url, timeout=15) as resp:
+            if resp.status == 200:
+                return resp.read()
+    except Exception as e:
+        raise RuntimeError(
+            f"Could not download the Remote Script for v{__version__} ({e}). "
+            "Download AbletonMCP_Remote_Script/__init__.py from the repo and copy it "
+            "into your User Library Remote Scripts/AbletonMCP/ folder by hand."
+        ) from e
+    raise RuntimeError(f"Remote Script for v{__version__} not found at {url}")
+
+
+def install() -> int:
+    dest_dir = _remote_scripts_dir() / SCRIPT_FOLDER
+    parent = dest_dir.parent
+    if not parent.exists():
+        print(f"Could not find Ableton's Remote Scripts folder at:\n  {parent}")
+        print(
+            "Is Ableton Live installed? If your User Library is elsewhere, copy the "
+            "Remote Script there by hand."
+        )
+        return 1
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    (dest_dir / "__init__.py").write_bytes(_fetch_remote_script())
+    print(f"Installed the Remote Script to:\n  {dest_dir / '__init__.py'}\n")
+    print("Next:")
+    print("  1. Restart Ableton Live.")
+    print("  2. Settings > Link/Tempo/MIDI > Control Surface: AbletonMCP (Input/Output: None).")
+    print("  3. Run `ableton-live-mcp doctor` to confirm the connection.")
+    return 0
+
+
+def uninstall() -> int:
+    dest = _remote_scripts_dir() / SCRIPT_FOLDER / "__init__.py"
+    if dest.exists():
+        dest.unlink()
+        try:
+            dest.parent.rmdir()
+        except OSError:
+            pass
+        print(f"Removed {dest}. Restart Live to unload it.")
+    else:
+        print("Nothing to remove; the Remote Script was not found.")
+    return 0
+
+
+def doctor() -> int:
+    print(f"ableton-live-mcp {__version__} setup check\n")
+    ok = True
+
+    installed = (_remote_scripts_dir() / SCRIPT_FOLDER / "__init__.py").exists()
+    print(f"  [{'ok' if installed else 'x '}] Remote Script installed in the User Library")
+    if not installed:
+        print("       fix: run `ableton-live-mcp install`")
+        ok = False
+
+    try:
+        with socket.create_connection((ABLETON_HOST, ABLETON_PORT), timeout=3) as s:
+            s.sendall(b'{"type": "get_session_info", "params": {}}')
+            data = s.recv(8192)
+        reachable = b'"status"' in data
+    except Exception:
+        reachable = False
+    print(
+        f"  [{'ok' if reachable else 'x '}] Remote Script reachable on "
+        f"{ABLETON_HOST}:{ABLETON_PORT}"
+    )
+    if not reachable:
+        print("       fix: start Ableton Live, select AbletonMCP as the Control Surface,")
+        print("            and dismiss any open dialog (the trial nag blocks the script).")
+        ok = False
+
+    print()
+    print("All good." if ok else "Some checks failed; follow the fixes above.")
+    return 0 if ok else 1
+
+
+USAGE = """ableton-live-mcp - Ableton Live MCP server
+
+Usage:
+  ableton-live-mcp                 run the MCP server (this is what MCP clients call)
+  ableton-live-mcp install         copy the Remote Script into Ableton's User Library
+  ableton-live-mcp uninstall       remove the Remote Script
+  ableton-live-mcp doctor          check that the setup is working
+  ableton-live-mcp --version       print the version
+  ableton-live-mcp --help          show this help
+"""
+
+
+def run(argv) -> int:
+    cmd = argv[0]
+    if cmd in ("-h", "--help", "help"):
+        print(USAGE)
+        return 0
+    if cmd in ("-V", "--version", "version"):
+        print(__version__)
+        return 0
+    handlers = {"install": install, "uninstall": uninstall, "doctor": doctor}
+    if cmd not in handlers:
+        print(f"Unknown command: {cmd}\n\n{USAGE}")
+        return 2
+    return handlers[cmd]()

mcp_server_ableton_live-1.0.1/MCP_Server/connection.py

@@ -0,0 +1,237 @@
+"""Socket connection to the AbletonMCP Remote Script (port 9877)."""
+
+import json
+import logging
+import os
+import socket
+import threading
+import time
+from dataclasses import dataclass
+from typing import Any
+
+ABLETON_HOST = os.environ.get("ABLETON_HOST", "localhost")
+ABLETON_PORT = int(os.environ.get("ABLETON_PORT", "9877"))
+
+logger = logging.getLogger("AbletonMCPServer")
+
+# Client-side socket timeouts. The Remote Script enforces its own main-thread
+# queue budget (10 s default; see _COMMAND_TIMEOUTS in the Remote Script for
+# long-running overrides) - the client budget must exceed it or the client can
+# drop the socket at the same instant the script replies. Keep these two maps
+# in sync; SOCKET_HEADROOM covers transport latency on top of the script budget.
+REMOTE_DEFAULT_TIMEOUT = 10.0
+REMOTE_COMMAND_TIMEOUTS = {"create_audio_clip": 60.0}
+SOCKET_HEADROOM = 5.0
+
+
+def command_timeout(command_type: str) -> float:
+    """Client socket budget for one command: remote budget + transport headroom."""
+    return REMOTE_COMMAND_TIMEOUTS.get(command_type, REMOTE_DEFAULT_TIMEOUT) + SOCKET_HEADROOM
+
+
+@dataclass
+class AbletonConnection:
+    host: str
+    port: int
+    sock: socket.socket = None
+
+    def __post_init__(self):
+        # One request/response in flight at a time: concurrent MCP tool calls
+        # must not interleave frames on the shared socket.
+        self._io_lock = threading.Lock()
+
+    def connect(self) -> bool:
+        """Connect to the Ableton Remote Script socket server"""
+        if self.sock:
+            return True
+
+        try:
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.settimeout(5.0)
+            self.sock.connect((self.host, self.port))
+            self.sock.settimeout(None)
+            logger.info(f"Connected to Ableton at {self.host}:{self.port}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to Ableton at {self.host}:{self.port}: {str(e)}")
+            self.sock = None
+            return False
+
+    def disconnect(self):
+        """Disconnect from the Ableton Remote Script"""
+        if self.sock:
+            try:
+                self.sock.close()
+            except Exception as e:
+                logger.error(f"Error disconnecting from Ableton: {str(e)}")
+            finally:
+                self.sock = None
+
+    def receive_full_response(self, sock, timeout=15.0, buffer_size=8192):
+        """Receive the complete response, potentially in multiple chunks"""
+        chunks = []
+        sock.settimeout(timeout)
+
+        try:
+            while True:
+                try:
+                    chunk = sock.recv(buffer_size)
+                    if not chunk:
+                        if not chunks:
+                            raise Exception("Connection closed before receiving any data")
+                        break
+
+                    chunks.append(chunk)
+
+                    # Check if we've received a complete JSON object
+                    try:
+                        data = b"".join(chunks)
+                        json.loads(data.decode("utf-8"))
+                        logger.info(f"Received complete response ({len(data)} bytes)")
+                        return data
+                    except json.JSONDecodeError:
+                        # Incomplete JSON, continue receiving
+                        continue
+                except TimeoutError:
+                    logger.warning("Socket timeout during chunked receive")
+                    break
+                except (ConnectionError, BrokenPipeError, ConnectionResetError) as e:
+                    logger.error(f"Socket connection error during receive: {str(e)}")
+                    raise
+        except Exception as e:
+            logger.error(f"Error during receive: {str(e)}")
+            raise
+
+        # If we get here, we either timed out or broke out of the loop
+        if chunks:
+            data = b"".join(chunks)
+            logger.info(f"Returning data after receive completion ({len(data)} bytes)")
+            try:
+                json.loads(data.decode("utf-8"))
+                return data
+            except json.JSONDecodeError:
+                raise Exception("Incomplete JSON response received")
+        else:
+            raise Exception("No data received")
+
+    def send_command(self, command_type: str, params: dict[str, Any] = None) -> dict[str, Any]:
+        """Send a command to Ableton and return the response"""
+        command = {"type": command_type, "params": params or {}}
+
+        try:
+            with self._io_lock:
+                if not self.sock and not self.connect():
+                    raise ConnectionError(
+                        "Not connected to Ableton. Start Live, select AbletonMCP as the "
+                        "Control Surface (Settings > Link/Tempo/MIDI), and run `abletonmcp doctor`."
+                    )
+                logger.info(f"Sending command: {command_type} with params: {params}")
+                self.sock.sendall(json.dumps(command).encode("utf-8"))
+                logger.info("Command sent, waiting for response...")
+                response_data = self.receive_full_response(
+                    self.sock, timeout=command_timeout(command_type)
+                )
+            logger.info(f"Received {len(response_data)} bytes of data")
+
+            # Parse the response
+            response = json.loads(response_data.decode("utf-8"))
+            logger.info(f"Response parsed, status: {response.get('status', 'unknown')}")
+
+            if response.get("status") == "error":
+                logger.error(f"Ableton error: {response.get('message')}")
+                raise Exception(response.get("message", "Unknown error from Ableton"))
+
+            return response.get("result", {})
+        except TimeoutError:
+            logger.error("Socket timeout while waiting for response from Ableton")
+            self.sock = None
+            raise Exception(
+                "Timeout waiting for Ableton response. If ALL commands time out, a "
+                "modal dialog is likely open in Live (it freezes the Remote Script) - "
+                "ask the user to dismiss it (press Enter in Live), then retry."
+            )
+        except (ConnectionError, BrokenPipeError, ConnectionResetError) as e:
+            logger.error(f"Socket connection error: {str(e)}")
+            self.sock = None
+            raise Exception(
+                f"Connection to Ableton lost ({e}). Is Live still running? "
+                "Run `abletonmcp doctor` to diagnose."
+            )
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON response from Ableton: {str(e)}")
+            if "response_data" in locals() and response_data:
+                logger.error(f"Raw response (first 200 bytes): {response_data[:200]}")
+            self.sock = None
+            raise Exception(f"Invalid response from Ableton: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error communicating with Ableton: {str(e)}")
+            self.sock = None
+            raise Exception(f"Communication error with Ableton: {str(e)}")
+
+
+# Global connection singleton (shared across all tool modules)
+_ableton_connection = None
+
+
+def get_ableton_connection():
+    """Get or create a persistent Ableton connection"""
+    global _ableton_connection
+
+    if _ableton_connection is not None and _ableton_connection.sock is not None:
+        try:
+            # Check if the socket is still alive by peeking for data
+            # MSG_PEEK + MSG_DONTWAIT will raise BlockingIOError if alive but no data,
+            # or return b'' if the remote end has closed the connection.
+            _ableton_connection.sock.setblocking(False)
+            try:
+                data = _ableton_connection.sock.recv(1, socket.MSG_PEEK)
+                if data == b"":
+                    raise ConnectionError("Remote end closed")
+            except BlockingIOError:
+                pass  # Socket is alive, just no data waiting - this is normal
+            finally:
+                _ableton_connection.sock.setblocking(True)
+            return _ableton_connection
+        except Exception as e:
+            logger.warning(f"Existing connection is no longer valid: {str(e)}")
+            try:
+                _ableton_connection.disconnect()
+            except Exception:
+                pass
+            _ableton_connection = None
+
+    # Connection doesn't exist or is invalid, create a new one
+    max_attempts = 3
+    for attempt in range(1, max_attempts + 1):
+        try:
+            logger.info(
+                f"Connecting to Ableton at {ABLETON_HOST}:{ABLETON_PORT} "
+                f"(attempt {attempt}/{max_attempts})..."
+            )
+            _ableton_connection = AbletonConnection(host=ABLETON_HOST, port=ABLETON_PORT)
+            if _ableton_connection.connect():
+                logger.info("Created new persistent connection to Ableton")
+                return _ableton_connection
+            _ableton_connection = None
+        except Exception as e:
+            logger.error(f"Connection attempt {attempt} failed: {str(e)}")
+            if _ableton_connection:
+                _ableton_connection.disconnect()
+                _ableton_connection = None
+        if attempt < max_attempts:
+            time.sleep(1.0)
+
+    logger.error("Failed to connect to Ableton after multiple attempts")
+    raise Exception("Could not connect to Ableton. Make sure the Remote Script is running.")
+
+
+def disconnect_ableton():
+    """Tear down the shared connection (used at server shutdown)."""
+    global _ableton_connection
+    if _ableton_connection:
+        logger.info("Disconnecting from Ableton on shutdown")
+        try:
+            _ableton_connection.disconnect()
+        except Exception:
+            pass
+        _ableton_connection = None

mcp_server_ableton_live-1.0.1/MCP_Server/server.py

@@ -0,0 +1,39 @@
+"""AbletonMCP server entrypoint.
+
+Importing MCP_Server.tools registers every @mcp.tool with the FastMCP app.
+"""
+
+import logging
+
+from . import tools  # noqa: F401  (tool registration side effect)
+from .app import mcp
+
+
+def main():
+    """Run the MCP server, or a setup subcommand (install/uninstall/doctor)."""
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] in (
+        "install",
+        "uninstall",
+        "doctor",
+        "--help",
+        "-h",
+        "help",
+        "--version",
+        "-V",
+        "version",
+    ):
+        from . import cli
+
+        sys.exit(cli.run(sys.argv[1:]))
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

mcp_server_ableton_live-1.0.1/MCP_Server/tools/__init__.py

@@ -0,0 +1,29 @@
+"""Import selected tool modules so their @mcp.tool decorators register.
+
+Set ABLETON_TOOLSETS to a comma-separated subset to load fewer tools (helps LLMs
+pick the right tool when the full 104-tool surface is more than a task needs),
+e.g. ABLETON_TOOLSETS="session,tracks,clips,generators". Default loads all.
+Available: session, tracks, clips, devices, browser, arrangement, generators, prompts.
+"""
+
+import importlib
+import os
+
+_ALL = ["session", "tracks", "clips", "devices", "browser", "arrangement", "generators", "prompts"]
+
+_requested = os.environ.get("ABLETON_TOOLSETS", "").strip()
+if _requested and _requested.lower() != "all":
+    _named = [m.strip() for m in _requested.split(",") if m.strip()]
+    _unknown = [m for m in _named if m not in _ALL]
+    if _unknown:
+        raise ValueError(
+            f"Unknown ABLETON_TOOLSETS: {_unknown}. Valid groups: {[g for g in _ALL if g != 'prompts']}"
+        )
+    _selected = [m for m in _named if m in _ALL]
+    if "prompts" not in _selected:
+        _selected.append("prompts")
+else:
+    _selected = _ALL
+
+for _m in _selected:
+    importlib.import_module(f".{_m}", __name__)

mcp_server_ableton_live-1.0.1/MCP_Server/tools/_util.py

@@ -0,0 +1,6 @@
+"""Shared helpers for tool modules."""
+
+
+def params(**kw):
+    """Build a wire-params dict, dropping None values (omitted optionals)."""
+    return {k: v for k, v in kw.items() if v is not None}

mcp_server_ableton_live-1.0.1/MCP_Server/tools/arrangement.py

@@ -0,0 +1,144 @@
+"""Arrangement view, timeline placement, and clip automation."""
+
+import json
+
+from mcp.server.fastmcp import Context
+from mcp.types import ToolAnnotations
+
+from ..app import mcp
+from ..connection import get_ableton_connection
+
+
+@mcp.tool(annotations=ToolAnnotations(destructiveHint=False))
+def switch_to_arrangement_view(ctx: Context) -> str:
+    """Switch Ableton's main window to the Arrangement view.
+
+    Parameters:
+    """
+    ableton = get_ableton_connection()
+    ableton.send_command("switch_to_arrangement_view")
+    return "Switched to Arrangement view"
+
+
+@mcp.tool(annotations=ToolAnnotations(destructiveHint=False))
+def set_arrangement_time(ctx: Context, time: float) -> str:
+    """
+    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)
+    """
+    ableton = get_ableton_connection()
+    result = ableton.send_command("set_current_song_time", {"time": time})
+    return f"Playhead moved to beat {result.get('current_song_time', time)}"
+
+
+@mcp.tool(annotations=ToolAnnotations(readOnlyHint=True))
+def get_arrangement_clips(ctx: Context, track_index: int) -> str:
+    """
+    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
+    """
+    ableton = get_ableton_connection()
+    result = ableton.send_command("get_arrangement_clips", {"track_index": track_index})
+    return json.dumps(result, indent=2)
+
+
+@mcp.tool(annotations=ToolAnnotations(destructiveHint=True))
+def duplicate_to_arrangement(
+    ctx: Context, track_index: int, clip_index: int, destination_time: float
+) -> str:
+    """
+    Copy a Session-view clip into the Arrangement timeline.
+
+    OVERWRITES whatever already occupies the destination range on that track
+    (like recording over tape) - this is also the supported way to REPLACE a
+    section. 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)
+    """
+    ableton = get_ableton_connection()
+    result = ableton.send_command(
+        "duplicate_session_clip_to_arrangement",
+        {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "destination_time": destination_time,
+        },
+    )
+    clip_name = result.get("clip_name", "clip")
+    track_name = result.get("track_name", f"track {track_index}")
+    return (
+        f"Duplicated '{clip_name}' from Session slot {clip_index} "
+        f"on '{track_name}' to arrangement at beat {destination_time}"
+    )
+
+
+@mcp.tool(annotations=ToolAnnotations(destructiveHint=True))
+def delete_arrangement_clip(ctx: Context, track_index: int, arrangement_clip_index: int) -> str:
+    """Delete a clip from the Arrangement timeline by its position in
+    get_arrangement_clips' list. NOTE: indices of later clips on the same track
+    shift down by one after each delete - re-read get_arrangement_clips between
+    deletes.
+    """
+    result = get_ableton_connection().send_command(
+        "delete_arrangement_clip",
+        {"track_index": track_index, "arrangement_clip_index": arrangement_clip_index},
+    )
+    return f"Deleted arrangement clip '{result.get('name')}' ({result.get('start_time')}-{result.get('end_time')})"
+
+
+@mcp.tool(annotations=ToolAnnotations(destructiveHint=False))
+def write_automation(
+    ctx: Context,
+    track_index: int,
+    clip_index: int,
+    device_index: int,
+    parameter: str | int,
+    points: list[dict[str, float]],
+) -> str:
+    """Write clip automation for a device parameter. points = [{"time": beats, "value": v}, ...].
+    Replaces any existing envelope for that parameter on the clip."""
+    r = get_ableton_connection().send_command(
+        "write_automation",
+        {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "device_index": device_index,
+            "parameter": parameter,
+            "points": points,
+        },
+    )
+    return f"Wrote {r.get('point_count')} automation points for {r.get('parameter')}"
+
+
+@mcp.tool(annotations=ToolAnnotations(destructiveHint=False))
+def clear_automation(
+    ctx: Context, track_index: int, clip_index: int, device_index: int, parameter: str | int
+) -> str:
+    """Clear the clip automation envelope for a device parameter."""
+    r = get_ableton_connection().send_command(
+        "clear_automation",
+        {
+            "track_index": track_index,
+            "clip_index": clip_index,
+            "device_index": device_index,
+            "parameter": parameter,
+        },
+    )
+    return f"Cleared automation for {r.get('parameter')}"