Add Max for Live and CV Tools support (125 total tools)

Features:
- 5 new M4L-specific tools for device detection and control
- Detect Max for Live devices by class name
- Get all M4L devices or CV Tools devices on a track
- Control M4L device parameters by name (easier than index)
- Get/set parameter values for CV Tools (LFO, Shaper, Envelope Follower, etc.)

New Tools:
- is_max_device: Check if a device is Max for Live
- get_m4l_devices: Get all M4L devices on a track
- set_device_param_by_name: Set parameter by name (not index)
- get_m4l_param_by_name: Get parameter info by name
- get_cv_tools_devices: Get CV Tools devices specifically

Documentation:
- MAX4LIVE_INTEGRATION.md: Complete M4L integration guide
- examples/cv_tools_control.py: Working example controlling CV LFO
- Updated README with M4L/CV Tools section

Total tools: 120 → 125

Closes support for Max for Live devices and CV Tools pack

Author: Ziforge

ClaudeMCP_Remote/__init__.py

@@ -516,6 +516,18 @@ def _process_command(self, command):
             elif action == 'randomize_device':
                 return self.tools.randomize_device(command.get('track_index', 0), command.get('device_index', 0))
 
+            # Max for Live (M4L) operations
+            elif action == 'is_max_device':
+                return self.tools.is_max_device(command.get('track_index', 0), command.get('device_index', 0))
+            elif action == 'get_m4l_devices':
+                return self.tools.get_m4l_devices(command.get('track_index', 0))
+            elif action == 'set_device_param_by_name':
+                return self.tools.set_device_param_by_name(command.get('track_index', 0), command.get('device_index', 0), command.get('param_name', ''), command.get('value', 0.0))
+            elif action == 'get_m4l_param_by_name':
+                return self.tools.get_m4l_param_by_name(command.get('track_index', 0), command.get('device_index', 0), command.get('param_name', ''))
+            elif action == 'get_cv_tools_devices':
+                return self.tools.get_cv_tools_devices(command.get('track_index', 0))
+
             # Unknown action
             else:
                 return {

ClaudeMCP_Remote/liveapi_tools.py

@@ -2157,6 +2157,166 @@ def randomize_device(self, track_index, device_index):
         except Exception as e:
             return {"ok": False, "error": str(e)}
 
+    # ========================================================================
+    # MAX FOR LIVE (M4L) DEVICE OPERATIONS
+    # ========================================================================
+
+    def is_max_device(self, track_index, device_index):
+        """Check if device is a Max for Live device"""
+        try:
+            if track_index < 0 or track_index >= len(self.song.tracks):
+                return {"ok": False, "error": "Invalid track index"}
+
+            track = self.song.tracks[track_index]
+            if device_index < 0 or device_index >= len(track.devices):
+                return {"ok": False, "error": "Invalid device index"}
+
+            device = track.devices[device_index]
+
+            # M4L devices have specific class names
+            m4l_classes = ['MxDeviceAudioEffect', 'MxDeviceMidiEffect', 'MxDeviceInstrument']
+            is_m4l = device.class_name in m4l_classes
+
+            return {
+                "ok": True,
+                "is_m4l": is_m4l,
+                "class_name": str(device.class_name),
+                "class_display_name": str(device.class_display_name) if hasattr(device, 'class_display_name') else str(device.class_name),
+                "device_name": str(device.name)
+            }
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def get_m4l_devices(self, track_index):
+        """Get all Max for Live devices on track"""
+        try:
+            if track_index < 0 or track_index >= len(self.song.tracks):
+                return {"ok": False, "error": "Invalid track index"}
+
+            track = self.song.tracks[track_index]
+            m4l_devices = []
+            m4l_classes = ['MxDeviceAudioEffect', 'MxDeviceMidiEffect', 'MxDeviceInstrument']
+
+            for i, device in enumerate(track.devices):
+                if device.class_name in m4l_classes:
+                    device_type = self._get_m4l_type(device.class_name)
+                    m4l_devices.append({
+                        "index": i,
+                        "name": str(device.name),
+                        "class_name": str(device.class_name),
+                        "type": device_type,
+                        "is_active": device.is_active,
+                        "num_parameters": len(device.parameters)
+                    })
+
+            return {
+                "ok": True,
+                "track_index": track_index,
+                "track_name": str(track.name),
+                "devices": m4l_devices,
+                "count": len(m4l_devices)
+            }
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def _get_m4l_type(self, class_name):
+        """Get M4L device type from class name"""
+        type_map = {
+            'MxDeviceAudioEffect': 'audio_effect',
+            'MxDeviceMidiEffect': 'midi_effect',
+            'MxDeviceInstrument': 'instrument'
+        }
+        return type_map.get(class_name, 'unknown')
+
+    def set_device_param_by_name(self, track_index, device_index, param_name, value):
+        """Set device parameter by name (useful for M4L devices with custom parameter names)"""
+        try:
+            if track_index < 0 or track_index >= len(self.song.tracks):
+                return {"ok": False, "error": "Invalid track index"}
+
+            track = self.song.tracks[track_index]
+            if device_index < 0 or device_index >= len(track.devices):
+                return {"ok": False, "error": "Invalid device index"}
+
+            device = track.devices[device_index]
+
+            # Find parameter by name
+            for i, param in enumerate(device.parameters):
+                if str(param.name) == param_name:
+                    param.value = float(value)
+                    return {
+                        "ok": True,
+                        "track_index": track_index,
+                        "device_index": device_index,
+                        "param_name": param_name,
+                        "param_index": i,
+                        "value": float(param.value)
+                    }
+
+            return {"ok": False, "error": "Parameter '{}' not found".format(param_name)}
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def get_m4l_param_by_name(self, track_index, device_index, param_name):
+        """Get M4L device parameter value by name"""
+        try:
+            if track_index < 0 or track_index >= len(self.song.tracks):
+                return {"ok": False, "error": "Invalid track index"}
+
+            track = self.song.tracks[track_index]
+            if device_index < 0 or device_index >= len(track.devices):
+                return {"ok": False, "error": "Invalid device index"}
+
+            device = track.devices[device_index]
+
+            # Find parameter by name
+            for i, param in enumerate(device.parameters):
+                if str(param.name) == param_name:
+                    return {
+                        "ok": True,
+                        "param_index": i,
+                        "name": str(param.name),
+                        "value": float(param.value),
+                        "min": float(param.min),
+                        "max": float(param.max),
+                        "is_enabled": param.is_enabled if hasattr(param, 'is_enabled') else True
+                    }
+
+            return {"ok": False, "error": "Parameter '{}' not found".format(param_name)}
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
+    def get_cv_tools_devices(self, track_index):
+        """Get all CV Tools devices on track (subset of M4L devices)"""
+        try:
+            if track_index < 0 or track_index >= len(self.song.tracks):
+                return {"ok": False, "error": "Invalid track index"}
+
+            track = self.song.tracks[track_index]
+            cv_devices = []
+
+            for i, device in enumerate(track.devices):
+                device_name = str(device.name)
+                # Check if device name contains "CV" (common in CV Tools)
+                if 'CV' in device_name or 'cv' in device_name.lower():
+                    cv_devices.append({
+                        "index": i,
+                        "name": device_name,
+                        "class_name": str(device.class_name),
+                        "is_active": device.is_active,
+                        "num_parameters": len(device.parameters)
+                    })
+
+            return {
+                "ok": True,
+                "track_index": track_index,
+                "track_name": str(track.name),
+                "cv_devices": cv_devices,
+                "count": len(cv_devices)
+            }
+        except Exception as e:
+            return {"ok": False, "error": str(e)}
+
     # ========================================================================
     # UTILITY
     # ========================================================================
@@ -2225,5 +2385,8 @@ def get_available_tools(self):
             # Track routing extras (3 tools)
             "get_track_output_routing", "set_track_input_sub_routing", "set_track_output_sub_routing",
             # Device extras - missing tool (1 tool)
-            "randomize_device"
+            "randomize_device",
+            # Max for Live (M4L) operations (6 tools)
+            "is_max_device", "get_m4l_devices", "set_device_param_by_name",
+            "get_m4l_param_by_name", "get_cv_tools_devices"
         ]