Skip to content
Back to search

flstudio-mcp

AI-powered FL Studio control via the Model Context Protocol. Beyond piano-roll notes — full in-DAW mixing (Mix Doctor, gain staging, EQ/comp/reverb, reference matching), routing, and composition through Claude and other MCP clients. 67 tools. Windows.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/rosasynthesiz/flstudio-mcp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/rosasynthesiz/flstudio-mcp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/rosasynthesiz--flstudio-mcp/badge.svg)](/listings/rosasynthesiz--flstudio-mcp)

HTML

<a href="/listings/rosasynthesiz--flstudio-mcp"><img src="/api/listings/rosasynthesiz--flstudio-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

scripts\install_windows.bat        :: controller + server + note bridge
fl-studio-mcp-daemon               :: start the bridge, keep it running
./scripts/install_macos.sh         # macOS: controller + server + note bridge
fl-studio-mcp-daemon               # start the bridge, keep it running

Wire the two virtual MIDI ports in FL (loopMIDI on Windows, IAC Driver on macOS), arm `MCP_Apply` once in the piano roll, then ask Claude in plain language:

> "Scan my mix and tell me what's wrong." — "Set up a vocal chain from my plugins." — "Export this arrangement to MIDI."

Full setup is below.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 395 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # FL Studio MCP — control FL Studio with Claude, Cursor and other AI assistants
  2. **The MCP server for FL Studio (Fruity Loops): AI mixing, mix diagnosis, plugin control, piano roll and drum patterns, in plain language.**
  3. [![PyPI](https://img.shields.io/pypi/v/fl-studio-mcp)](https://pypi.org/project/fl-studio-mcp/)
  4. ![status](https://img.shields.io/badge/status-beta-yellow)
  5. ![license](https://img.shields.io/badge/license-MIT-green)
  6. ![python](https://img.shields.io/badge/python-3.10+-blue)
  7. ![platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS-blue)
  8. ![FL Studio](https://img.shields.io/badge/FL%20Studio-2025%2B-orange)
  9. ![Claude diagnosing and fixing a mix in FL Studio](docs/demo.gif)
  10. *Claude diagnosing and fixing a mix in FL Studio through natural language.*
  11. ## Overview
  12. `flstudio-mcp` is a Model Context Protocol (MCP) server that connects FL Studio to AI assistants: Claude Code, Claude Desktop, Cursor, Codex, or any other MCP client. Ask for a mix diagnosis, a vocal chain, a chord progression in a particular scale, or a full arrangement, and the assistant carries it out inside your open FL Studio project through FL's scripting API and a set of calibrated, safety-checked tools.
  13. - **76 tools** for the mixer, plugins, piano roll, step sequencer, patterns, routing and transport
  14. - **One-command setup on macOS**, with no MIDI configuration
  15. - **Every change can be undone**, and an undo never touches a different project
  16. - **Windows and macOS**, FL Studio 2025 and 2026
  17. It is genre- and producer-agnostic: nothing about it assumes a particular style of music.
  18. ## Quickstart
  19. **macOS** — one command, no MIDI setup:
  20. ```bash
  21. uvx --from git+https://github.com/rosasynthesiz/flstudio-mcp fl-studio-mcp setup
  22. ```
  23. It installs the FL controller script, then waits. Open FL Studio and load any
  24. project; the command prints `Status: READY` once FL answers. You do not create
  25. IAC ports and you do not touch FL's MIDI Settings: the server makes its own
  26. MIDI ports and FL links them by itself.
  27. Then add the server to your AI client:
  28. ```bash
  29. uvx --from git+https://github.com/rosasynthesiz/flstudio-mcp fl-studio-mcp connect
  30. ```
  31. **Windows** — two loopMIDI ports and one step in FL (details in [Setup](#setup)):
  32. ```bat
  33. :: first: in loopMIDI, create two ports named exactly "FLStudioMCP RX" and "FLStudioMCP TX"
  34. git clone https://github.com/rosasynthesiz/flstudio-mcp.git
  35. cd flstudio-mcp
  36. scripts\install_windows.bat
  37. ```
  38. Then ask Claude in plain language:
  39. > "Scan my mix and tell me what's wrong." — "Set up a vocal chain from my plugins." — "Export this arrangement to MIDI."
  40. If something does not connect, run `fl-studio-mcp doctor`. It checks each
  41. stage and prints one status and the one next step.
  42. The PyPI package (`fl-studio-mcp` 1.0.0) is the older v1 and does not have
  43. these commands yet; use the commands above until 2.0.0 is released.
  44. ## Capabilities
  45. ### Mixing & diagnosis
  46. - **Mix Doctor** — scans the whole mix and reports concrete problems (clipping, low headroom, level imbalance, missing high-pass, ungrouped related tracks, overlapping EQ boosts), each with the exact evidence and a proposed fix. Fixes are applied one at a time, only on approval, through a snapshot → write → readback → rollback safety layer. Master clipping is resolved by trimming the contributing source tracks rather than pulling the master.
  47. - **Full-song peak watch** — holds a running peak per track across playback, so level decisions are based on the loudest moment of the actual song, not a single instant.
  48. - **Calibrated processing intents** — musical EQ, compression, reverb, and delay moves mapped to real plugin parameters (native and third-party), each applied as one reversible change.
  49. - **Level-aware compression** — sets thresholds relative to a track's measured level during playback.
  50. - **Gain staging** — proposes per-track trims toward a healthy level with proper master headroom.
  51. - **Reference match** — compares your mix's level and tonal balance against a reference track.
  52. - **Bulk track control** — solo or mute a whole group (drums, vocals, …) in one step, with a one-call reset.
  53. - **Track & channel coloring** — color a track, a channel, or a whole group (drums, vocals, …) by color name or hex, reversible like every other change.
  54. ### Plugin & preset control
  55. - Read and set plugin parameters by name, on native and third-party plugins (the parameter list is resolved live).
  56. - **Verified writes** — every parameter write is re-read on a fresh tick and retried (0.4 s apart) if FL did not take it; the answer carries `verified` / `attempts` and a `hint`, so a swallowed write is reported instead of echoed back as if it worked.
  57. - **Batch parameter changes** — `fl_plugin_set_params` sets several knobs of one plugin in a single paced burst and one undo step; `fl_rollback_last_change` puts them all back together.
  58. - **Chain suggestions** and **preset recommendations** drawn from your actual installed library — read directly from FL's plugin database and preset folders on disk, so recommendations are limited to what you own.
  59. ### Composition
  60. - **Multi-track MIDI export** — generate a complete arrangement as a standard MIDI file to import.
  61. - **Multi-pattern arrangement** — create, name, clone, and mark sections.
  62. - **Pattern control** — list (paginated), select, rename, and read the length (beats/bars via the project PPQ) of any pattern; select and rename are single reversible steps with their own rollback.
  63. - **Drum patterns in the step sequencer**: read or set a channel's steps in the current pattern, e.g. `x...x...x...x...`, reversible like every other change.
  64. - **Note and chord writing** into the piano roll, with quantize to a grid (for new notes and existing ones).
  65. - **Composition in any scale or mode** — Western modes, pentatonic, ragas, maqam, and beyond — through the scale composer, where Claude supplies the notes for the requested scale.
  66. ### Audio analysis
  67. - Tempo and key estimation from an audio file.
  68. - Melody-to-MIDI transcription (CREPE pitch tracking, with a lighter fallback).
  69. - **Chords-to-MIDI** transcription of polyphonic audio (keys, piano, guitar) with Spotify's Basic Pitch, as notes for the piano roll or a `.mid` file.
  70. - **Drums to MIDI**: a drum loop or stem to kick, snare, clap, closed and open hi-hat, aligned to the beat, as a `.mid` or straight into the step sequencer of the channels you choose (one undo step).
  71. The server exposes 76 tools across 15 categories, plus 6 live resources (project, mixer, transport, channels, patterns, status) that Claude can read directly.
  72. ## What sets it apart
  73. flstudio-mcp is built as a mixing and production assistant, not only a note sender. It diagnoses and repairs a whole mix, makes decisions from real measured levels rather than guesswork, and is aware of your actual plugin and preset library when it makes suggestions. Every change that touches the project is shown before it is applied, logged, and reversible.
  74. ## Limitations
  75. These are properties of FL Studio's scripting API, stated plainly:
  76. - **Plugins, audio files, and rendering are UI-only.** FL's API cannot load a plugin, load an audio file, or render audio. The plugin and preset tools therefore *suggest* — you load the chosen plugin or preset, and Claude then configures it. Audio export is done manually (File > Export); Claude can analyze the rendered file afterward.
  77. - **Only some plugin parameters accept arbitrary values.** Levels and gains do; stepped parameters (filter types, orders, selectors) snap to their own grid steps, so an off-grid request cannot land; some parameters (Fruity Parametric EQ 2's band widths) ignore writes entirely. The parameter tools re-read and retry, then report `verified: false` with a `hint` and the value FL actually holds, instead of echoing the request as if it had landed.
  78. - **Note writing is armed once per session.** A generated pyscript writes notes into the piano roll; FL exposes no API to run a pyscript, so you run "MCP_Apply" once from the piano roll's scripting menu at the start of a session.
  79. - **Micro-tonal and gamaka-heavy music is approximated.** Scales with intervals smaller than a semitone (e.g. Arabic maqam) are rounded to the nearest semitone, and traditions built on gamaka/ornamentation (e.g. Carnatic) get the *scale framework* — the correct swaras and intervals — not gamaka or micro-tonal rendering. That's a limit of 12-tone MIDI, not of the tools.
  80. ## Requirements
  81. - **macOS** or **Windows 10/11** (Linux: untested, the macOS path should apply)
  82. - **FL Studio 2025** or newer (tested on 26.1)
  83. - **Claude Code**, **Claude Desktop**, Cursor, Codex or any MCP client
  84. - **Python 3.10+** (with `uvx`, [uv](https://docs.astral.sh/uv/) brings its own)
  85. - Virtual MIDI ports:
  86. - macOS: nothing to install, the server creates them
  87. - Windows: **loopMIDI** ([download](https://www.tobias-erichsen.de/software/loopmidi.html))
  88. - Optional: **ffmpeg** on PATH (for MP3 analysis)
  89. ## Setup
  90. ### macOS
  91. 1. **Run setup:**
  92. ```bash
  93. uvx --from git+https://github.com/rosasynthesiz/flstudio-mcp fl-studio-mcp setup
  94. ```
  95. It copies the controller script into FL Studio's user-data folder (a
  96. different existing copy is kept next to it as a `.bak-<date>` file), then
  97. waits for FL Studio.
  98. 2. **Open FL Studio and load any project.** If FL was already open, restart it
  99. once. Setup prints `Status: READY` when FL answers.
  100. 3. **Add the server to your client:** run `... fl-studio-mcp connect` and paste
  101. the entry it prints (Claude Code, Claude Desktop, Cursor, Codex).
  102. That is all. How it works: the server creates two virtual MIDI ports that share
  103. one name, `FLStudioMCP`. The controller script lists that name as its supported
  104. device, so FL links the script, pairs input and output on one port number and
  105. enables them without any clicks. FL has to see the ports when it starts the
  106. first time; after that it re-attaches by itself.
  107. Working from a clone instead: `./scripts/install_macos.sh` does the same inside
  108. a private `.venv` in the repo (your system Python is not touched).
  109. Already using IAC Driver ports named `FLStudioMCP RX` / `FLStudioMCP TX`? They
  110. keep working and are used first. `FLSTUDIO_MCP_VIRTUAL_PORTS=0` stops the
  111. server from creating its own ports.
  112. ### Windows
  113. Windows cannot create MIDI ports from a program, so loopMIDI is still needed.
  114. 1. **Create two loopMIDI ports** named exactly `FLStudioMCP RX` and
  115. `FLStudioMCP TX`:
  116. - Install and open [loopMIDI](https://www.tobias-erichsen.de/software/loopmidi.html).
  117. - Remove default ports (`loopMIDI Port`, …); those names are not detected.
  118. - Type `FLStudioMCP RX` in **New port-name**, click **+**. Repeat for `FLStudioMCP TX`.
  119. - Keep loopMIDI running (it can start with Windows).
  120. 2. **Install:**
  121. ```bat
  122. git clone https://github.com/rosasynthesiz/flstudio-mcp
  123. cd flstudio-mcp
  124. scripts\install_windows.bat
  125. ```
  126. The server goes into a `.venv` folder inside the repo, using Python
  127. 3.12/3.11/3.10 when available. The installer prints the full paths of the
  128. commands. It finds your Documents folder even when it is redirected
  129. (OneDrive, non-English names) and follows FL's own "User data folder"
  130. setting; if it still cannot find the folder, run
  131. `setx FL_SETTINGS "<folder>\FL Studio\Settings"` once and open a new terminal.
  132. 3. **Configure FL Studio once** — Options > MIDI Settings:
  133. - Input list: select `FLStudioMCP RX`, turn on **Enable**, set Controller
  134. type to **FLStudioMCP**, and give it a Port number.
  135. - Output list: select `FLStudioMCP TX` and give it the **same** Port number.
  136. 4. **Check:** `.venv\Scripts\fl-studio-mcp.exe doctor` should print `Status: READY`.
  137. 5. **Add the server to your client:** `.venv\Scripts\fl-studio-mcp.exe connect`
  138. prints the entry, with the full path already filled in.
  139. ### Both platforms
  140. **No daemon to start.** The first MCP server that starts owns the MIDI ports
  141. and shares them on a local socket; a second client joins it automatically.
  142. The standalone daemon (`fl-studio-mcp-daemon`, Windows: `scripts\start_daemon.bat`)
  143. is still there for one case: an MCP client that cannot receive MIDI itself,
  144. such as the Microsoft Store build of Claude Desktop. Start the daemon first and
  145. the server joins it. An older config with `FLSTUDIO_MCP_TRANSPORT=tcp` keeps
  146. working, with or without the daemon; the setting is no longer needed.
  147. **Note writing is armed once per session.** Open the piano roll and choose
  148. **Tools > Scripting > MCP > MCP Apply** once. On macOS the note bridge then
  149. sends `Cmd+Opt+Y`; grant Accessibility permission to the app that runs the MCP
  150. server (**System Settings > Privacy & Security > Accessibility**).
  151. **Optional audio features** (not installed by default):
  152. ```
  153. pip install -e ".[audio]" # tempo/key, drums to MIDI, light melody
  154. pip install -e ".[audio,audio-accurate]" # + CREPE (accurate melody)
  155. pip install -e ".[audio-chords]" # chords: then also run
  156. pip install --no-deps basic-pitch==0.4.0 # (skips its TensorFlow requirement)
  157. ```
  158. The installers take `FLMCP_EXTRAS` (`all`, `none`, or any of `audio accurate chords`);
  159. the Windows installer also asks.
  160. **Undo is tied to the project.** Every change Claude makes can be rolled back
  161. with `fl_rollback_last_change`, but only inside the project and FL session it
  162. was made in. An entry from another project is refused, never applied.
  163. After updating, run `setup` again and restart FL Studio so the controller and
  164. the server are the same version (`doctor` reports a mismatch). See
  165. [bridge correctness regressions](docs/bridge-correctness-regressions.md) for
  166. numeric JSON compatibility, dry-run behavior, and localized parameter names.
  167. ## Troubleshooting
  168. | Symptom | Fix |
  169. |---|---|
  170. | Anything about connecting | `fl-studio-mcp doctor` checks each stage and prints one status code and the one next step. Start here. |
  171. | A change is refused with `FL_BUSY` | FL Studio refuses writes while a dialog is open (the welcome screen counts). Close it or load a project, then try again. |
  172. | Virtual MIDI ports not found / not detected | The two ports must be named **exactly** `FLStudioMCP RX` and `FLStudioMCP TX`. loopMIDI's default `loopMIDI Port` names won't work. Recreate them in loopMIDI (Windows) or IAC Driver (macOS), make sure loopMIDI is running, then re-run the installer. |
  173. | `FL Studio Settings\Hardware folder not found` | Open FL Studio once so it creates its user-data folder. If you moved that folder (Options > File settings > User data folder), `setx FL_SETTINGS "<that folder>\FL Studio\Settings"`, open a new terminal and re-run. |
  174. | `fl-studio-mcp-daemon` is not recognized | The commands live in the repo's `.venv\Scripts\` folder. Run them by full path (the installer prints it). |
  175. | Python crashes on start / MIDI library fails to load (Windows) | Install Python 3.12 from python.org, delete the `.venv` folder, and re-run the installer. |
  176. | No `[FLStudioMCP] Ready` in FL's Script output | The controller isn't registered: set the `FLStudioMCP RX` input's **Controller type** to **FLStudioMCP** in MIDI Settings, confirm `device_FLStudioMCP.py` is in `Settings\Hardware\FLStudioMCP\`, then fully restart FL Studio. |
  177. | Claude can't reach FL / `fl_ping` fails | Run `fl-studio-mcp doctor` and do the step it prints. `fl_ping` returns the same `status` and `next`. Most common: FL Studio has no project loaded yet, or FL was opened before the server the first time (restart FL once). |
  178. | `fl_ping` says the heartbeat is stale (`Ready` is shown, but FL stops answering) | Usually happens after changing MIDI Settings while the script is running. Open View > Script output, select the FLStudioMCP tab and click **Reload script** (or restart FL Studio). Also check that the Output port number is on `FLStudioMCP TX`, not `FLStudioMCP RX`. |
  179. | Note-writing does nothing | Run `MCP_Apply` once from the piano roll's scripting menu this session — it arms the note bridge. |
  180. | macOS note-trigger fails | Grant Accessibility permission to the app running the MCP server or daemon, then click the FL Piano roll and try `Cmd+Opt+Y`. |
  181. | Audio tools error or are unavailable | Re-run the installer and answer Y to "Install audio to MIDI?" (or install the extras manually, see Setup step 2). |
  182. | The installer stops because the MCP server is running | Claude Desktop or Claude Code is running `fl-studio-mcp.exe` from the `.venv`, which locks its files. Quit Claude Desktop or Claude Code, then re-run. |
  183. ## Usage examples
  184. Plain-language prompts:
  185. - "Scan my mix and tell me what's wrong."
  186. - "Set up a vocal chain on the lead vocal using my plugins."
  187. - "Suggest a vintage bass preset from my Serum library."
  188. - "Compose an 8-bar melody in D Dorian and write it to the selected channel."
  189. - "Export this arrangement to a MIDI file."
  190. - "What tempo and key is this track?" (on an audio file)
  191. ## Tools
  192. 76 tools, grouped by area.
  193. ### Transport
  194. - `fl_ping` — Check that FL Studio is running and the controller script is loaded.
  195. - `fl_get_tempo` — Read the project tempo in BPM.
  196. - `fl_set_tempo` — Set the project tempo (10–999 BPM).
  197. - `fl_play` — Start playback.
  198. - `fl_stop` — Stop playback.
  199. - `fl_toggle_play` — Toggle play and stop, like the spacebar.
  200. - `fl_record` — Toggle record-arm.
  201. - `fl_get_play_state` — Report whether FL is playing or recording.
  202. - `fl_get_song_position` — Read the playhead position in beats.
  203. - `fl_set_song_position` — Move the playhead to a beat position.
  204. ### Project, mixer & channel state
  205. - `fl_get_project_state` — Tempo, transport state, and pattern, channel and mixer counts.
  206. - `fl_get_mixer_state` — Every mixer track with name, volume, pan, mute and solo.
  207. - `fl_get_channel_state` — Every channel-rack channel with name, volume, pan, mute and solo.
  208. - `fl_set_mixer_volume` — Set a mixer track's volume (linear or dB).
  209. - `fl_set_mixer_pan` — Set a mixer track's pan (-1 left to +1 right).
  210. - `fl_set_mixer_mute` — Mute or unmute a mixer track.
  211. - `fl_set_mixer_solo` — Solo or unsolo a mixer track.
  212. - `fl_set_mixer_name` — Rename a mixer track.
  213. - `fl_set_channel_volume` — Set a channel's volume (linear or dB).
  214. - `fl_set_channel_pan` — Set a channel's pan (-1 left to +1 right).
  215. - `fl_set_channel_mute` — Mute or unmute a channel.
  216. - `fl_set_channel_solo` — Solo or unsolo a channel.
  217. - `fl_take_snapshot` — Read the current state of a scope for before/after comparison.
  218. - `fl_rollback_last_change` — Undo the most recent write from its saved snapshot.
  219. - `fl_set_dry_run` — Preview writes without changing the project.
  220. ### Mix Doctor & gain staging
  221. - `fl_diagnose_mix` — Scan the whole mix and report problems with proposed fixes (read-only).
  222. - `fl_apply_mix_fix` — Apply one Mix Doctor fix with snapshot, readback and rollback.
  223. - `fl_mix_watch_start` — Start a full-song peak watch that keeps each track's loudest moment.
  224. - `fl_mix_watch_status` — Report whether a peak watch is running and for how long.
  225. - `fl_mix_watch_stop` — Stop the peak watch and diagnose the mix on full-song peaks.
  226. - `fl_gain_stage` — Propose per-track fader trims toward a healthy level with master headroom.
  227. - `fl_reference_match` — Compare your mix's level and tonal balance to a reference track.
  228. ### Processing intents
  229. - `fl_apply_eq_intent` — Apply a musical EQ move on Fruity Parametric EQ 2.
  230. - `fl_apply_compression_intent` — Compress with Fruity Limiter or FabFilter Pro-C, relative to the measured level.
  231. - `fl_apply_reverb_intent` — Reverb moves on Fruity Reeverb 2 (decay, wet, high-cut) as one undoable change.
  232. - `fl_apply_delay_intent` — Delay moves on Fruity Delay (time, feedback, wet, feedback cut) as one undoable change.
  233. - `fl_get_track_level` — Measure a mixer track's level from its meter over a short window.
  234. ### Plugin parameters
  235. - `fl_plugin_list` — List the filled effect slots on a mixer track.
  236. - `fl_plugin_get_params` — List every named parameter of a plugin with its value and display text.
  237. - `fl_plugin_set_param` — Set one plugin parameter, then verify it landed.
  238. - `fl_plugin_set_params` — Set several parameters of one plugin as a single rollback unit.
  239. ### Presets & processing chains
  240. - `fl_list_presets` — List preset names from your FL Studio and Serum 2 preset folders.
  241. - `fl_suggest_preset` — Suggest presets from your own library that match a description.
  242. - `fl_list_chains` — List the built-in processing-chain recipes (vocal, drum bus, bass, master).
  243. - `fl_list_installed_plugins` — List the plugins installed in FL Studio, de-duplicated and categorized.
  244. - `fl_setup_chain` — Plan a processing chain over a track's existing plugins.
  245. ### Routing
  246. - `fl_get_routing` — Show which tracks a mixer track sends to.
  247. - `fl_get_routing_all` — Show routing for every mixer track.
  248. - `fl_get_channel_routing` — Show which mixer track each channel is linked to.
  249. - `fl_detect_cleanup_candidates` — Flag empty channels and unused mixer tracks, with a reason (read-only).
  250. - `fl_set_route` — Turn a send between two mixer tracks on or off.
  251. - `fl_group_tracks` — Route a group of tracks into a bus, and the bus to the master.
  252. ### Bulk mute, solo & color
  253. - `fl_solo_tracks` — Solo a group (drums, vocals, …) so only it is audible.
  254. - `fl_mute_tracks` — Mute a group of tracks.
  255. - `fl_clear_mute_solo` — Unmute and unsolo every mixer track.
  256. - `fl_set_track_color` — Color mixer tracks by name, group, color name or hex.
  257. - `fl_set_channel_color` — Color channel-rack channels.
  258. ### Composition & arrangement
  259. - `fl_write_piano_roll_notes` — Write notes into the open piano roll.
  260. - `fl_quantize_pattern` — Quantize the notes already in the open piano roll.
  261. - `fl_write_raga_melody` — Write a melody in any scale into the selected channel.
  262. - `fl_write_raga_chords` — Write chords or a progression in any scale into the selected channel.
  263. - `fl_get_step_grid` — Read which step-sequencer steps are on for a channel.
  264. - `fl_set_step_grid` — Set exactly which step-sequencer steps are on for a channel.
  265. - `fl_arrange_new_pattern` — Create, select and name the next empty pattern.
  266. - `fl_arrange_select_channel` — Select a channel-rack channel.
  267. - `fl_arrange_clone_pattern` — Clone a pattern with its notes and rename the clone.
  268. - `fl_arrange_add_marker` — Add a named timeline marker at a bar.
  269. - `fl_export_midi` — Write a multi-track .mid file from an arrangement.
  270. ### Patterns
  271. - `fl_pattern_list` — List the project's patterns with their names.
  272. - `fl_pattern_select` — Switch the working pattern; one undo step.
  273. - `fl_pattern_rename` — Rename a pattern; one undo step.
  274. - `fl_pattern_get_length` — Read a pattern's length in beats, bars and ticks.
  275. ### Audio analysis
  276. - `fl_analyze_audio` — Estimate tempo and key of an audio file.
  277. - `fl_extract_melody` — Transcribe a single-line melody from audio to notes.
  278. - `fl_extract_chords` — Transcribe chords from audio to notes.
  279. - `fl_extract_drums` — Detect drum hits in a loop or stem and sort them into kick, snare, clap and hi-hats.
  280. ## Architecture
  281. A thin controller script runs inside FL Studio and returns only cheap, raw data; all judgement — diagnosis, calibration, planning — happens server-side. The two talk over MIDI SysEx, the only channel FL's script sandbox allows. The first MCP server to start owns the MIDI ports and shares them on a local socket, so several clients can use one FL Studio at once. Note authoring uses a generated pyscript bridge: the server re-triggers the armed `MCP_Apply` script with the platform run-last-script shortcut after a brief window focus. Every project-modifying tool routes through a snapshot → write → readback → rollback safety layer backed by a change log that is tied to the open project.
  282. Design notes and findings are in [`docs/`](docs/).
  283. ## FAQ
  284. **Can Claude control FL Studio?**
  285. Yes. With this MCP server Claude reads and changes the open project: mixer levels, plugin parameters, piano-roll notes, step-sequencer drums, patterns, routing, tempo and transport.
  286. **Which AI assistants does it work with?**
  287. Any MCP client. `fl-studio-mcp connect` prints the ready-made entry for Claude Code, Claude Desktop, Cursor and Codex.
  288. **Which FL Studio versions are supported?**
  289. FL Studio 2025 and 2026. It is tested on 26.1 (Producer Edition), on macOS and Windows 11.
  290. **Does it work on a Mac?**
  291. Yes, and setup is one command: the server creates its own MIDI ports and FL Studio links them by itself. Windows needs the free loopMIDI tool.
  292. **Can it load plugins, load samples or render audio?**
  293. No. FL Studio's scripting API does not allow that. The assistant suggests plugins and presets from the ones you own, you load them, and it then configures them.
  294. **Is it safe to use on a real project?**
  295. Each change is logged with the value it replaced and can be rolled back with `fl_rollback_last_change`. Undo entries are tied to the project they were made in, so an old entry is never applied to another project. A dry-run mode shows what would change without changing it.
  296. **Is it free?**
  297. Yes. MIT licence, open source.
  298. ## License
  299. MIT — see [LICENSE](LICENSE).
  300. ## Status & contributing
  301. Beta. `main` is version 2 (in development); PyPI still carries 1.0.0 until 2.0.0 is released. Tested live on FL Studio 26.1 on macOS and Windows 11. Linux is untested; contributions are welcome. Issues and pull requests: [github.com/rosasynthesiz/flstudio-mcp](https://github.com/rosasynthesiz/flstudio-mcp).
  302. <!-- mcp-name: io.github.rosasynthesiz/flstudio-mcp -->

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.