serum-mcp
Generate, edit and save Xfer Serum 2 presets from a plain-English description — as an server, so any MCP client (Claude Code, Claude Desktop, ...) can drive it directly.
Potencia tu agente
Instalación del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
Aún no hay una versión empaquetada en el registro. Sigue el README del repositorio.
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDel publicador
Generate, edit and save Xfer Serum 2 presets from a plain-English description — as an server, so any MCP client (Claude Code, Claude Desktop, ...) can drive it directly.
Generate, edit and save Xfer Serum 2 presets from natural language, over MCP
You: generate a dark, evolving pad with a slow chorus
Claude: [builds a PresetSpec from your description, calls
generate_preset(spec)]
Wrote ~/Documents/Xfer/Serum 2 Presets/Presets/User/PD - Dark Evolving Chorus.SerumPreset
Osc A: ON octave=-1 volume=0.75 table_pos=42.0
Filter 1: ON type=lowpass_24 cutoff=0.32 resonance=18%
Env 1: attack=0.8s decay=2.5s sustain=0.70 release=3.0s
FX chain: FXChorus (wet=45%)
Open Serum in whatever DAW you use (FL Studio, Ableton, Bitwig, ...), load
the preset, done. serum-mcp never touches your DAW, never renders audio,
and never loads the Serum plugin itself — it reads and writes the
.SerumPreset file format directly.
Existing "AI Serum preset" tools are either closed-source SaaS products or
one-shot config-to-preset generators. serum-mcp is:
edit_preset lets you refine an
existing patch ("make it warmer", "add more resonance") instead of only
generating from scratch.docs/PARAMETER_SCHEMA.md), because Xfer
doesn't publish this format and we don't pretend otherwise.See Prior art for how this compares to Serum-Preset-Generator, SerumPresetGenerator, and Pounding Systems' AI preset generator.
By design, and deliberately not planned for later:
.SerumPreset file.A V2 direction — "reproduce this sound from an audio file" — is kept in mind architecturally but not started.
Requires Python 3.11+ and uv. No API key of any kind is required — see How it works for why.
Most people reaching for this tool are producers, not developers. If the steps below look intimidating, paste this into Claude Desktop (or any LLM assistant that has file/terminal access on your computer) instead of typing any of it yourself:
Please set up the serum-mcp MCP server on this computer so I can use it
with my MCP client.
1. Install `uv` (a Python package manager) if not already installed --
on Windows: run
`powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`
on Mac/Linux: run `curl -LsSf https://astral.sh/uv/install.sh | sh`
2. Clone https://github.com/Celian-mrc/serum-mcp somewhere on this
machine (or download it as a ZIP and extract it), then run `uv sync`
inside that folder.
3. Find my Serum presets folder -- in Serum, the hamburger menu ->
"Show Serum Presets folder" -> note the path ending in Presets/User
(Presets\User on Windows).
4. Add serum-mcp as an MCP server in my client's config, pointing
`--directory` at the folder from step 2 and setting
SERUM_PRESETS_PATH to the path from step 3. If I'm on Claude Desktop
for Windows, the config file is claude_desktop_config.json -- NOTE:
if Claude Desktop was installed via the Microsoft Store, the real
config file is NOT in the normal %APPDATA%\Claude location, it's
under %LOCALAPPDATA%\Packages\Claude_<random id>\LocalCache\Roaming\Claude\
-- search for claude_desktop_config.json across %LOCALAPPDATA% if the
normal path doesn't have it or seems unused. If I'm on Claude Code,
use `claude mcp add serum-mcp -- uv --directory <path> run serum-mcp`
instead.
5. Tell me exactly what you did, then tell me to fully quit and restart
my MCP client (not just close the window) for the change to take
effect.
If you don't have filesystem/terminal access to do any of this, say so
clearly and walk me through the manual steps from serum-mcp's own README
instead.
Otherwise, do it yourself:
git clone https://github.com/Celian-mrc/serum-mcp
cd serum-mcp
uv sync
Serum's user preset folder location varies by install — find yours via
Serum's hamburger menu → "Show Serum Presets folder" → the Presets/User
subfolder. Then set:
export SERUM_PRESETS_PATH="/path/to/Serum 2 Presets/Presets/User"
If unset, serum-mcp falls back to a couple of known default install
locations (see src/serum_mcp/config.py) before failing with a clear error
— it never silently guesses or hardcodes a path.
If you ask for a custom-synthesized wavetable (custom_harmonics) or a
wavetable sliced from one of your own audio files (sample_source, e.g.
"turn this drum one-shot into a wavetable" — see How it
works), serum-mcp also needs Serum's Tables folder
(a sibling of Presets/) to write the generated .wav into. It's derived
automatically from SERUM_PRESETS_PATH; override with SERUM_TABLES_PATH
if your install doesn't follow the standard layout. Note sample_source
slices the file into a wavetable, it does not play the sample back
faithfully.
If you instead ask to keep a one-shot/sample recognizable (sample_playback_source,
e.g. "turn this drum hit into a preset" or "layer this vocal chop with a
synth pad"), serum-mcp uses Serum's actual sample-playback engine
(SampleOsc) and copies the file into Serum's Samples folder (also a
sibling of Presets/, derived automatically or overridden via
SERUM_SAMPLES_PATH). Only .wav is supported for this (confirmed working
live, despite every factory preset referencing .flac instead — see
docs/PARAMETER_SCHEMA.md §8). The sample plays back at its originally
recorded pitch/speed when C5 is played — a fixed reference note, not
configurable. If the source file is stereo, its channels are gain-balanced
by default (sample_center_pan) to correct any left/right level bias in
the original recording (common — real one-shots are often mic'd slightly
off-center) without altering either channel's actual content.
Any of these (custom_harmonics, sample_source, sample_playback_source,
granular_source, spectral_source) write a file outside the .SerumPreset
itself — the same real Serum limitation as a wavetable hand-drawn in Serum's
own editor, not something this tool routes around. generate_preset/
edit_preset surface this: if the write depends on one of these files, the
returned path is followed by a note listing it, so you know to send that file
along too if you share the preset with someone else.
Optionally, set SAMPLE_BANK_PATH to the root of your own one-shot/drumkit
library (unrelated to Serum's own folders — this can point anywhere). With
it set, list_sample_files() can be called with no arguments and defaults
to browsing that folder, which lets the calling model proactively check
whether you have a fitting one-shot for a request even if you didn't
explicitly mention your sample bank. Not set by default, and nothing reads
your filesystem unless you configure this or point the model at a
directory yourself.
claude mcp add serum-mcp -- uv --directory /path/to/serum-mcp run serum-mcp
Or add manually to .claude/settings.json / ~/.claude.json:
{
"mcpServers": {
"serum-mcp": {
"command": "uv",
"args": ["--directory", "/path/to/serum-mcp", "run", "serum-mcp"],
"env": {
"SERUM_PRESETS_PATH": "/path/to/Serum 2 Presets/Presets/User"
}
}
}
}
Same shape, in Claude Desktop's claude_desktop_config.json
(Settings → Developer → Edit Config):
{
"mcpServers": {
"serum-mcp": {
"command": "uv",
"args": ["--directory", "/path/to/serum-mcp", "run", "serum-mcp"],
"env": {
"SERUM_PRESETS_PATH": "/path/to/Serum 2 Presets/Presets/User"
}
}
}
}
You don't write PresetSpec JSON by hand — the calling model (Claude Code,
Claude Desktop, ...) builds it from your natural-language request using the
tool descriptions and list_parameters() as a guide, the same way it would
construct arguments for any other MCP tool.
Prompt (natural language)
│
▼
The calling model (Claude Code / Claude Desktop) translates the request
into a PresetSpec (generation/spec.py) itself -- no separate LLM call.
This server has no model of its own to call.
│
▼
generate_preset(spec) / edit_preset(path, spec) (MCP tool)
│
▼
preset/mapping.py ── merges the validated PresetSpec onto a base preset
│ (fixtures/init_preset.SerumPreset for generation, the
│ existing file's own state for edits), validating
│ every value against preset/schema.py's ground-truth
│ bounds before it touches anything
▼
preset/packer.py ── encodes the result back into the real Serum 2 container
│ format (XferJson header + zstd-compressed CBOR)
▼
Written to $SERUM_PRESETS_PATH as a real .SerumPreset file
Deliberately no LLM call happens inside this server. An earlier design
had generate_preset call the Claude API internally to turn free text into
a PresetSpec — but every MCP tool call is already made by an LLM-driven
client, so that second call was pure redundancy: an extra, separately-billed
API request on top of whatever you already pay for Claude Code/Desktop, to
do reasoning the calling model could do itself for free (from your
perspective) as part of the same turn. PresetSpec is schema-validated
twice regardless (once by Pydantic when the model calls the tool, once
against the raw parameter bounds on the way into the file), so nothing about
correctness was lost — only cost. Everything in an existing preset that
isn't part of this schema (arpeggiator, MIDI clips, GUI state, unresolved
mod matrix sources, ...) round-trips through edits completely untouched.
Full parameter documentation, including exactly how each bound was verified
(or wasn't): docs/PARAMETER_SCHEMA.md.
serum-mcp has no sound-design opinion of its own — the model in your MCP
client does all of it, using this server's tools plus its own general
knowledge. A few things that noticeably change how well that goes:
<X>
preset"). find_reference_presets already searches your Factory library
and any installed banks by keyword automatically, with no setup required —
but naming something specific lets the model inspect its actual parameters
via describe_preset instead of guessing from a folder/file name, which is
a lot more precise.list_parameters() is what the model calls
on its own whenever it needs exact ranges/enums before writing a spec.
There's no separate analysis step for you to trigger.describe_preset confirm a file
is structurally valid, never that it sounds right. Test-listening is
the only way to actually judge a preset.This server already pushes detailed usage guidance to the calling model automatically (see above) — but a documented convention living inside a large system prompt doesn't guarantee it gets applied on every single generation. If your MCP client supports per-project custom instructions (Claude Desktop's Projects, for example), pasting this block in noticeably improves consistency, especially for anything more ambitious than a single one-off preset:
When generating or editing Serum presets via serum-mcp, aim for real
depth, not a minimal valid spec:
- Call list_parameters() to confirm valid field names/ranges before
generating. The top-level mod-matrix field is `mod_routes` (a list of
{source, destination, amount, bipolar}) -- not `mod_matrix` or any
other variant.
- Name and use several of the 8 available macros per preset (not just
1-2), with real fanout -- some macros driving 2+ destinations at once,
some starting near 0% as performer "bring-in" controls.
- Build out a real mod matrix -- 10+ routes per preset touching
velocity/key_track/envelope/LFO/macro sources, not just 2-3 obvious
ones.
- Whenever an oscillator uses a curated wavetable at a meaningful
table_position, or a multi-frame custom_harmonics list, wire an actual
mod route (envelope/LFO/macro) to table_position. A static
table_position on a multi-frame/curated table wastes the point of it
-- the sound should genuinely evolve/morph over the note.
- Before synthesizing an instrument-named role (guitar, piano, violin,
choir, strings, bell/mallet...), check multisample_source's curated
list first (brass_french_horn, choir_ah, epiano_suitcase, guitar_ac,
mallet_balafon, piano_grand, strings_full, synth_pad_superjx,
synth_sid, violins) -- a real sample reads far more convincing than a
synthesized approximation for these roles.
- Before generating from scratch for any genre/artist/style-named
request, call find_reference_presets(query) to search the real Serum
Factory library and any installed third-party banks -- ground the
design in an actual reference via describe_preset() rather than
working purely from parametric knowledge. For a themed request, also
do a quick web search on that genre/artist's real production
character.
- For a themed bank ("make me a bank of X"), default to melodic/textural
roles only (lead, pluck, pad, keys, arp) -- don't add bass or FX/riser
presets unless explicitly asked for.
- If I mention a specific preset or pack I already like, use
describe_preset() on it directly to ground the new design in its
actual parameters, rather than guessing from its name alone.
Always remind me to load the result in real Serum to check it sounds
right -- nothing in this pipeline renders or listens to audio, so
describe_preset()/tests only confirm the file is structurally valid,
never that it sounds correct.
serum-mcp's difference isn't better AI — it's distribution (an MCP tool,
not a separate app), editability (iterate on an existing patch, not just
one-shot generation), and honesty about format coverage (see
Known gaps).
.SerumPreset file format is not officially documented. Everything
this tool knows about it comes from community reverse-engineering plus
empirical verification against a real Serum 2 install (see
docs/PARAMETER_SCHEMA.md for methodology and
confidence levels per parameter).spotify/pedalboard)
and spectral comparison. The current architecture deliberately avoids
choices that would foreclose this later.See docs/PRIVACY.md. Short version: serum-mcp makes no
network requests and collects no data -- everything it does is local file
I/O against your own Serum presets/tables folders.
See CONTRIBUTING.md — filling in a documented gap in
docs/PARAMETER_SCHEMA.md is one of the most valuable things you can do,
even without writing code.
Generate, edit and save Xfer Serum 2 presets from natural language, over MCP
Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Serum se ejecuta localmente por stdio.
Última comprobación: 2026-10-28. Generate, edit and save Xfer Serum 2 presets from natural language, over MCP