# rosasynthesiz/flstudio-mcp [Health: Active]

**Category:** 🎥 Multimedia Process  
**Repository:** https://github.com/rosasynthesiz/flstudio-mcp  
**GitHub Stars:** 150  
**Views:** 12  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/rosasynthesiz-flstudio-mcp

## Description
Control FL Studio with AI: in-DAW mixing (Mix Doctor, gain staging, EQ/comp/reverb, reference matching), routing, and composition. 67 tools.

## Tools
Capabilities this server exposes over MCP:

- **fl_ping** — Check that FL Studio is running and the controller script is loaded.

Returns the controller's reported FL Studio version, the age of the
last heartbeat in seconds, and the MIDI port names in use. Call this
first when something seems wrong.
- **fl_get_tempo** — Return the current FL Studio project tempo in beats per minute.
- **fl_set_tempo** — Set the FL Studio project tempo. Range is 10-999 BPM (FL's own limits).
- **fl_play** — Start playback. Idempotent — calling while already playing is a no-op.
- **fl_stop** — Stop playback. Idempotent.
- **fl_toggle_play** — Toggle between play and stop, mirroring the spacebar in FL.
- **fl_record** — Toggle FL Studio's record-arm state.
- **fl_get_play_state** — Return whether FL is currently playing and / or recording.
- **fl_get_song_position** — Return the current playhead position in beats from the song start.
- **fl_set_song_position** — Move the playhead to the given beat position.
- **fl_get_project_state** — Tempo, transport state, pattern/channel/mixer counts.
- **fl_get_mixer_state** — All mixer tracks (index, name, volume, pan, mute, solo). Names in
this overview are truncated; use a single-track read for the full name.
- **fl_get_channel_state** — All channel-rack channels (index, name, volume, pan, mute, solo).
- **fl_set_mixer_volume** — Set a mixer track volume. unit='db' uses 0.8=unity (0 dB).
- **fl_set_mixer_pan** — Set a mixer track's pan position (-1 left .. +1 right).
- **fl_set_mixer_mute** — Mute or unmute a mixer track (state=True mutes).
- **fl_set_mixer_solo** — Solo or unsolo a mixer track (state=True solos).
- **fl_set_mixer_name** — Rename a mixer track.
- **fl_set_channel_volume** — Set a channel-rack channel's volume. unit='db' uses 0.8=unity (0 dB).
- **fl_set_channel_pan** — Set a channel-rack channel's pan position (-1 left .. +1 right).
- **fl_set_channel_mute** — Mute or unmute a channel-rack channel (state=True mutes).
- **fl_set_channel_solo** — Solo or unsolo a channel-rack channel (state=True solos).
- **fl_take_snapshot** — Read current state for a scope (for your own before/after diffing).
- **fl_rollback_last_change** — Undo the most recent write by replaying its pre-change snapshot.
- **fl_set_dry_run** — When on, write tools return a 'planned' preview without changing FL.
- **fl_write_piano_roll_notes** — Write notes into the currently-open FL Piano roll.

Each note: {pitch (MIDI), time_bars, length_bars, velocity 0-1}. Set
quantize (grid in bars) to snap note starts to a grid before writing.
Setup: open the Piano roll and run 'MCP_Apply' once from its Scripting
menu (so Ctrl+Alt+Y targets it). mode='replace' clears first.
- **fl_quantize_pattern** — Quantize the notes ALREADY in the open Piano roll: reads the score,
snaps note starts (and optionally lengths) to the grid, rewrites -- via
the pyscript bridge, no dialog. Needs the Piano roll open + MCP_Apply
armed once this session (same setup as note writing).
- **fl_plugin_list** — List the filled effect slots (0-9) on a mixer track, with plugin names.

We cannot load NEW plugins (FL API limit) -- this only reports plugins
already present in the project.
- **fl_plugin_get_params** — Every named parameter of the plugin in this slot: index, name,
normalised value (0..1) and FL's display string (e.g. '3.6dB',
'500Hz'). Returns {"total", "params":[{"i","name","v","s"}, ...]}.
- **fl_plugin_set_param** — Set one plugin parameter (normalised 0..1). ``param`` may be an
index or a name; names are resolved from the live param list. The
change is logged and undo-able via fl_rollback_last_change. Returns
before/after plus the resolved {index, name}.
- **fl_apply_eq_intent** — Apply a musical EQ move on a Fruity Parametric EQ 2 using a free band.
Sets type/freq/gain/width as one undo-able group; returns the band used
and FL's readback strings. Revert with fl_rollback_last_change.
- **fl_apply_reverb_intent** — Musical reverb moves on a Fruity Reeverb 2 (decay/wet/high-cut), as one
undo-able group. Returns readback strings. Revert: fl_rollback_last_change.
- **fl_apply_delay_intent** — Musical delay moves on a Fruity Delay (time division / feedback / wet /
feedback-cut), as one undo-able group. Feedback is clamped <=100% unless
intensity>0.9 (warns on self-oscillation risk). Returns readback strings.
- **fl_get_track_level** — Measure a mixer track's level by sampling meter peaks over a short
window. Requires PLAYBACK -- returns playing=False (avg/peak null) when
stopped/silent. {track, playing, avg_db, peak_db}.
- **fl_apply_compression_intent** — Compress via Fruity Limiter (COMP section) or FabFilter Pro-C. ALWAYS
sets ratio AND threshold together; ratio/attack/release/makeup (+ Pro-C
Style) per intent, as ONE rollback unit. When level_aware and the track
is playing, threshold is set relative to the MEASURED peak (a smart
starting point, not exact gain-reduction); stopped -> preset fallback +
a note. Returns readback + the measured level / chosen threshold.
- **fl_get_routing** — Which destination tracks this mixer track sends to:
{track, name, routes_to:[{dst, dst_name, level?}]}.
- **fl_get_routing_all** — Routing for every mixer track (paginated under the hood, returned
whole): {total, routing:[{i, name, routes_to:[...]}]}.
- **fl_get_channel_routing** — Which mixer track each channel-rack channel is linked to:
{total, channels:[{channel, name, target_mixer_track, target_name}]}.
- **fl_detect_cleanup_candidates** — Flag (do NOT touch) empty channels + unused mixer tracks, each with a
reason. Judgement is computed server-side from cheap controller reads.
Channel emptiness is a name heuristic; unused-track detection is reliable.
- **fl_set_route** — Enable/disable a send from src -> dst (calls afterRoutingChanged on the
FL side). Snapshot + readback; undo with fl_rollback_last_change.
- **fl_group_tracks** — Group sources into a bus, EXCLUSIVELY: each source -> bus ON and its
direct -> Master OFF; bus -> Master ON; optional bus rename. Applied as
ONE rollback unit -- fl_rollback_last_change undoes the whole grouping.
- **fl_solo_tracks** — Isolate a group so only it is audible -- mutes every OTHER (non-Master)
track. Use category ('drums', etc.) or explicit tracks. Implemented as
mute-the-rest (reliable; FL's multi-solo is inconsistent). Reverse with
fl_clear_mute_solo. One rollback unit.
- **fl_mute_tracks** — Mute a group of tracks (leaves the others as they are). Use category or
explicit tracks. One rollback unit; reverse with fl_clear_mute_solo.
- **fl_clear_mute_solo** — Unmute and unsolo every mixer track (reset). The universal undo for the
bulk solo/mute tools.
- **fl_set_track_color** — Set the color of mixer tracks. Pick targets by category ('drums',
'bass', ...) or an explicit tracks list; choose a color by name or hex.
All writes are ONE rollback unit -- fl_rollback_last_change reverts them.
(Master is never colored.)
- **fl_set_channel_color** — Set the color of channel-rack channels (separate from mixer-track
color). Target by index or name substring. ONE rollback unit --
fl_rollback_last_change reverts it.
- **fl_arrange_new_pattern** — Create + select + name the next empty pattern. After this, the note
bridge (fl_write_piano_roll_notes) writes INTO this pattern.
- **fl_arrange_select_channel** — Make a channel the active selection so the note bridge
(fl_write_piano_roll_notes) writes INTO it. Use before writing each
instrument's notes in a section (drums -> ch X, bass -> ch Y, ...).
- **fl_arrange_clone_pattern** — Clone a pattern (copies its notes) and rename the clone -- e.g. for
verse -> verse2 variations.
- **fl_arrange_add_marker** — Add a named timeline marker at a bar (intro/verse/chorus/drop).
- **fl_analyze_audio** — Estimate tempo + key (+ duration, beats, onsets) of an audio file.
Pure offline analysis -- does NOT touch FL. Key is ESTIMATED.
- **fl_extract_melody** — Transcribe a monophonic melody to quantized notes; engine-selectable
(CREPE = accurate/heavy, pyin = light). Returns ALL notes with confidence
+ a `kept` flag; bridge_notes holds only the confident notes, ready for
fl_write_piano_roll_notes. Does NOT write to FL -- review first.
- **fl_write_raga_melody** — Write a MELODY (single-line, sequential notes) into the selected channel
via the piano-roll bridge. YOU (Claude) generate the swaras for the named
raga/root -> MIDI notes (use the proper aarohana/avarohana; respect the
raga's allowed swaras); this tool only selects the channel + writes. SHOW
the user the notes/swaras BEFORE calling. Needs the Piano roll open +
MCP_Apply armed once this session (see the note-bridge setup).
- **fl_write_raga_chords** — Write CHORDS / a progression (stacked notes sharing start times) into
the selected channel via the bridge. YOU stack chord tones drawn from the
raga/scale (give simultaneous notes the SAME time_bars). Tool selects the
channel + writes. SHOW the user the chords BEFORE calling.
- **fl_list_chains** — List the built-in genre processing-chain recipes (vocal, drum_bus,
bass, master) and their ordered steps.
- **fl_list_installed_plugins** — Read FL's installed-plugin DATABASE from disk (the .fst shortcuts FL
writes for every scanned plugin) -> a de-duped, categorized list of what
you OWN. Bypasses the FL API (which only sees LOADED plugins). FL still
can't LOAD these -- it's for library-aware suggestions. effects_by_role is
a rough keyword grouping (Claude should apply its own plugin knowledge).
Read-only (directory listing only).
- **fl_setup_chain** — Plan a genre-appropriate processing chain over a track's EXISTING
plugins. READ-ONLY plan: returns the ordered intent calls (each with the
matched plugin + slot) and which steps are MISSING because the needed
plugin isn't loaded (FL can't load plugins -- add those manually). After
the user approves, apply each step by calling its 'apply' tool+args
(fl_apply_eq_intent / fl_apply_compression_intent / fl_apply_reverb_intent
-- each logged + rollback-able). e.g. vocal: HP -> comp -> presence ->
air -> reverb.
- **fl_export_midi** — Write a type-1 multi-track .mid from an arrangement spec. YOU (Claude)
generate the whole arrangement -- multiple named tracks, each with notes
{pitch, start_bars, length_bars, velocity} across all sections -- and this
writes ONE .mid. Bypasses the note-bridge's one-pattern + MCP_Apply limits.

