FL Studio MCP

Conecta assistentes de IA ao FL Studio, permitindo que produtores controlem a reprodução, configurações do mixer, plugins e notas do piano roll por meio de comandos em linguagem natural.

GitHub
185
Experimente este MCPPatrocinado

Documentação

Servidor FL Studio MCP

Controle o FL Studio com linguagem natural. Um servidor MCP (Model Context Protocol) que permite que assistentes de IA controlem o FL Studio por meio de comunicação MIDI e scripts do Piano Roll — componha melodias, ajuste mixes e automatize plugins sem tocar no mouse.

Listed on mcpservers.org Listed on awesome-mcp-servers GitHub stars License: MIT Python 3.10+

Sumário

Demonstração

Peça ao Claude para analisar seu projeto e compor uma melodia — as notas aparecem no Piano Roll em tempo real:

Claude composing a dark bell melody in FL Studio via MCP

não ligue para o áudio ruim, tive que gravar com o microfone porque a Apple não me deixou gravar o áudio da área de trabalho lol

https://github.com/user-attachments/assets/d4fc668f-9fe5-4ab4-9f18-76cd661029c6

Ouça o áudio original se quiser

https://github.com/user-attachments/assets/c2b1a5e7-1640-41fa-82bc-18ca7cbae9e8

Recursos

Controle de Transporte

  • Reproduzir, pausar, parar a reprodução
  • Alternar gravação
  • Definir posição de reprodução
  • Obter duração e posição da música
  • Controlar o modo de loop (padrão/música)
  • Ajustar velocidade de reprodução

Controle do Mixer

  • Obter/definir volume e pan de faixas
  • Silenciar/isolado faixas
  • Armar faixas para gravação
  • Definir nomes e cores de faixas
  • Controle de separação estéreo

Controle do Channel Rack

  • Listar todos os canais
  • Obter/definir propriedades do canal (volume, pan, nome, cor)
  • Silenciar/isolado canais
  • Roteamento de canais para faixas do mixer
  • Disparar notas MIDI em tempo real
  • Controle do step sequencer (obter/definir bits da grade)

Controle de Plugins

  • Listar parâmetros de plugins
  • Obter/definir valores de parâmetros
  • Navegar por presets (próximo/anterior)
  • Consultar informações do plugin

Controle do Piano Roll

  • Adicionar notas ao piano roll com tempo preciso
  • Adicionar acordes com um único comando
  • Excluir notas específicas por número MIDI e tempo
  • Limpar todas as notas do piano roll
  • Ler o estado do piano roll para ver todas as notas existentes
  • Disparo automático via atalho de teclado (Cmd+Opt+Y no macOS, Ctrl+Alt+Y no Windows)

Limitações

Não é possível carregar plugins — A API de scripts do FL Studio não suporta carregar novos plugins VST/AU. Você só pode controlar parâmetros de plugins que já estão carregados no seu projeto.

Sem gerenciamento de padrões (ainda) — O servidor pode escrever notas e passos do step sequencer em um padrão, mas não possui ferramentas para criar, alternar, renomear ou clonar padrões. Tudo vai para o padrão atualmente selecionado no FL Studio, então escolha ou crie o padrão você mesmo antes de pedir notas. (A API de scripts do FL Studio suporta isso por meio do módulo patterns, então pode ser adicionado.)

Requisitos

  • FL Studio 20.7+ (API de Scripts de Controle MIDI)
  • Python 3.10+
  • macOS ou Windows
    • macOS: IAC Driver (integrado, precisa ser habilitado)
    • Windows: loopMIDI

Instalação Rápida

macOS / Linux

git clone https://github.com/karl-andres/fl-studio-mcp.git
cd fl-studio-mcp
./install.sh

Windows

git clone https://github.com/karl-andres/fl-studio-mcp.git
cd fl-studio-mcp

# Allow running local scripts for this user (one-time)
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned -Force

.\install.ps1

install.ps1 é o equivalente no Windows ao install.sh — mesmos passos, PowerShell em vez de bash. Ele instala Python 3.12 especificamente (necessário para wheels pré-compilados de python-rtmidi no Windows).

Ambos os instaladores irão:

  1. Instalar uv se não estiver presente
  2. Instalar dependências do Python
  3. Orientar você na habilitação de portas MIDI virtuais (IAC Driver no Mac, loopMIDI no Windows)
  4. Instalar o script de controle MIDI do FL Studio
  5. Instalar o script do Piano Roll (ComposeWithLLM)
  6. Configurar o Claude Desktop ou Claude Code automaticamente (scripts/install_mcp_for_claude.sh / scripts/install_mcp_for_claude.ps1)

