AbletonMCP

Implementation Reference

• MCP_Server/server.py:674-683 (handler)

  The primary MCP tool handler for 'stop_recording'. It retrieves the Ableton connection, sends the 'stop_recording' command, and returns a formatted status message. The @mcp.tool() decorator also serves as the registration.

  @mcp.tool()
  def stop_recording(ctx: Context) -> str:
      try:
          ableton = get_ableton_connection()
          result = ableton.send_command("stop_recording")
          status = "recording" if result.get('recording') else "not recording"
          return f"Stopped recording - Status: {status}, Playing: {result.get('playing')}"
      except Exception as e:
          logger.error(f"Error stopping recording: {str(e)}")
          return f"Error stopping recording: {str(e)}"

• AbletonMCP_Remote_Script/__init__.py:1501-1513 (helper)

  The underlying implementation in the Ableton Live remote script that handles the 'stop_recording' command by stopping playback (which ends recording) and returning the updated recording and playing status.

  def _stop_recording(self):
      """Stop recording"""
      try:
          # Stop recording and playback
          self._song.stop_playing()
          
          result = {
              "recording": False,
              "playing": self._song.is_playing
          }
          return result
      except Exception as e:
          self.log_message("Error stopping recording: " + str(e))

• MCP_Server/server.py:196-249 (helper)

  Utility function used by the handler to obtain a persistent socket connection to the Ableton remote script server.

  def get_ableton_connection():
      """Get or create a persistent Ableton connection"""
      global _ableton_connection
  
      if _ableton_connection is not None:
          try:
              # quick liveness test (non-intrusive)
              _ableton_connection.sock.settimeout(0.5)
              _ableton_connection.sock.send(b'')  # may raise if broken
              _ableton_connection.sock.settimeout(None)
              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
  
      # Try to establish a new persistent connection (retries)
      max_attempts = 3
      for attempt in range(1, max_attempts + 1):
          try:
              logger.info(f"Connecting to Ableton (attempt {attempt}/{max_attempts})...")
              candidate = AbletonConnection(host="localhost", port=9877)
              if candidate.connect():
                  _ableton_connection = candidate
                  # basic validation
                  try:
                      _ableton_connection.send_command("get_session_info")
                      logger.info("Connection validated successfully")
                      return _ableton_connection
                  except Exception as e:
                      logger.error(f"Connection validation failed: {str(e)}")
                      _ableton_connection.disconnect()
                      _ableton_connection = None
              else:
                  _ableton_connection = None
          except Exception as e:
              logger.error(f"Connection attempt {attempt} failed: {str(e)}")
              if _ableton_connection:
                  try:
                      _ableton_connection.disconnect()
                  except Exception:
                      pass
                  _ableton_connection = None
  
          if attempt < max_attempts:
              import time
              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 and Ableton is open.")