Does NOT touch FL: IMPORT the file yourself (FL: File > Import > MIDI file,
or drag it into the playlist). FL won't auto-load instruments -- assign a
channel to each imported track. Returns the saved file path.
- **fl_list_presets** — Read preset NAMES from disk: FL Presets\ (per-plugin 'Plugin presets',
plus Channel/Mixer presets) + Serum 2 Presets (.serumpreset). With NO
filter -> a SUMMARY (which plugins have presets + counts). With
plugin_filter -> that plugin's full preset list. Read-only. FL can't LOAD
presets via the API -- this is for suggestions (you load the named preset,
then Claude can tweak it).
- **fl_suggest_preset** — Suggest presets from YOUR library matching a description, for a given
plugin. Reads the plugin's preset NAMES from disk + ranks by name match.
Name-only (can't hear the sound) -- apply your own knowledge of preset
naming. FL can't LOAD presets via the API: recommend which to load in the
plugin manually; AFTER the user loads it you can tweak its params via
fl_plugin_set_param / fl_apply_*_intent.
- **fl_diagnose_mix** — Scan the WHOLE mix and report problems + proposed fixes. READ-ONLY.

Transparent threshold rules (clipping, headroom, level imbalance, missing
high-pass, ungrouped tracks, EQ clashes) on a thin paginated snapshot;
returns findings (severity + exact evidence) + concrete proposals.

IMPORTANT: this samples peaks over only ~1.2s -- one MOMENT of the song,
so it can MISS clipping in a drop/chorus that isn't playing right now. For
full-song-accurate levels use WATCH mode: fl_mix_watch_start -> play the
whole song -> fl_mix_watch_stop. If stopped, level rules are skipped
(needs_playback). Applies nothing.
- **fl_apply_mix_fix** — Apply ONE Mix Doctor fix via the safety layer: snapshot -> write ->
FRESH readback -> rollback-able with fl_rollback_last_change.

Call this ONLY after the user approves the exact change in conversation
(Mix Doctor never auto-applies). 'trim_volume' sets a mixer track's fader
to target_db. For grouping use fl_group_tracks; for EQ use
fl_apply_eq_intent.
- **fl_mix_watch_start** — Begin a peak-HOLD watch: continuously sample every mixer track's peak,
keeping a RUNNING MAX per track, until fl_mix_watch_stop. Tell the user to
PLAY the whole song (or at least the loudest section / the drop) while this
runs -- then stop for full-song-accurate level diagnosis. Read-only.
- **fl_mix_watch_status** — Is a peak watch running, and for how long / how many polls so far?
- **fl_mix_watch_stop** — Stop the peak watch and diagnose on the FULL-SONG running-max peaks
captured across the whole watch (accurate clipping/headroom/imbalance vs
the ~1.2s snapshot). Read-only -- proposes fixes, applies nothing.
- **fl_gain_stage** — Propose per-track fader trims so each track's peak sits in a healthy
band (~-12..-6 dBFS, aim -9) and the Master keeps -3..-6 dB headroom.
READ-ONLY proposals -- apply approved ones via fl_apply_mix_fix (rollback).

Uses FULL-SONG peaks from a recent watch (fl_mix_watch_start -> play ->
fl_mix_watch_stop) when available; else a ~1.2s snapshot (prefer watch).
FL's fader is POST-chain, so this sets a track's OUTPUT level, not a true
pre-plugin input trim.
- **fl_reference_match** — Compare your mix's LEVEL + rough tonal BALANCE to a reference track.
READ-ONLY. Analyzes the reference FILE (overall level + low/mid/high
spectral-band shares) and your mix (Master peak for level + a ROUGH
name-based band estimate). HONEST: a level/balance compare, NOT a spectral
match -- FL doesn't expose its output audio, so the your-mix balance is
estimated from track names + peaks. Suggests adjustments; applies nothing.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "flstudio-mcp": {
    "command": "uvx",
    "args": ["fl-studio-mcp"]
  }
}
```

## Documentation

## What rosasynthesiz/flstudio-mcp does

rosasynthesiz/flstudio-mcp lets an MCP client inspect and operate an FL Studio project from natural-language requests. It covers transport, tempo, the mixer, channel rack, plugin parameters, piano-roll notes, pattern work, routing-related production tasks, and mix diagnosis. The server can read project state and measured levels, then apply targeted changes through FL Studio's controller layer.

Its production workflows include gain staging, peak monitoring across playback, level-aware compression, reference matching, EQ, reverb, delay, bulk mute or solo operations, track and channel coloring, and recommendations based on installed plugins and presets. Composition features include note and chord writing, quantization, scale-based composition, drum patterns, arrangement work, and MIDI export. Audio utilities can estimate tempo and key and transcribe melody, chords, or drums into MIDI.

## How it works

The MCP server communicates with a controller running inside FL Studio. Two virtual MIDI ports carry commands and responses: `FLStudioMCP RX` and `FLStudioMCP TX`. The controller reports FL Studio status, including its version, heartbeat age, and ports in use, through `fl_ping`.

Writes use a safety-oriented workflow. The server can capture a snapshot, preview writes with dry-run mode, apply a change, read back the result, and undo the last change by replaying the saved pre-change state. Plugin parameter writes resolve names against the live parameter list and report the value FL Studio actually retained. Piano-roll writing and quantization use a separate bridge that must be armed from the Piano roll scripting menu.

## Setup and configuration

The repository includes installers for Windows and macOS. A typical setup is:

1. Clone the repository.
2. Create virtual MIDI ports named exactly `FLStudioMCP RX` and `FLStudioMCP TX`.
3. Run the Windows or macOS installer.
4. Start the bridge daemon and keep it running.
5. Connect the ports in FL Studio.
6. Open the Piano roll and run `MCP_Apply` once during the session if note writing or quantization is needed.

Windows uses loopMIDI; macOS uses the built-in IAC Driver. The package can also be installed with `python -m pip install fl-studio-mcp` when the FL Studio controller and MIDI bridge are already configured. Python 3.10 or newer, FL Studio 2025 or newer, and Windows 10/11 or macOS are required. `ffmpeg` on the system path is optional for MP3 analysis. Linux is not supported.

## Tools and capabilities

The exposed tools include:

- Check controller health, read project, mixer, channel, transport, and playhead state, and control playback, recording, tempo, and position.
- Set mixer and channel volume, pan, mute, solo, and names.
- Take snapshots, enable dry-run previews, and roll back the latest change.
- Write or quantize piano-roll notes using MIDI pitches, bar-based timing, lengths, velocities, and grid quantization.
- List existing effect-slot plugins, inspect their named parameters, and set parameters by index or name.
- Diagnose mix problems using clipping, headroom, balance, filtering, grouping, and overlapping-EQ evidence.
- Generate or transcribe MIDI, create composition patterns, and analyze audio for tempo, key, melody, chords, or drums.

## Limitations and notes

FL Studio's scripting API cannot load plugins, load audio files, or render audio. Plugin and preset workflows can recommend an item, but the item must be loaded in FL Studio separately; rendering and export are manual. Some stepped plugin parameters only accept their own discrete values, and certain parameters may ignore writes. The server re-reads parameter values and reports unsuccessful verification instead of treating the requested value as applied.

Piano-roll operations require `MCP_Apply` to be armed once per session. Twelve-tone MIDI also approximates microtonal scales and gamaka-heavy traditions by rounding intervals to semitones and retaining the scale framework rather than detailed ornamentation.

_Full upstream README: https://allmcps.com/mcp/rosasynthesiz-flstudio-mcp/readme_

