DAW MIDI Generator MCP 🎵

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

🎹 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)
Any DAW that supports MIDI import

🚀 Installation

Step 1: Clone the Repository

git clone https://github.com/s2d01/daw-midi-generator-mcp.git
cd daw-midi-generator-mcp

Step 2: Install Python Dependencies

pip3 install -r requirements.txt

This installs:

mcp - Model Context Protocol library
mido - MIDI file generation library

Step 3: Get the Absolute Path

pwd

Copy the output (e.g., /Users/yourname/daw-midi-generator-mcp)

Step 4: Configure Claude Desktop

Open Claude Desktop's configuration file:

macOS:

nano ~/Library/Application\ Support/Claude/claude_desktop_config.json

Linux:

nano ~/.config/Claude/claude_desktop_config.json

Add this configuration (replace YOUR_USERNAME with your actual username):

{
  "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:

{
  "method": "tools/call",
  "params": {
    "name": "generate_drum_pattern",
    "arguments": {
      "pattern_type": "house",
      "tempo": 128,
      "bars": 4
    }
  }
}

3. The Python server executes:

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

File → Import → MIDI File
Navigate to ~/Music/DAW/Claude_MIDI/
Select one or more MIDI files
Click Open

Or drag & drop files directly into the timeline.

Ableton Live

Drag MIDI files from Finder into Session or Arrangement View
Ableton automatically creates a new track
Assign an instrument

FL Studio

File → Import → MIDI file
Navigate to ~/Music/DAW/Claude_MIDI/
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:

# 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:

pip3 install --upgrade mcp mido

Claude Doesn't See the Server

Problem: Claude says "I don't have access to that tool"

Solutions:

Check the config path is absolute:

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/... ❌

Check the logs:

tail -f ~/Library/Logs/Claude/mcp*.log

Look for:

[daw-midi] [info] Server started and connected successfully

Completely restart Claude Desktop:

Cmd+Q (not just close window)
Wait 5 seconds
Reopen

Test the Server Manually

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:

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:

# Line ~25
MIDI_OUTPUT_DIR = Path.home() / "Music" / "YOUR_FOLDER" / "MIDI"

Add New Drum Patterns

Edit the patterns dict in create_drum_pattern_midi():

patterns = {
    "house": [...],
    "techno": [...],
    "trap": [...],
    "your_style": [...]  # Add here
}

Add New Scales

Edit the scales dict in create_melody_midi():

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

Create a new generator function
Register it in @app.list_tools()
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.

Fork the repository
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
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 file for details.

👤 Author

S2D01

GitHub: @s2d01
Website: s2d01.github.io

🙏 Acknowledgments

Built with Anthropic's Claude and Model Context Protocol
MIDI handling powered by mido
Inspired by the need for AI-assisted music production

⭐ Support

If you find this project useful:

⭐ Star this repository
🐛 Report bugs in Issues
💡 Suggest features in Issues
🔧 Contribute code via Pull Requests

🎵 Happy music making!

DAW MIDI Generator MCP