reaper-mcp-server 0.1.0__tar.gz

reaper_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,40 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+env/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+Thumbs.db
+
+# REAPER specific
+*.RPP-bak
+*.reapeaks

reaper_mcp_server-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Youssef Hemimy
+
+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.

reaper_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: reaper-mcp-server
+Version: 0.1.0
+Summary: MCP server for controlling REAPER DAW with AI agents
+Project-URL: Homepage, https://github.com/bonfire-audio/reaper-mcp
+Project-URL: Repository, https://github.com/bonfire-audio/reaper-mcp
+Project-URL: Issues, https://github.com/bonfire-audio/reaper-mcp/issues
+Author-email: Youssef Hemimy <itsuzef@users.noreply.github.com>
+License: MIT
+License-File: LICENSE
+Keywords: audio,daw,mastering,mcp,midi,mixing,music,reaper
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.10
+Requires-Dist: librosa>=0.10.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: platformdirs>=3.0.0
+Requires-Dist: pyloudnorm>=0.1.1
+Requires-Dist: python-reapy>=0.10.0
+Requires-Dist: soundfile>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# REAPER MCP Server
+
+A Model Context Protocol (MCP) server that enables AI agents to control REAPER DAW — 58 tools covering project management, tracks, MIDI, FX, mixing, mastering, rendering, and audio analysis.
+
+## Requirements
+
+- [REAPER](https://www.reaper.fm/) DAW installed and running
+- Python 3.10+
+- REAPER's distant API enabled (see [Setup](#setting-up-reaper))
+
+## Installation
+
+```bash
+pip install reaper-mcp-server
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/bonfire-audio/reaper-mcp.git
+cd reaper-mcp
+pip install -e .
+```
+
+## Setting Up REAPER
+
+The server communicates with REAPER via [python-reapy](https://github.com/RomeoDespres/reapy), which requires REAPER's distant API to be enabled.
+
+### Option 1: Run the setup script
+
+```bash
+python scripts/enable_reapy.py
+```
+
+### Option 2: Manual setup
+
+1. Open REAPER
+2. Go to Actions > Run ReaScript
+3. Run this Python code:
+   ```python
+   import reapy
+   reapy.config.enable_dist_api()
+   ```
+
+## Usage
+
+### With Claude Desktop
+
+Add to your Claude Desktop config (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "reaper": {
+      "command": "reaper-mcp-server",
+      "args": []
+    }
+  }
+}
+```
+
+### With Claude Code
+
+```bash
+claude mcp add reaper -- reaper-mcp-server
+```
+
+### Standalone
+
+```bash
+reaper-mcp-server          # start the server
+reaper-mcp-server --debug  # with debug logging
+```
+
+## Tools (58)
+
+### Project Management
+`create_project` `load_project` `save_project` `get_project_info` `set_tempo` `set_time_signature` `set_cursor_position` `play_project` `stop_transport`
+
+### Tracks
+`create_track` `delete_track` `rename_track` `list_tracks` `get_track_info` `set_track_color` `create_bus` `create_send` `remove_send` `list_sends`
+
+### MIDI
+`create_midi_item` `add_midi_note` `create_chord_progression` `create_drum_pattern`
+
+### FX & Instruments
+`add_fx` `remove_fx` `bypass_fx` `list_track_fx` `get_fx_parameters` `set_fx_parameter` `load_fx_preset` `add_master_fx` `list_master_fx` `set_master_fx_parameter`
+
+### Audio
+`import_audio_file` `edit_audio_item` `start_recording` `adjust_pitch` `adjust_playback_rate`
+
+### Mixing
+`set_track_volume` `set_track_pan` `set_track_mute` `set_track_solo` `set_send_volume` `set_master_volume` `add_volume_automation` `add_pan_automation`
+
+### Rendering
+`render_project` `render_stems` `render_time_selection`
+
+### Mastering
+`apply_mastering_chain` `apply_limiter` `normalize_project`
+
+### Analysis
+`analyze_loudness` `analyze_dynamics` `analyze_frequency_spectrum` `analyze_stereo_field` `analyze_transients` `detect_clipping`
+
+## Configuration
+
+The server stores its configuration in your platform's config directory:
+
+- macOS: `~/Library/Application Support/reaper-mcp/config.json`
+- Linux: `~/.config/reaper-mcp/config.json`
+- Windows: `%APPDATA%\reaper-mcp\config.json`
+
+## License
+
+MIT

reaper_mcp_server-0.1.0/README.md

@@ -0,0 +1,114 @@
+# REAPER MCP Server
+
+A Model Context Protocol (MCP) server that enables AI agents to control REAPER DAW — 58 tools covering project management, tracks, MIDI, FX, mixing, mastering, rendering, and audio analysis.
+
+## Requirements
+
+- [REAPER](https://www.reaper.fm/) DAW installed and running
+- Python 3.10+
+- REAPER's distant API enabled (see [Setup](#setting-up-reaper))
+
+## Installation
+
+```bash
+pip install reaper-mcp-server
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/bonfire-audio/reaper-mcp.git
+cd reaper-mcp
+pip install -e .
+```
+
+## Setting Up REAPER
+
+The server communicates with REAPER via [python-reapy](https://github.com/RomeoDespres/reapy), which requires REAPER's distant API to be enabled.
+
+### Option 1: Run the setup script
+
+```bash
+python scripts/enable_reapy.py
+```
+
+### Option 2: Manual setup
+
+1. Open REAPER
+2. Go to Actions > Run ReaScript
+3. Run this Python code:
+   ```python
+   import reapy
+   reapy.config.enable_dist_api()
+   ```
+
+## Usage
+
+### With Claude Desktop
+
+Add to your Claude Desktop config (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "reaper": {
+      "command": "reaper-mcp-server",
+      "args": []
+    }
+  }
+}
+```
+
+### With Claude Code
+
+```bash
+claude mcp add reaper -- reaper-mcp-server
+```
+
+### Standalone
+
+```bash
+reaper-mcp-server          # start the server
+reaper-mcp-server --debug  # with debug logging
+```
+
+## Tools (58)
+
+### Project Management
+`create_project` `load_project` `save_project` `get_project_info` `set_tempo` `set_time_signature` `set_cursor_position` `play_project` `stop_transport`
+
+### Tracks
+`create_track` `delete_track` `rename_track` `list_tracks` `get_track_info` `set_track_color` `create_bus` `create_send` `remove_send` `list_sends`
+
+### MIDI
+`create_midi_item` `add_midi_note` `create_chord_progression` `create_drum_pattern`
+
+### FX & Instruments
+`add_fx` `remove_fx` `bypass_fx` `list_track_fx` `get_fx_parameters` `set_fx_parameter` `load_fx_preset` `add_master_fx` `list_master_fx` `set_master_fx_parameter`
+
+### Audio
+`import_audio_file` `edit_audio_item` `start_recording` `adjust_pitch` `adjust_playback_rate`
+
+### Mixing
+`set_track_volume` `set_track_pan` `set_track_mute` `set_track_solo` `set_send_volume` `set_master_volume` `add_volume_automation` `add_pan_automation`
+
+### Rendering
+`render_project` `render_stems` `render_time_selection`
+
+### Mastering
+`apply_mastering_chain` `apply_limiter` `normalize_project`
+
+### Analysis
+`analyze_loudness` `analyze_dynamics` `analyze_frequency_spectrum` `analyze_stereo_field` `analyze_transients` `detect_clipping`
+
+## Configuration
+
+The server stores its configuration in your platform's config directory:
+
+- macOS: `~/Library/Application Support/reaper-mcp/config.json`
+- Linux: `~/.config/reaper-mcp/config.json`
+- Windows: `%APPDATA%\reaper-mcp\config.json`
+
+## License
+
+MIT

reaper_mcp_server-0.1.0/config.json

@@ -0,0 +1,11 @@
+{
+  "reaper_path": "/Applications/REAPER.app",
+  "default_project_directory": "/Users/youssefhemimy/Documents/REAPER Projects",
+  "vst_directories": ["/Library/Audio/Plug-Ins/VST", "/Library/Audio/Plug-Ins/VST3"],
+  "sample_libraries": ["/Volumes/ExtremeSSD/Soundbanks/SB_October"],
+  "default_tempo": 120.0,
+  "default_time_signature": "4/4",
+  "default_sample_rate": 48000,
+  "default_bit_depth": 24,
+  "default_audio_format": "wav"
+}

reaper_mcp_server-0.1.0/custom_mcp_server.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Custom MCP Server for REAPER
+This script provides a robust MCP server implementation that should work with IDE integration
+"""
+
+import json
+import sys
+import os
+import reapy
+from mcp.server.fastmcp import FastMCP
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    stream=sys.stderr)
+logger = logging.getLogger("reaper-mcp")
+
+# Create the MCP server
+mcp = FastMCP("ReaperMCP")
+
+# Connect to REAPER
+try:
+    logger.info("Attempting to connect to REAPER...")
+    reapy.connect()
+    logger.info("Successfully connected to REAPER")
+except Exception as e:
+    logger.error(f"Failed to connect to REAPER: {e}")
+    logger.error("Make sure REAPER is running with ReaScript API enabled")
+    sys.exit(1)
+
+# Simple tool definitions
+@mcp.tool()
+def create_project(name, template=None):
+    """Creates a new REAPER project."""
+    try:
+        project = reapy.Project()
+        if name:
+            project.save(os.path.join(os.path.expanduser("~/Documents/REAPER Projects"), f"{name}.rpp"))
+        return {"success": True, "message": f"Created project: {name}"}
+    except Exception as e:
+        logger.error(f"Error creating project: {e}")
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+def create_track(name=None):
+    """Creates a new track in the current project."""
+    try:
+        project = reapy.Project()
+        track = project.add_track(index=project.n_tracks, name=name)
+        return {"success": True, "track_index": track.index}
+    except Exception as e:
+        logger.error(f"Error creating track: {e}")
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+def list_tracks():
+    """Lists all tracks in the current project."""
+    try:
+        project = reapy.Project()
+        tracks = []
+        for i in range(project.n_tracks):
+            track = project.tracks[i]
+            tracks.append({
+                "index": i,
+                "name": track.name,
+                "is_selected": track.is_selected
+            })
+        return {"success": True, "tracks": tracks}
+    except Exception as e:
+        logger.error(f"Error listing tracks: {e}")
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+def add_midi_note(track_index, note, start_time, duration, velocity=100):
+    """Adds a MIDI note to a track."""
+    try:
+        project = reapy.Project()
+        track = project.tracks[track_index]
+        item = track.add_item(start=start_time, length=duration)
+        take = item.add_take()
+        take.add_note(note=note, start=0, end=duration, velocity=velocity)
+        return {"success": True, "message": f"Added note {note} to track {track_index}"}
+    except Exception as e:
+        logger.error(f"Error adding MIDI note: {e}")
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+def get_project_info():
+    """Gets information about the current project."""
+    try:
+        project = reapy.Project()
+        return {
+            "success": True,
+            "name": project.name,
+            "path": project.path,
+            "length": project.length,
+            "track_count": project.n_tracks,
+            "selected_track_count": project.n_selected_tracks
+        }
+    except Exception as e:
+        logger.error(f"Error getting project info: {e}")
+        return {"success": False, "error": str(e)}
+
+# Run the server
+if __name__ == "__main__":
+    logger.info("Starting custom REAPER MCP Server...")
+    # Use stdio transport for MCP protocol
+    mcp.run(transport='stdio')

reaper_mcp_server-0.1.0/examples/create_drum_kit_actions.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Create a drum kit in REAPER using OSC action IDs
+This script uses REAPER's specific action IDs to create tracks properly
+"""
+
+import sys
+import time
+from pythonosc import udp_client
+
+# OSC settings (matching our server configuration)
+REAPER_OSC_HOST = "192.168.1.110"
+REAPER_OSC_PORT = 8000
+
+# REAPER Action IDs
+ACTION_NEW_PROJECT = 40023
+ACTION_INSERT_TRACK = 40001
+ACTION_SELECT_TRACK_1 = 40939
+ACTION_SELECT_TRACK_2 = 40940
+ACTION_SELECT_TRACK_3 = 40941
+ACTION_SELECT_TRACK_4 = 40942
+ACTION_INSERT_MIDI_ITEM = 40214
+ACTION_SET_TEMPO = 40364
+
+def main():
+    print("Creating a drum kit in REAPER using action IDs...")
+    
+    # Create OSC client
+    client = udp_client.SimpleUDPClient(REAPER_OSC_HOST, REAPER_OSC_PORT)
+    
+    # Create a new project
+    print("Creating a new project...")
+    client.send_message("/action", [ACTION_NEW_PROJECT])
+    time.sleep(1.5)
+    
+    # Create drum tracks (we need to create 4 tracks)
+    track_names = ["Kick", "Snare", "Hi-Hat", "Crash"]
+    
+    for i, name in enumerate(track_names):
+        if i > 0:  # First track already exists, create additional tracks
+            print(f"Creating track {i+1}...")
+            client.send_message("/action", [ACTION_INSERT_TRACK])
+            time.sleep(0.8)
+        
+        # Select the track (track 1 is already selected after creation)
+        if i == 1:
+            client.send_message("/action", [ACTION_SELECT_TRACK_2])
+        elif i == 2:
+            client.send_message("/action", [ACTION_SELECT_TRACK_3])
+        elif i == 3:
+            client.send_message("/action", [ACTION_SELECT_TRACK_4])
+        time.sleep(0.5)
+        
+        # Name the track
+        print(f"Naming track: {name}...")
+        client.send_message(f"/track/{i}/name", [name])
+        time.sleep(0.5)
+        
+        # Insert MIDI item
+        print(f"Adding MIDI item to {name} track...")
+        client.send_message("/action", [ACTION_INSERT_MIDI_ITEM])
+        time.sleep(0.8)
+    
+    # Set project tempo to 120 BPM
+    print("Setting project tempo to 120 BPM...")
+    # First select tempo dialog
+    client.send_message("/action", [ACTION_SET_TEMPO])
+    time.sleep(0.8)
+    # Then send the tempo value (this might not work via OSC, but worth trying)
+    client.send_message("/tempo", [120.0])
+    time.sleep(0.5)
+    
+    print("\nDrum kit created with the following tracks:")
+    for name in track_names:
+        print(f"- {name}")
+    
+    print("\nCheck REAPER to see if the tracks were created properly.")
+    print("You may need to manually set the tempo to 120 BPM if that didn't work via OSC.")
+
+if __name__ == "__main__":
+    main()

reaper_mcp_server-0.1.0/examples/create_drum_pattern.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Create a simple drum pattern in REAPER using OSC
+This script demonstrates how to create a more complex musical pattern using OSC
+"""
+
+import sys
+import time
+from pythonosc import udp_client
+
+# OSC settings (matching our server configuration)
+REAPER_OSC_HOST = "192.168.1.110"
+REAPER_OSC_PORT = 8000
+
+def main():
+    print("Creating a drum pattern in REAPER using OSC...")
+    
+    # Create OSC client
+    client = udp_client.SimpleUDPClient(REAPER_OSC_HOST, REAPER_OSC_PORT)
+    
+    # Create a new project
+    print("Creating a new project...")
+    client.send_message("/new", None)
+    time.sleep(1)
+    
+    # Set project tempo to 120 BPM
+    print("Setting project tempo to 120 BPM...")
+    client.send_message("/tempo", [120.0])
+    time.sleep(0.5)
+    
+    # Create drum tracks
+    track_names = ["Kick", "Snare", "Hi-Hat", "Crash"]
+    
+    for i, name in enumerate(track_names):
+        print(f"Creating track: {name}...")
+        client.send_message("/track/add", None)
+        time.sleep(0.5)
+        client.send_message(f"/track/{i}/name", [name])
+        time.sleep(0.2)
+    
+    # Create a 4-bar pattern (16 beats at 4/4)
+    print("Creating MIDI items for the pattern...")
+    
+    # Pattern definitions (1 = hit, 0 = rest)
+    patterns = {
+        "Kick":   [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
+        "Snare":  [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0],
+        "Hi-Hat": [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+        "Crash":  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    }
+    
+    # Create MIDI items for each track
+    for i, (track_name, pattern) in enumerate(patterns.items()):
+        # Select the track
+        client.send_message(f"/track/{i}/select", [1])
+        time.sleep(0.2)
+        
+        # Insert a 4-bar MIDI item
+        client.send_message("/insert/midi", None)
+        time.sleep(0.5)
+        
+        # We can't directly add MIDI notes via OSC
+        # But we've created the MIDI items that can be edited in REAPER
+        
+        print(f"Created pattern for {track_name}")
+    
+    print("\nDrum pattern created! You'll need to add the actual MIDI notes in REAPER.")
+    print("The pattern structure is:")
+    
+    # Print the pattern as a visual representation
+    for name, pattern in patterns.items():
+        pattern_str = ""
+        for beat in pattern:
+            pattern_str += "X " if beat == 1 else "- "
+        print(f"{name.ljust(8)}: {pattern_str}")
+    
+    print("\nYou can now open the MIDI editor in REAPER to add the notes according to this pattern.")
+
+if __name__ == "__main__":
+    main()

reaper_mcp_server-0.1.0/examples/create_tracks_fixed.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Create tracks in REAPER using OSC with a different approach
+This script tries different OSC commands to properly create new tracks
+"""
+
+import sys
+import time
+from pythonosc import udp_client
+
+# OSC settings (matching our server configuration)
+REAPER_OSC_HOST = "192.168.1.110"
+REAPER_OSC_PORT = 8000
+
+def main():
+    print("Testing different methods to create tracks in REAPER...")
+    
+    # Create OSC client
+    client = udp_client.SimpleUDPClient(REAPER_OSC_HOST, REAPER_OSC_PORT)
+    
+    # Method 1: Using the specific insert track command
+    print("\nMethod 1: Using /track/insert command...")
+    client.send_message("/track/insert", None)
+    time.sleep(1)
+    client.send_message("/track/0/name", ["Method 1 Track"])
+    time.sleep(1)
+    
+    # Method 2: Using the action ID for insert track
+    print("\nMethod 2: Using action ID for insert track...")
+    client.send_message("/action", [40001])  # Action ID for "Insert new track"
+    time.sleep(1)
+    client.send_message("/track/1/name", ["Method 2 Track"])
+    time.sleep(1)
+    
+    # Method 3: Using the track/add command with position
+    print("\nMethod 3: Using /track/add with position parameter...")
+    client.send_message("/track/add/last", None)
+    time.sleep(1)
+    client.send_message("/track/2/name", ["Method 3 Track"])
+    time.sleep(1)
+    
+    # Method 4: Using a different command structure
+    print("\nMethod 4: Using /insert/track command...")
+    client.send_message("/insert/track", None)
+    time.sleep(1)
+    client.send_message("/track/3/name", ["Method 4 Track"])
+    time.sleep(1)
+    
+    print("\nTest completed. Check REAPER to see which method worked for creating new tracks.")
+
+if __name__ == "__main__":
+    main()