Nota sobre piano roll no Windows: O script do Piano Roll é iniciado enviando um atalho de teclado ao FL Studio (Ctrl+Alt+Y). No Windows, isso traz a janela do FL Studio para o primeiro plano brevemente, então o FL Studio vai aparecer na frente por um momento cada vez que uma ferramenta como fl_send_notes for executada. Isso é esperado. Veja Script do Piano Roll não disparando se ele não disparar de forma alguma.

Instalação Manual

1. Instalar Dependências do Python

# Using uv (recommended)
uv sync

# Or using pip
pip install -e .

2. Habilitar Portas MIDI Virtuais

macOS (IAC Driver)

  1. Abra Audio MIDI Setup (pesquise no Spotlight)
  2. Pressione Cmd+2 ou vá em Janela > Mostrar MIDI Studio
  3. Clique duas vezes em IAC Driver
  4. Marque "Device is online"
  5. Clique em Apply

Windows (loopMIDI)

  1. Baixe e instale o loopMIDI
  2. Crie uma porta virtual (qualquer nome serve)
  3. Mantenha o loopMIDI em execução enquanto usa o FL Studio

3. Instalar Scripts do FL Studio

Copie o script de controle para a pasta Hardware do FL Studio:

# macOS
mkdir -p ~/Documents/Image-Line/FL\ Studio/Settings/Hardware/FLStudioMCP
cp fl_controller/device_FLStudioMCP.py ~/Documents/Image-Line/FL\ Studio/Settings/Hardware/FLStudioMCP/

# Windows
mkdir "%USERPROFILE%\Documents\Image-Line\FL Studio\Settings\Hardware\FLStudioMCP"
copy fl_controller\device_FLStudioMCP.py "%USERPROFILE%\Documents\Image-Line\FL Studio\Settings\Hardware\FLStudioMCP\"

Copie o script do Piano Roll:

# macOS
cp scripts/ComposeWithLLM.pyscript ~/Documents/Image-Line/FL\ Studio/Settings/Piano\ roll\ scripts/

# Windows
copy scripts\ComposeWithLLM.pyscript "%USERPROFILE%\Documents\Image-Line\FL Studio\Settings\Piano roll scripts\"

4. Configurar o FL Studio

  1. Reinicie o FL Studio (se estiver em execução)
  2. Vá em Opções > Configurações de MIDI
  3. Em Entrada, encontre sua porta MIDI virtual (ex.: "IAC Driver Bus 1")
  4. Defina o Tipo de controle como FLStudioMCP
  5. Habilite a porta (clique para destacá-la)

5. Configurar Seu Cliente MCP

Adicione à configuração do seu Claude Desktop:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "fl-studio": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/fl-studio-mcp", "fl-studio-mcp"]
    }
  }
}

Para o Claude Code, adicione às suas configurações de MCP (~/.claude.json, ou execute claude mcp add).

Quais Clientes de IA Funcionam com Isso?

Este é um servidor MCP padrão que se comunica com clientes via stdio — ele não é vinculado a nenhum fornecedor de IA específico. Em princípio, qualquer cliente compatível com MCP pode se conectar: Claude Desktop, Claude Code, Cursor, Windsurf, Gemini CLI, Codex CLI/Agents SDK da OpenAI, etc.

O que é realmente testado e configurado automaticamente: apenas Claude Desktop e Claude Code, via scripts/install_mcp_for_claude.sh (macOS/Linux) e scripts/install_mcp_for_claude.ps1 (Windows). Outros clientes não têm suporte de instalador — você precisaria adicionar manualmente a seguinte entrada de servidor MCP à configuração do próprio cliente:

{
  "command": "uv",
  "args": ["run", "--directory", "/path/to/fl-studio-mcp", "fl-studio-mcp"]
}

Substitua /path/to/fl-studio-mcp pelo caminho do seu clone local. Se você tentar isso com um cliente que não seja Claude, abra uma issue informando o que funcionou ou não — o protocolo deve suportar, mas não foi verificado aqui.

Uso

Executando o Servidor Manualmente

# Using uv
uv run fl-studio-mcp

# Or after installation
fl-studio-mcp

Fluxo de Trabalho do Piano Roll

  1. Abra o FL Studio e selecione um canal
  2. Abra o Piano Roll (F7 ou clique duas vezes no canal)
  3. Na primeira vez, execute o script manualmente: Ferramentas > Scripts > ComposeWithLLM
  4. Depois disso, as ferramentas MCP dispararão o script automaticamente

Ferramentas Disponíveis

Conexão

FerramentaDescrição
fl_connectConectar/reconectar ao FL Studio
fl_connection_statusObter status da conexão

Transporte

