# DAW MIDI Generator MCP 🎵
An MCP (Model Context Protocol) server that enables Claude AI to generate professional MIDI files for **any DAW**.
[](https://opensource.org/licenses/MIT)
[](https://www.python.org/downloads/)
---
## 🎹 What It Does
This MCP server gives Claude the ability to generate complete, production-ready MIDI files:
- **Chord Progressions** - Any key, any progression (I-V-vi-IV, ii-V-I, custom)
- **Drum Patterns** - House, Techno, Trap with precise General MIDI mapping
- **Bass Lines** - Steady, Syncopated, Walking patterns
- **Melodies** - Major, Minor, Pentatonic scales
- **Full Arrangements** - Chords + Drums + Bass in one command
All files are **standard MIDI 1.0** compatible with every DAW.
---
## ✅ Compatible DAWs
- Logic Pro X
- Ableton Live
- FL Studio
- Cubase
- Pro Tools
- Reaper
- Bitwig Studio
- Studio One
- GarageBand
- **Any MIDI-compatible software**
---
## 📋 Requirements
- **macOS** (tested on Sequoia 15.7.2+) or **Linux**
- **Python 3.10+**
- **Claude Desktop** ([download here](https://claude.ai/download))
- Any DAW that supports MIDI import
---
## 🚀 Installation
### Step 1: Clone the Repository
```bash
git clone https://github.com/s2d01/daw-midi-generator-mcp.git
cd daw-midi-generator-mcp
```
### Step 2: Install Python Dependencies
```bash
pip3 install -r requirements.txt
```
This installs:
- `mcp` - Model Context Protocol library
- `mido` - MIDI file generation library
### Step 3: Get the Absolute Path
```bash
pwd
```
Copy the output (e.g., `/Users/yourname/daw-midi-generator-mcp`)
### Step 4: Configure Claude Desktop
Open Claude Desktop's configuration file:
**macOS:**
```bash
nano ~/Library/Application\ Support/Claude/claude_desktop_config.json
```
**Linux:**
```bash
nano ~/.config/Claude/claude_desktop_config.json
```
Add this configuration (replace `YOUR_USERNAME` with your actual username):
```json
{
"mcpServers": {
"daw-midi": {
"command": "python3",
"args": ["/Users/YOUR_USERNAME/daw-midi-generator-mcp/midi_generator_server.py"]
}
}
}
```
**⚠️ CRITICAL:** Use the **absolute path** from Step 3. Relative paths don't work.
Save the file:
- In nano: `Ctrl+O`, `Enter`, `Ctrl+X`
### Step 5: Restart Claude Desktop
**Completely quit** Claude Desktop:
- macOS: `Cmd+Q`
- Linux: Close the application
Wait 3 seconds, then reopen Claude Desktop.
### Step 6: Verify Installation
Open Claude Desktop and type:
```
Create a chord progression in C major
```
Claude should generate a MIDI file and show you the path.
---
## 📂 Project Structure
```
daw-midi-generator-mcp/
├── README.md # This file
├── midi_generator_server.py # MCP server (runs automatically)
├── requirements.txt # Python dependencies
├── LICENSE # MIT License
└── .gitignore # Git ignore rules
```
### Output Directory
**MIDI files are saved to:**
```
~/Music/DAW/Claude_MIDI/
```
This directory is **created automatically** the first time the server runs. You don't need to create it manually.
---
## 🎼 How It Works
### The Architecture
```
┌─────────────────┐
│ You ask │
│ Claude │
└────────┬────────┘
│
▼
┌─────────────────────────┐
│ Claude Desktop │
│ (MCP Client) │
└────────┬────────────────┘
│ JSON-RPC over stdio
▼
┌─────────────────────────────┐
│ midi_generator_server.py │
│ (MCP Server - Python) │
│ │
│ • Receives tool calls │
│ • Generates MIDI events │
│ • Creates .mid files │
└────────┬────────────────────┘
│
▼
┌─────────────────────────┐
│ ~/Music/DAW/ │
│ Claude_MIDI/ │
│ • chords_*.mid │
│ • drums_*.mid │
│ • bass_*.mid │
└─────────────────────────┘
```
### Step-by-Step Example
**1. You ask Claude:**
```
Generate a house drum pattern at 128 BPM
```
**2. Claude calls the MCP server:**
```json
{
"method": "tools/call",
"params": {
"name": "generate_drum_pattern",
"arguments": {
"pattern_type": "house",
"tempo": 128,
"bars": 4
}
}
}
```
**3. The Python server executes:**
```python
def create_drum_pattern_midi(pattern_type="house", tempo=128, bars=4):
# Create MIDI file
mid = MidiFile()
track = MidiTrack()
# Add tempo and time signature
track.append(MetaMessage('set_tempo', tempo=...))
# Generate drum events
# Kick (MIDI 36) on beats 1, 2, 3, 4
# Snare (MIDI 38) on beats 2, 4
# Hi-hat (MIDI 42) on eighth notes
# Save to ~/Music/DAW/Claude_MIDI/drums_house_20241130_154523.mid
return filepath
```
**4. Claude responds:**
```
🥁 Drum pattern created!
📁 File: /Users/yourname/Music/DAW/Claude_MIDI/drums_house_20241130_154523.mid
🎶 Style: house
⏱️ Tempo: 128 BPM
📏 Bars: 4
💡 Import into your DAW and assign to a drum kit!
```
**5. You import the file into your DAW**
### When Does the Server Run?
The server runs **automatically in the background**:
- **Starts:** When you open Claude Desktop
- **Runs:** While Claude Desktop is open
- **Stops:** When you quit Claude Desktop
You **never run it manually**. Claude Desktop handles everything.
### The Five Tools
The server exposes 5 tools to Claude:
| Tool Name | What It Does | Parameters |
|-----------|--------------|------------|
| `generate_chord_progression` | Creates chord MIDI files | key, progression, tempo, bars |
| `generate_drum_pattern` | Creates drum patterns | pattern_type (house/techno/trap), tempo, bars |
| `generate_bass_line` | Creates bass lines | key, pattern (steady/syncopated/walking), tempo, bars |
| `generate_melody` | Creates melodies | scale (major/minor/pentatonic), key, tempo, bars |
| `create_full_arrangement` | Creates all 3 above | key, genre, tempo, bars |
---
## 💬 Usage Examples
### Chord Progressions
```
Create a chord progression in D minor
Generate a I-V-vi-IV progression in G major at 140 BPM
Make me 8 bars of C - F - Am - G chords
Create a jazz progression in Bb major
```
**Output:** Single MIDI file with chord voicings
### Drum Patterns
```
Generate a house pattern at 128 BPM
Create 16 bars of techno drums at 135 BPM
Make me a trap beat
Generate a 4-bar house groove
```
**Styles:**
- **house** - Four-on-floor kick, snare on 2-4, hi-hats on eighths
- **techno** - Driving kick pattern, tight hi-hats, occasional open hats
- **trap** - Syncopated kicks, 16th note hi-hats, hard snares
### Bass Lines
```
Create a steady bass in A minor
Generate a syncopated bass in C at 125 BPM
Make me 8 bars of walking bass in F
Create a bass line in E minor
```
**Patterns:**
- **steady** - Root notes on every beat (4/4 time)
- **syncopated** - Off-beat grooves with rests
- **walking** - Jazz-style ascending/descending patterns
### Melodies
```
Generate a pentatonic melody in A minor
Create a melody in C major scale
Make me a lead line in E minor
Generate an 8-bar melody
```
**Scales:**
- **major** - Happy, bright melodies
- **minor** - Sad, dark melodies
- **pentatonic** - Simple, catchy melodies (great for leads)
### Full Arrangements
```
Create a complete house arrangement in C major at 128 BPM
Generate a techno base in A minor at 135 BPM
Make me 16 bars of trap in G major at 140 BPM
Create a full track arrangement
```
**Output:** 3 MIDI files (chords + drums + bass)
---
## 📥 Importing into Your DAW
### Logic Pro X / GarageBand
1. **File → Import → MIDI File**
2. Navigate to `~/Music/DAW/Claude_MIDI/`
3. Select one or more MIDI files
4. Click **Open**
Or **drag & drop** files directly into the timeline.
### Ableton Live
1. Drag MIDI files from Finder into Session or Arrangement View
2. Ableton automatically creates a new track
3. Assign an instrument
### FL Studio
1. **File → Import → MIDI file**
2. Navigate to `~/Music/DAW/Claude_MIDI/`
3. Select file and import
### Cubase / Pro Tools / Reaper / Bitwig
Drag & drop MIDI files into the timeline.
---
## 🔧 Technical Details
### MIDI Specification
- **Format:** MIDI 1.0 standard
- **Timing:** 480 PPQ (pulses per quarter note)
- **Drums:** General MIDI Channel 10 mapping
- Kick: MIDI 36
- Snare: MIDI 38
- Closed Hi-hat: MIDI 42
- Open Hi-hat: MIDI 46
- **Velocity:** Dynamic (50-100)
- **Time Signature:** 4/4 (currently)
### Python Architecture
**Main Components:**
```python
# MIDI Utilities
note_to_midi() # Convert "C4" → MIDI 60
get_chord_notes() # Generate chord voicings
# MIDI Generators
create_chord_progression_midi() # Chords
create_drum_pattern_midi() # Drums
create_bass_line_midi() # Bass
create_melody_midi() # Melodies
# MCP Protocol Handlers
@app.list_tools() # Exposes tools to Claude
@app.call_tool() # Executes tool calls
```
**Key Libraries:**
- `mido` - MIDI file creation and manipulation
- `mcp` - Model Context Protocol server implementation
- `asyncio` - Asynchronous I/O for MCP communication
---
## 🐛 Troubleshooting
### Server Won't Start
**Error:** `ModuleNotFoundError: No module named 'mcp'`
**Solution:**
```bash
pip3 install --upgrade mcp mido
```
### Claude Doesn't See the Server
**Problem:** Claude says "I don't have access to that tool"
**Solutions:**
1. **Check the config path is absolute:**
```bash
cat ~/Library/Application\ Support/Claude/claude_desktop_config.json
```
Should show: `/Users/yourname/daw-midi-generator-mcp/midi_generator_server.py`
Not: `~/daw-midi-generator-mcp/...` ❌
2. **Check the logs:**
```bash
tail -f ~/Library/Logs/Claude/mcp*.log
```
Look for:
```
[daw-midi] [info] Server started and connected successfully
```
3. **Completely restart Claude Desktop:**
- `Cmd+Q` (not just close window)
- Wait 5 seconds
- Reopen
### Test the Server Manually
```bash
cd ~/daw-midi-generator-mcp
python3 midi_generator_server.py
```
Should output:
```
🎵 DAW MIDI Generator - MCP Server started!
📁 MIDI files will be saved to: /Users/yourname/Music/DAW/Claude_MIDI
```
Press `Ctrl+C` to stop.
### MIDI Files Are Empty or Don't Play
**Check:**
- ✅ Assigned an instrument to the track
- ✅ Track volume is not zero
- ✅ Track is not muted
- ✅ Using the correct MIDI channel (drums = channel 10)
### Output Directory Not Created
The directory `~/Music/DAW/Claude_MIDI/` is created automatically by this line:
```python
MIDI_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
```
If it doesn't exist:
- The server hasn't run yet
- Check file permissions on `~/Music/`
---
## 🛠️ Customization
### Change Output Directory
Edit `midi_generator_server.py`:
```python
# Line ~25
MIDI_OUTPUT_DIR = Path.home() / "Music" / "YOUR_FOLDER" / "MIDI"
```
### Add New Drum Patterns
Edit the `patterns` dict in `create_drum_pattern_midi()`:
```python
patterns = {
"house": [...],
"techno": [...],
"trap": [...],
"your_style": [...] # Add here
}
```
### Add New Scales
Edit the `scales` dict in `create_melody_midi()`:
```python
scales = {
"major": [0, 2, 4, 5, 7, 9, 11, 12],
"minor": [0, 2, 3, 5, 7, 8, 10, 12],
"pentatonic": [0, 2, 4, 7, 9, 12],
"blues": [0, 3, 5, 6, 7, 10, 12], # Add here
}
```
### Add New Tools
1. Create a new generator function
2. Register it in `@app.list_tools()`
3. Handle it in `@app.call_tool()`
**After any changes:** Restart Claude Desktop
---
## 🗺️ Roadmap
- [ ] Support for alternate time signatures (3/4, 6/8, 7/8)
- [ ] More drum patterns (breakbeat, dnb, funk)
- [ ] Advanced chord voicings (9th, 11th, 13th)
- [ ] Arpeggiators
- [ ] Swing/groove quantization
- [ ] MusicXML export
- [ ] Integration with AI music generation models
---
## 🤝 Contributing
Pull requests are welcome! For major changes, please open an issue first.
1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request
**Ideas for contributions:**
- More drum patterns
- Additional scales and modes
- Chord voicing variations
- Time signature support
- Humanization/randomization
- MIDI effects (swing, velocity curves)
---
## 📄 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
---
## 👤 Author
**S2D01**
- GitHub: [@s2d01](https://github.com/s2d01)
- Website: [s2d01.github.io](https://s2d01.github.io/s2d01-docs-z9n4x1c/)
---
## 🙏 Acknowledgments
- Built with [Anthropic's Claude](https://claude.ai) and Model Context Protocol
- MIDI handling powered by [mido](https://mido.readthedocs.io/)
- Inspired by the need for AI-assisted music production
---
## ⭐ Support
If you find this project useful:
- ⭐ **Star this repository**
- 🐛 **Report bugs** in [Issues](https://github.com/s2d01/daw-midi-generator-mcp/issues)
- 💡 **Suggest features** in [Issues](https://github.com/s2d01/daw-midi-generator-mcp/issues)
- 🔧 **Contribute code** via Pull Requests
---
🎵 **Happy music making!**
