# DAW MIDI Generator MCP 🎵

An MCP (Model Context Protocol) server that enables Claude AI to generate professional MIDI files for **any DAW**.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](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!**