FerramentaDescrição
fl_playIniciar/pausar reprodução
fl_stopParar reprodução
fl_recordAlternar gravação
fl_get_transport_statusObter estado de reprodução/gravação
fl_set_song_positionDefinir posição de reprodução
fl_get_song_lengthObter duração da música
fl_set_loop_modeAlternar entre modo padrão/música
fl_set_playback_speedAjustar velocidade de reprodução (0,25x–4x)

Mixer

FerramentaDescrição
fl_get_mixer_track_countObter número de faixas do mixer
fl_get_mixer_track_infoObter detalhes da faixa
fl_get_all_mixer_tracksListar todas as faixas
fl_set_track_volumeDefinir volume da faixa
fl_set_track_panDefinir pan da faixa
fl_mute_trackSilenciar/reativar faixa
fl_solo_trackIsolar/desisolar faixa
fl_arm_trackArmar faixa para gravação
fl_set_track_nameRenomear faixa
fl_set_track_colorDefinir cor da faixa
fl_set_stereo_separationAjustar largura estéreo

Canais

FerramentaDescrição
fl_get_channel_countObter número de canais
fl_get_channel_infoObter detalhes do canal
fl_get_all_channelsListar todos os canais
fl_get_selected_channelObter canal selecionado
fl_select_channelSelecionar/desselecionar canal
fl_select_one_channelSelecionar canal exclusivamente
fl_trigger_noteDisparar nota MIDI (tempo real)
fl_set_channel_volumeDefinir volume do canal
fl_set_channel_panDefinir pan do canal
fl_mute_channelSilenciar/reativar canal
fl_solo_channelIsolar/desisolar canal
fl_set_channel_nameRenomear canal
fl_set_channel_colorDefinir cor do canal
fl_route_channel_to_mixerRoteamento para faixa do mixer
fl_get_grid_bitObter passo do step sequencer
fl_set_grid_bitDefinir passo do step sequencer
fl_get_step_sequenceObter padrão completo
fl_set_step_sequenceDefinir padrão completo

Plugins

FerramentaDescrição
fl_is_plugin_validVerificar se o plugin existe
fl_get_plugin_nameObter nome do plugin
fl_get_plugin_param_countObter número de parâmetros
fl_get_plugin_paramsListar todos os parâmetros
fl_get_plugin_param_valueObter valor do parâmetro
fl_set_plugin_param_valueDefinir valor do parâmetro
fl_get_preset_countObter número de presets
fl_next_presetPróximo preset
fl_prev_presetPreset anterior
fl_get_plugin_colorObter cor do plugin

Piano Roll

FerramentaDescrição
fl_send_notesAdicionar notas ao piano roll
fl_send_chordAdicionar um acorde (várias notas ao mesmo tempo)
fl_delete_notesExcluir notas específicas
fl_clear_piano_rollLimpar todas as notas
fl_get_piano_roll_stateLer notas atuais do piano roll
fl_trigger_scriptDisparar manualmente o script do FL Studio
fl_get_piano_roll_infoObter informações do sistema do piano roll
fl_clear_request_queueCancelar alterações pendentes na fila

Exemplos de Fluxos de Trabalho

Ajustando um Mix

"Set the volume of mixer track 1 to 80% and pan it slightly left"

Criando um Padrão de Bateria

"Create a basic kick pattern on channel 0 with kicks on steps 0, 4, 8, and 12"

Adicionando uma Melodia ao Piano Roll

"Add a C major arpeggio starting at beat 0: C4, E4, G4, C5 - each note quarter duration"

Adicionando Acordes

"Add a C major chord at beat 0, then F major at beat 2, then G major at beat 4"

Automatizando Parâmetros de Plugins

"List the parameters of the plugin on channel 0 and set the filter cutoff to 50%"

Solução de Problemas

"Não conectado ao FL Studio"

  1. Certifique-se de que o FL Studio está em execução
  2. Verifique se o controle FLStudioMCP está habilitado nas Configurações de MIDI
  3. No Mac, verifique se o IAC Driver está habilitado no Audio MIDI Setup
  4. No Windows, verifique se o loopMIDI está em execução
  5. Reinicie o FL Studio após habilitar o controle

"Tempo esgotado aguardando resposta do FL Studio"

  1. Certifique-se de que o FL Studio está em foco
  2. Verifique a janela de saída de Scripts no FL Studio (Exibir > Saída de scripts)
  3. Verifique se o controle está recebendo MIDI (procure atividade nas Configurações de MIDI)

