iflow-mcp_ghchen99_mcp-musescore 0.1.0__py3-none-any.whl

iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_ghchen99_mcp-musescore
+Version: 0.1.0
+Summary: MCP server for MuseScore control through WebSocket
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: websockets>=13.0
+Description-Content-Type: text/markdown
+
+# MuseScore MCP Server
+
+A Model Context Protocol (MCP) server that provides programmatic control over MuseScore through a WebSocket-based plugin system. This allows AI assistants like Claude to compose music, add lyrics, navigate scores, and control MuseScore directly.
+
+![Demo GIF](./assets/mcp-muse.gif)
+
+## Prerequisites
+
+- MuseScore 3.x or 4.x
+- Python 3.8+
+- Claude Desktop or compatible MCP client
+
+## Setup
+
+### 1. Install the MuseScore Plugin
+
+First, save the QML plugin code to your MuseScore plugins directory:
+
+**macOS**: `~/Documents/MuseScore4/Plugins/musescore-mcp-websocket.qml`
+**Windows**: `%USERPROFILE%\Documents\MuseScore4\Plugins\musescore-mcp-websocket.qml`
+**Linux**: `~/Documents/MuseScore4/Plugins/musescore-mcp-websocket.qml`
+
+### 2. Enable the Plugin in MuseScore
+
+1. Open MuseScore
+2. Go to **Plugins → Plugin Manager**
+3. Find "MuseScore API Server" and check the box to enable it
+4. Click **OK**
+
+### 3. Setup Python Environment
+
+```bash
+git clone <your-repo>
+cd mcp-agents-demo
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install fastmcp websockets
+```
+
+### 4. Configure Claude Desktop
+
+Add to your Claude Desktop configuration file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "musescore": {
+      "command": "/path/to/your/project/.venv/bin/python",
+      "args": [
+        "/path/to/your/project/server.py"
+      ]
+    }
+  }
+}
+```
+
+**Note**: Update the paths to match your actual project location.
+
+## Running the System
+
+### Order of Operations (Important!)
+
+1. **Start MuseScore first** with a score open
+2. **Run the MuseScore plugin**: Go to **Plugins → MuseScore API Server**
+   - You should see console output: `"Starting MuseScore API Server on port 8765"`
+3. **Then start the Python MCP server** or restart Claude Desktop
+
+[insert screenshot of different functionality, harmonisation, melodywriting, as zoomed in GIFs]
+
+### Development and Testing
+
+For development, use the MCP development tools:
+
+```bash
+# Install MCP dev tools
+pip install mcp
+
+# Test your server
+mcp dev server.py
+
+# Check connection status
+mcp dev server.py --inspect
+```
+
+### Viewing Console Output
+
+To see MuseScore plugin console output, run MuseScore from terminal:
+
+**macOS**:
+```bash
+/Applications/MuseScore\ 4.app/Contents/MacOS/mscore
+```
+
+**Windows**:
+```cmd
+cd "C:\Program Files\MuseScore 4\bin"
+MuseScore.exe
+```
+
+**Linux**:
+```bash
+musescore4
+```
+
+## Features
+
+This MCP server provides comprehensive MuseScore control:
+
+### **Navigation & Cursor Control**
+- `get_cursor_info()` - Get current cursor position and selection info
+- `go_to_measure(measure)` - Navigate to specific measure
+- `go_to_beginning_of_score()` / `go_to_final_measure()` - Navigate to start/end
+- `next_element()` / `prev_element()` - Move cursor element by element
+- `next_staff()` / `prev_staff()` - Move between staves
+- `select_current_measure()` - Select entire current measure
+
+### **Note & Rest Creation**
+- `add_note(pitch, duration, advance_cursor_after_action)` - Add notes with MIDI pitch
+- `add_rest(duration, advance_cursor_after_action)` - Add rests
+- `add_tuplet(duration, ratio, advance_cursor_after_action)` - Add tuplets (triplets, etc.)
+
+### **Measure Management**
+- `insert_measure()` - Insert measure at current position
+- `append_measure(count)` - Add measures to end of score
+- `delete_selection(measure)` - Delete current selection or specific measure
+
+### **Lyrics & Text**
+- `add_lyrics_to_current_note(text)` - Add lyrics to current note
+- `add_lyrics(lyrics_list)` - Batch add lyrics to multiple notes
+- `set_title(title)` - Set score title
+
+### **Score Information**
+- `get_score()` - Get complete score analysis and structure
+- `ping_musescore()` - Test connection to MuseScore
+- `connect_to_musescore()` - Establish WebSocket connection
+
+### **Utilities**
+- `undo()` - Undo last action
+- `set_time_signature(numerator, denominator)` - Change time signature
+- `processSequence(sequence)` - Execute multiple commands in batch
+
+## Sample Music
+
+Check out the `/examples` folder for sample MuseScore files demonstrating various musical styles:
+
+- **Asian Instrumental** - Traditional Asian-inspired instrumental piece
+- **String Quartet** - Classical string quartet arrangement
+
+Each example includes:
+- `.mscz` - MuseScore file (editable)
+- `.pdf` - Sheet music
+- `.mp3` - Audio preview
+
+## Usage Examples
+
+### Creating a Simple Melody
+
+```python
+# Set up the score
+await set_title("My First Song")
+await go_to_beginning_of_score()
+
+# Add notes (MIDI pitch: 60=C, 62=D, 64=E, etc.)
+await add_note(60, {"numerator": 1, "denominator": 4}, True)  # Quarter note C
+await add_note(64, {"numerator": 1, "denominator": 4}, True)  # Quarter note E
+await add_note(67, {"numerator": 1, "denominator": 4}, True)  # Quarter note G
+await add_note(72, {"numerator": 1, "denominator": 2}, True)  # Half note C
+
+# Add lyrics
+await go_to_beginning_of_score()
+await add_lyrics_to_current_note("Do")
+await next_element()
+await add_lyrics_to_current_note("Mi")
+await next_element()
+await add_lyrics_to_current_note("Sol")
+await next_element()
+await add_lyrics_to_current_note("Do")
+```
+
+### Batch Operations
+
+```python
+# Add multiple lyrics at once
+await add_lyrics(["Twin-", "kle", "twin-", "kle", "lit-", "tle", "star"])
+
+# Use sequence processing for complex operations
+sequence = [
+    {"action": "goToBeginningOfScore", "params": {}},
+    {"action": "addNote", "params": {"pitch": 60, "duration": {"numerator": 1, "denominator": 4}, "advanceCursorAfterAction": True}},
+    {"action": "addNote", "params": {"pitch": 64, "duration": {"numerator": 1, "denominator": 4}, "advanceCursorAfterAction": True}},
+    {"action": "addRest", "params": {"duration": {"numerator": 1, "denominator": 4}, "advanceCursorAfterAction": True}}
+]
+await processSequence(sequence)
+```
+
+## Troubleshooting
+
+### Connection Issues
+- **"Not connected to MuseScore"**: 
+  - Ensure MuseScore is running with a score open
+  - Run the MuseScore plugin (Plugins → MuseScore API Server)
+  - Check that port 8765 isn't blocked by firewall
+
+### Plugin Issues
+- **Plugin not appearing**: Check the `.qml` file is in the correct plugins directory
+- **Plugin won't enable**: Restart MuseScore after placing the plugin file
+- **No console output**: Run MuseScore from terminal to see debug messages
+
+### Python Server Issues
+- **"No server object found"**: The server object must be named `mcp`, `server`, or `app` at module level
+- **WebSocket errors**: Make sure MuseScore plugin is running before starting Python server
+- **Connection timeout**: The MuseScore plugin must be actively running, not just enabled
+
+### API Limitations
+- **Lyrics**: Only first verse supported in MuseScore 3.x plugin API
+- **Title setting**: Uses multiple fallback methods due to frame access limitations
+- **Selection persistence**: Some operations may affect current selection
+
+## File Structure
+
+```
+mcp-agents-demo/
+├── .venv/
+├── server.py                           # Python MCP server entry point
+├── musescore-mcp-websocket.qml         # MuseScore plugin
+├── requirements.txt
+├── README.md
+└── src/                                # Source code modules
+    ├── __init__.py
+    ├── client/                         # WebSocket client functionality
+    │   ├── __init__.py
+    │   └── websocket_client.py
+    ├── tools/                          # MCP tool implementations
+    │   ├── __init__.py
+    │   ├── connection.py               # Connection management tools
+    │   ├── navigation.py               # Score navigation tools
+    │   ├── notes_measures.py           # Note and measure manipulation
+    │   ├── sequences.py                # Batch operation tools
+    │   ├── staff_instruments.py        # Staff and instrument tools
+    │   └── time_tempo.py               # Timing and tempo tools
+    └── types/                          # Type definitions
+        ├── __init__.py
+        └── action_types.py             # WebSocket action type definitions
+```
+
+## Requirements
+
+Create a `requirements.txt` file with:
+
+```
+fastmcp
+websockets
+```
+
+## MIDI Pitch Reference
+
+Common MIDI pitch values for reference:
+- **Middle C**: 60
+- **C Major Scale**: 60, 62, 64, 65, 67, 69, 71, 72
+- **Chromatic**: C=60, C#=61, D=62, D#=63, E=64, F=65, F#=66, G=67, G#=68, A=69, A#=70, B=71
+
+## Duration Reference
+
+Duration format: `{"numerator": int, "denominator": int}`
+- **Whole note**: `{"numerator": 1, "denominator": 1}`
+- **Half note**: `{"numerator": 1, "denominator": 2}`
+- **Quarter note**: `{"numerator": 1, "denominator": 4}`
+- **Eighth note**: `{"numerator": 1, "denominator": 8}`
+- **Dotted quarter**: `{"numerator": 3, "denominator": 8}`

iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+server.py,sha256=9dIrI669T4c8VCAF4iP7h_5v_o-NX1H2AG9K6mBt3uo,1130
+src/__init__.py,sha256=-jib-i1HuFU7ElFWBWohFghvPOE7AveBCFjeie62eGE,110
+src/client/__init__.py,sha256=MNyf4k-4MdWouGG0P1ConsLs6UnNvOGjXCEWmOTWsD8,129
+src/client/websocket_client.py,sha256=3FzE9dbrDMWb1LZ3-uG1FFWPAyIYXk6KMfvHRtC1vSI,1944
+src/tools/__init__.py,sha256=bJbvf3pA5bFypW0MIC-QeaS822n5LrO8af0eAY2KYoI,547
+src/tools/connection.py,sha256=0HrzZJDb0er9t-roIP5za_8C7uv4Gxg0RBYAom8-J4g,703
+src/tools/navigation.py,sha256=R4GI4Oal97y6EZbFa6NEwzsTdgDevAIFCfhjEEWjIVE,1667
+src/tools/notes_measures.py,sha256=HzjBcX-JaWAr1FwJI61WPVWTtsHDXn6GE84FuerPwIM,3676
+src/tools/sequences.py,sha256=QEeCVc6D9gqSzTN8DnoEg0yhjC5pIhXAI1muNnBwQp4,491
+src/tools/staff_instruments.py,sha256=3dv6ab2lDt7jYYBANZ2YTMhp4K7YzKEnHf7T7UucXyM,1303
+src/tools/time_tempo.py,sha256=mHpyits3jIfjNJAMypcNHkR39-8-F1hHT7cqT41eloQ,678
+src/types/__init__.py,sha256=zu6KFs8c4Ex6dw_Re1xok3EjUmVF7KPoY4LVKEStFxY,679
+src/types/action_types.py,sha256=t-24oOqlQan3UA0-VLT1D3Gy_rpZaguumh8JTYWbnEo,277
+iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/METADATA,sha256=9Ns82Sb6z7lnQJcAOlNKyeztdd-XtH8tOhbGmWCg5Ac,9196
+iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/entry_points.txt,sha256=jbMwCNQtTWK1AFnvDssHEwY1a99FqLTWxSxvYCWMAzo,46
+iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/licenses/LICENSE,sha256=mc8W3ZAoSXw3qToh-9CfxDqZ8XRyykACU5kBlqdlBuI,1068
+iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/RECORD,,

iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+musescore-mcp = server:main

iflow_mcp_ghchen99_mcp_musescore-0.1.0.dist-info/licenses/LICENSE

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

server.py

@@ -0,0 +1,44 @@
+from mcp.server.fastmcp import FastMCP
+import sys
+import logging
+
+# Import modular components
+from src.client import MuseScoreClient
+from src.tools import (
+    setup_connection_tools,
+    setup_navigation_tools,
+    setup_notes_measures_tools,
+    setup_staff_instruments_tools,
+    setup_time_tempo_tools,
+    setup_sequence_tools
+)
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stderr)]
+)
+logger = logging.getLogger("MuseScoreMCP")
+
+# Create the MCP app and client
+mcp = FastMCP("MuseScore Assistant")
+client = MuseScoreClient()
+
+# Setup all tool categories
+setup_connection_tools(mcp, client)
+setup_navigation_tools(mcp, client)
+setup_notes_measures_tools(mcp, client)
+setup_staff_instruments_tools(mcp, client)
+setup_time_tempo_tools(mcp, client)
+setup_sequence_tools(mcp, client)
+
+# Main entry point
+def main():
+    sys.stderr.write("MuseScore MCP Server starting up...\n")
+    sys.stderr.flush()
+    logger.info("MuseScore MCP Server is running")
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

src/__init__.py

@@ -0,0 +1,3 @@
+"""MuseScore MCP Server - A Model Context Protocol server for MuseScore integration."""
+
+__version__ = "1.0.0"

src/client/__init__.py

@@ -0,0 +1,5 @@
+"""WebSocket client for MuseScore communication."""
+
+from .websocket_client import MuseScoreClient
+
+__all__ = ["MuseScoreClient"]

src/client/websocket_client.py

@@ -0,0 +1,55 @@
+"""WebSocket client for communicating with MuseScore."""
+
+import websockets
+import json
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger("MuseScoreMCP.Client")
+
+
+class MuseScoreClient:
+    """Client to communicate with MuseScore WebSocket API."""
+    
+    def __init__(self, host: str = "localhost", port: int = 8765):
+        self.uri = f"ws://{host}:{port}"
+        self.websocket = None
+    
+    async def connect(self):
+        """Connect to the MuseScore WebSocket API."""
+        try:
+            self.websocket = await websockets.connect(self.uri)
+            logger.info(f"Connected to MuseScore API at {self.uri}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to MuseScore API: {str(e)}")
+            return False
+    
+    async def send_command(self, action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Send a command to MuseScore and wait for response."""
+        if not self.websocket:
+            connected = await self.connect()
+            if not connected:
+                return {"error": "Not connected to MuseScore"}
+        
+        if params is None:
+            params = {}
+        
+        command = {"action": action, "params": params}
+        
+        try:
+            logger.info(f"Sending command: {json.dumps(command)}")
+            await self.websocket.send(json.dumps(command))
+            response = await self.websocket.recv()
+            logger.info(f"Received response: {response}")
+            return json.loads(response)
+        except Exception as e:
+            logger.error(f"Error sending command: {str(e)}")
+            return {"error": str(e)}
+    
+    async def close(self):
+        """Close the WebSocket connection."""
+        if self.websocket:
+            await self.websocket.close()
+            self.websocket = None
+            logger.info("Disconnected from MuseScore API")

src/tools/__init__.py

@@ -0,0 +1,17 @@
+"""MCP tools for MuseScore operations."""
+
+from .connection import setup_connection_tools
+from .navigation import setup_navigation_tools
+from .notes_measures import setup_notes_measures_tools
+from .staff_instruments import setup_staff_instruments_tools
+from .time_tempo import setup_time_tempo_tools
+from .sequences import setup_sequence_tools
+
+__all__ = [
+    "setup_connection_tools",
+    "setup_navigation_tools", 
+    "setup_notes_measures_tools",
+    "setup_staff_instruments_tools",
+    "setup_time_tempo_tools",
+    "setup_sequence_tools"
+]

src/tools/connection.py

@@ -0,0 +1,23 @@
+"""Connection and utility tools for MuseScore MCP."""
+
+from ..client import MuseScoreClient
+
+
+def setup_connection_tools(mcp, client: MuseScoreClient):
+    """Setup connection and utility tools."""
+    
+    @mcp.tool()
+    async def connect_to_musescore():
+        """Connect to the MuseScore WebSocket API."""
+        result = await client.connect()
+        return {"success": result}
+
+    @mcp.tool()
+    async def ping_musescore():
+        """Ping the MuseScore WebSocket API to check connection."""
+        return await client.send_command("ping")
+
+    @mcp.tool()
+    async def get_score():
+        """Get information about the current score."""
+        return await client.send_command("getScore")

src/tools/navigation.py

@@ -0,0 +1,52 @@
+"""Cursor and navigation tools for MuseScore MCP."""
+
+from ..client import MuseScoreClient
+
+
+def setup_navigation_tools(mcp, client: MuseScoreClient):
+    """Setup cursor and navigation tools."""
+    
+    @mcp.tool()
+    async def get_cursor_info():
+        """Get information about the current cursor position."""
+        return await client.send_command("getCursorInfo")
+
+    @mcp.tool()
+    async def go_to_measure(measure: int):
+        """Navigate to a specific measure."""
+        return await client.send_command("goToMeasure", {"measure": measure})
+
+    @mcp.tool()
+    async def go_to_final_measure():
+        """Navigate to the final measure of the score."""
+        return await client.send_command("goToFinalMeasure")
+
+    @mcp.tool()
+    async def go_to_beginning_of_score():
+        """Navigate to the beginning of the score."""
+        return await client.send_command("goToBeginningOfScore")
+
+    @mcp.tool()
+    async def next_element():
+        """Move cursor to the next element."""
+        return await client.send_command("nextElement")
+
+    @mcp.tool()
+    async def prev_element():
+        """Move cursor to the previous element."""
+        return await client.send_command("prevElement")
+
+    @mcp.tool()
+    async def next_staff():
+        """Move cursor to the next staff."""
+        return await client.send_command("nextStaff")
+
+    @mcp.tool()
+    async def prev_staff():
+        """Move cursor to the previous staff."""
+        return await client.send_command("prevStaff")
+
+    @mcp.tool()
+    async def select_current_measure():
+        """Select the current measure."""
+        return await client.send_command("selectCurrentMeasure")

src/tools/notes_measures.py

@@ -0,0 +1,87 @@
+"""Notes and measures tools for MuseScore MCP."""
+
+from typing import List, Optional
+from ..client import MuseScoreClient
+
+
+def setup_notes_measures_tools(mcp, client: MuseScoreClient):
+    """Setup notes and measures tools."""
+    
+    @mcp.tool()
+    async def add_note(pitch: int = 64, duration: dict = {"numerator": 1, "denominator": 4}, advance_cursor_after_action: bool = True):
+        """Add a note at the current cursor position with the specified pitch and duration.
+        
+        Args:
+            pitch: MIDI pitch value (0-127, where 60 is middle C)
+            duration: Duration as {"numerator": int, "denominator": int} (e.g., {"numerator": 1, "denominator": 4} for quarter note)
+            advance_cursor_after_action: Whether to move cursor to next position after adding note
+        """
+        return await client.send_command("addNote", {
+            "pitch": pitch, 
+            "duration": duration,
+            "advanceCursorAfterAction": advance_cursor_after_action
+        })
+
+    @mcp.tool()
+    async def add_rest(duration: dict = {"numerator": 1, "denominator": 4}, advance_cursor_after_action: bool = True):
+        """Add a rest at the current cursor position.
+        
+        Args:
+            duration: Duration as {"numerator": int, "denominator": int} (e.g., {"numerator": 1, "denominator": 4} for quarter rest)
+            advance_cursor_after_action: Whether to move cursor to next position after adding rest
+        """
+        return await client.send_command("addRest", {
+            "duration": duration,
+            "advanceCursorAfterAction": advance_cursor_after_action
+        })
+
+    @mcp.tool()
+    async def add_tuplet(duration: dict = {"numerator": 1, "denominator": 4}, ratio: dict = {"numerator": 3, "denominator": 2}, advance_cursor_after_action: bool = True):
+        """Add a tuplet at the current cursor position.
+        
+        Args:
+            duration: Base duration as {"numerator": int, "denominator": int}
+            ratio: Tuplet ratio as {"numerator": int, "denominator": int} (e.g., {"numerator": 3, "denominator": 2} for triplet)
+            advance_cursor_after_action: Whether to move cursor to next position after adding tuplet
+        """
+        return await client.send_command("addTuplet", {
+            "duration": duration,
+            "ratio": ratio,
+            "advanceCursorAfterAction": advance_cursor_after_action
+        })
+
+    @mcp.tool()
+    async def add_lyrics(lyrics: List[str], verse: int = 0):
+        """Add lyrics to consecutive notes starting from the current cursor position.
+        
+        Args:
+            lyrics: List of lyric syllables to add (e.g., ["Hel", "lo", "world"])
+            verse: Verse number (0-based, default is 0 for first verse)
+        """
+        return await client.send_command("addLyrics", {
+            "lyrics": lyrics,
+            "verse": verse
+        })
+
+    @mcp.tool()
+    async def insert_measure():
+        """Insert a measure at the current position."""
+        return await client.send_command("insertMeasure")
+
+    @mcp.tool()
+    async def append_measure(count: int = 1):
+        """Append measures to the end of the score."""
+        return await client.send_command("appendMeasure", {"count": count})
+
+    @mcp.tool()
+    async def delete_selection(measure: Optional[int] = None):
+        """Delete the current selection or specified measure."""
+        params = {}
+        if measure is not None:
+            params["measure"] = measure
+        return await client.send_command("deleteSelection", params)
+
+    @mcp.tool()
+    async def undo():
+        """Undo the last action."""
+        return await client.send_command("undo")

src/tools/sequences.py

@@ -0,0 +1,16 @@
+"""Sequence processing tools for MuseScore MCP."""
+
+from ..client import MuseScoreClient
+
+
+def setup_sequence_tools(mcp, client: MuseScoreClient):
+    """Setup sequence processing tools."""
+
+    @mcp.tool()
+    async def processSequence(sequence: list):
+        """Process a sequence of commands.
+
+        Args:
+            sequence: A list of action dictionaries with 'action' and 'params' keys
+        """
+        return await client.send_command("processSequence", {"sequence": sequence})

src/tools/staff_instruments.py

@@ -0,0 +1,44 @@
+"""Staff and instrument tools for MuseScore MCP."""
+
+from ..client import MuseScoreClient
+
+
+def setup_staff_instruments_tools(mcp, client: MuseScoreClient):
+    """Setup staff and instrument tools."""
+    
+    @mcp.tool()
+    async def add_instrument(instrument_id: str):
+        """Add a new staff/instrument to the score.
+        
+        Args:
+            instrument_id: ID of the instrument to add
+        """
+        return await client.send_command("addInstrument", {
+            "instrumentId": instrument_id
+        })
+
+    @mcp.tool()
+    async def set_staff_mute(staff: int, mute: bool):
+        """Mute or unmute a staff.
+        
+        Args:
+            staff: Staff number (0-based)
+            mute: True to mute, False to unmute
+        """
+        return await client.send_command("setStaffMute", {
+            "staff": staff,
+            "mute": mute
+        })
+
+    @mcp.tool()
+    async def set_instrument_sound(staff: int, instrument_id: str):
+        """Change the sound of an instrument on a staff.
+        
+        Args:
+            staff: Staff number (0-based)
+            instrument_id: ID of the new instrument sound
+        """
+        return await client.send_command("setInstrumentSound", {
+            "staff": staff,
+            "instrumentId": instrument_id
+        })

src/tools/time_tempo.py

@@ -0,0 +1,20 @@
+"""Time signature and tempo tools for MuseScore MCP."""
+
+from ..client import MuseScoreClient
+
+
+def setup_time_tempo_tools(mcp, client: MuseScoreClient):
+    """Setup time signature and tempo tools."""
+    
+    @mcp.tool()
+    async def set_time_signature(numerator: int = 4, denominator: int = 4):
+        """Set the time signature.
+        
+        Args:
+            numerator: Top number of time signature (beats per measure)
+            denominator: Bottom number of time signature (note value that gets the beat)
+        """
+        return await client.send_command("setTimeSignature", {
+            "numerator": numerator,
+            "denominator": denominator
+        })

src/types/__init__.py

@@ -0,0 +1,29 @@
+"""Type definitions for MuseScore MCP."""
+
+from .action_types import *
+
+__all__ = [
+    "ActionSequence",
+    "getScoreAction",
+    "addNoteAction", 
+    "addRestAction",
+    "addTupletAction",
+    "addLyricsAction",
+    "addInstrumentAction",
+    "setStaffMuteAction",
+    "setInstrumentSoundAction",
+    "appendMeasureAction",
+    "deleteSelectionAction",
+    "getCursorInfoAction",
+    "goToMeasureAction",
+    "nextElementAction",
+    "prevElementAction",
+    "selectCurrentMeasureAction",
+    "insertMeasureAction",
+    "goToFinalMeasureAction",
+    "goToBeginningOfScoreAction",
+    "setTimeSignatureAction",
+    "undoAction",
+    "nextStaffAction",
+    "prevStaffAction"
+]

src/types/action_types.py

@@ -0,0 +1,12 @@
+"""TypedDict definitions for MuseScore MCP action sequences."""
+
+from typing import Dict, Any, List, TypedDict
+
+
+class ActionSequenceItem(TypedDict):
+    """A single action in a sequence."""
+    action: str
+    params: Dict[str, Any]
+
+
+ActionSequence = List[ActionSequenceItem]