Script do Piano Roll não disparando

  1. Na primeira vez: execute manualmente Ferramentas > Scripts > ComposeWithLLM no FL Studio
  2. No macOS: conceda permissões de Acessibilidade quando solicitado
  3. No Windows: o servidor MCP traz a janela do FL Studio para o primeiro plano automaticamente antes de enviar o atalho — se o FL Studio não estiver em execução ou estiver minimizado na bandeja do sistema, o disparo não consegue encontrá-lo e cairá em um aviso dizendo para você pressionar o atalho manualmente
  4. Tente pressionar Cmd+Opt+Y (macOS) ou Ctrl+Alt+Y (Windows) manualmente para confirmar que o atalho está vinculado ao script no FL Studio
  5. Se você acabou de atualizar o código do servidor (ex.: baixou uma correção), reinicie completamente seu cliente MCP (Claude Desktop/Code) — apenas reconectar o servidor MCP não reinicia o processo subjacente

Nenhuma porta MIDI disponível

  • macOS: Habilite o IAC Driver no Audio MIDI Setup
  • Windows: Instale e execute o loopMIDI

Arquitetura

Este servidor MCP usa uma abordagem híbrida:

┌─────────────────┐     ┌─────────────────────────────────────────┐
│   MCP Client    │────▶│           FastMCP Server                │
│  (Claude, etc)  │     │                                         │
└─────────────────┘     │  ┌─────────────────┐  ┌──────────────┐  │
                        │  │ MIDI + JSON     │  │ Piano Roll   │  │
                        │  │ Tools           │  │ Tools (JSON) │  │
                        │  └────────┬────────┘  └──────┬───────┘  │
                        └───────────┼──────────────────┼──────────┘
                                    │                  │
                               MIDI + JSON        JSON Files +
                                    │              Keystroke
                                    ▼                  ▼
                        ┌─────────────────────────────────────────┐
                        │              FL Studio                   │
                        │  ┌──────────────┐  ┌──────────────────┐ │
                        │  │FLStudioMCP   │  │ Piano Roll Script│ │
                        │  │(MIDI Ctrl)   │  │ (ComposeWithLLM) │ │
                        │  └──────────────┘  └──────────────────┘ │
                        └─────────────────────────────────────────┘

Como Funciona

Transporte / Mixer / Canais / Plugins:

  1. O servidor MCP escreve o comando em um arquivo JSON
  2. Envia nota de disparo MIDI para o FL Studio
  3. O script de controle do FL Studio lê o JSON, executa a API, escreve a resposta
  4. O servidor MCP lê a resposta

Piano Roll:

  1. O servidor MCP escreve solicitações de notas em um arquivo JSON
  2. Envia atalho de teclado (Cmd+Opt+Y no macOS, Ctrl+Alt+Y no Windows) para disparar o script do FL Studio — no Windows, a janela do FL Studio é trazida para o primeiro plano primeiro para que o atalho realmente chegue até ela
  3. O script do Piano Roll lê o JSON e modifica as notas

Desenvolvimento

Pré-requisitos

  • Python 3.10+
  • uv (recomendado)

Configuração

# Install all dependencies including dev extras
uv sync --dev

# Or with pip
pip install -e ".[dev]"

Comandos Disponíveis

ComandoDescrição
uv run fl-studio-mcpExecutar o servidor MCP
uv run ruff check .Verificar o código-fonte (lint)
uv run ruff check --fix .Verificar e corrigir automaticamente
uv run pytestExecutar testes

Estrutura do Projeto

fl-studio-mcp/
├── fl_controller/
│   └── device_FLStudioMCP.py     # FL Studio MIDI controller script (runs inside FL Studio)
├── scripts/
│   ├── setup.sh                  # FL Studio script installer
│   ├── install_mcp_for_claude.sh # Claude config installer (macOS/Linux)
│   ├── install_mcp_for_claude.ps1# Claude config installer (Windows)
│   └── ComposeWithLLM.pyscript   # Piano Roll script (runs inside FL Studio)
├── src/fl_studio_mcp/
│   ├── server.py                 # FastMCP server entry point
│   ├── tools/                    # MCP tool implementations
│   │   ├── channels.py
│   │   ├── mixer.py
│   │   ├── piano_roll.py
│   │   ├── plugins.py
│   │   └── transport.py
│   └── utils/
│       ├── connection.py         # FL Studio connection wrapper
│       ├── fl_trigger.py         # Piano roll keystroke trigger
│       └── midi_connection.py    # MIDI + JSON communication layer
├── install.sh                    # One-command installer (macOS/Linux)
└── install.ps1                   # One-command installer (Windows)

Créditos

Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para abrir uma issue ou um pull request.

Apenas um aviso: este projeto ainda não possui uma suíte de testes adequada, CI ou processo de revisão para PRs. Sou um estudante mantendo isso no meu tempo livre, então as mudanças são testadas principalmente manualmente no FL Studio. Se você quiser ajudar a configurar testes ou um fluxo de contribuição mais suave, essa ajuda é especialmente bem-vinda.

Licença

MIT