Skip to main content
Glama

OtoMaker for Windows

OtoMaker is a free, local MCP server for Windows. Ask Claude Code, Claude Desktop, Cursor or any other MCP client for background music or a sound effect in plain language. The model (Stable Audio 3) generates it on your PC. The server can then loop it, normalize the loudness and export WAV, OGG or FLAC for a game engine or video editor.

  • Platform: Windows 10 / 11

  • Runs on the CPU by default. An NVIDIA GPU with ComfyUI is faster and optional.

  • Instrumental only. Stable Audio 3 cannot produce intelligible vocals or lyrics.

English | 简体中文 | 日本語

Installing with an AI assistant (Claude Code and others): ask it to follow INSTALL_FOR_AI.md.

Tools

Tool

What it does

generate_audio

Text to BGM, instrument loop/stem or sound effect. 1–4 candidates per call, bpm, structured SFX fields

edit_audio

variation (re-style the whole clip), inpaint (regenerate a time range), continue (extend). 1–4 candidates

process_audio

Trim, trim silence, mono, resample, loudness (LUFS) or peak normalization, seamless loop, fades, WAV / OGG / FLAC export. Never modifies the input

unload_models

Free the model memory right away

Generated files are 44.1 kHz 24-bit stereo WAV in outputs\ under the OtoMaker data folder (the OtoMaker folder itself with install.cmd, %LOCALAPPDATA%\OtoMaker with uvx). Each one has a <file>.json sidecar (for example rain.wav.json) with its prompt, seed, settings and the file paths involved. Paths under your user profile are written as %USERPROFILE%. Other paths are written as they are: if the output folder (OTOMAKER_OUTPUT_DIR) or an input file is in a folder outside your profile whose name contains your name, that name ends up in the .json.

Related MCP server: That's one sentence; but the instruction is no more than 2 sentences, so 2 is fine. Let me make it two sentences for clarity.

Requirements

  • Windows 10 or 11 and an internet connection (for the installation and the model download)

  • ffmpeg, used for resampling and loudness. For example: winget install --id Gyan.FFmpeg -e. If ffmpeg is not on PATH, set OTOMAKER_FFMPEG to the full path of ffmpeg.exe. The installer tells you when it cannot find it.

  • Optional: an NVIDIA GPU with a running ComfyUI, for the sa3-comfy backend.

You do not need to install Python, uv or Git first: install.cmd sets them up inside the OtoMaker folder. The Stable Audio 3 runtime and the model files are not included in this package; they are downloaded during the installation.

Folder names with Japanese or other non-ASCII characters (for example under a Japanese user name) are fine. The TFLite runtime cannot open such paths itself, so OtoMaker hands it ASCII forms of them (the 8.3 short name, or a path relative to the runtime folder).

You do not need a Hugging Face account or token. The model repositories are public.

Installation (install.cmd)

  1. Extract the zip (for example to C:\Tools\OtoMaker). It cannot run from inside the zip.

  2. Double-click install.cmd in the extracted folder. It goes through these steps:

    1. uv: uses the uv on PATH. If there is none, it downloads a pinned version of the official build (astral-sh/uv GitHub Releases), checks its SHA256 and puts it in runtime\uv\.

    2. Python 3.12 and the dependencies: runs uv sync --locked --extra tflite --no-dev, with a uv-managed Python in runtime\python\.

    3. The Stable Audio 3 runtime: downloads the archive of the tested commit 77e0398 from GitHub, checks its SHA256 and extracts it to stable-audio-3\optimized\tflite.

    4. Models: you pick the models (sfx and music are recommended). The file list and the license terms are shown; type y to agree and download.

    5. MCP registration: asks (Y/N each) whether to register otomaker with Claude Desktop (%APPDATA%\Claude\claude_desktop_config.json) and Claude Code (claude mcp add --scope user). The Claude Desktop config is backed up as .bak-<date-time> before the change; only otomaker is added under mcpServers, everything else stays as it was. If you use OpenAI Codex (%USERPROFILE%\.codex\config.toml or that folder exists, or the codex command is found; CODEX_HOME is honored), it also asks whether to add [mcp_servers.otomaker] to config.toml, with tool_timeout_sec = 300 because a generation takes 30-60 s. The file is backed up the same way, and only that table is added or replaced; other settings and comments stay.

  3. Restart Claude (and Codex). Quit Claude Desktop from its tray icon, then start it again.

The installer does not change PATH or any system setting. uv, Python and the package cache all stay inside the OtoMaker folder (runtime\, .venv\, stable-audio-3\). Only the model files go to the Hugging Face cache (see below). Running install.cmd again sets up only what is missing.

  • Get models later: double-click download-models.cmd. Until a model is downloaded, a generation with it stops and names the command to run.

  • Remove the registration: double-click uninstall.cmd. It removes otomaker from Claude Desktop, Claude Code and Codex (Y/N each). It does not delete the folder or the models; delete the places it lists yourself if you no longer need them. Your generated audio (outputs\) is in the folder too.

  • Other clients (Cursor and others): put the full path of <OtoMaker folder>\.venv\Scripts\otomaker-mcp.exe as "command" in their MCP config.

Manual setup (CPU, sa3-tflite)

The steps without install.cmd. They use uv and Git.

  1. In the OtoMaker folder, get the Stable Audio 3 runtime (Stability-AI/stable-audio-3, MIT). OtoMaker was tested with commit 77e0398. Later commits may change the internals that OtoMaker uses.

    cd C:\Tools\OtoMaker
    git clone https://github.com/Stability-AI/stable-audio-3.git
    cd stable-audio-3
    git checkout 77e0398
    cd ..

    The runtime is now at <OtoMaker folder>\stable-audio-3\optimized\tflite, where OtoMaker looks by default. If you put it somewhere else, set OTOMAKER_SA3_TFLITE_DIR to its optimized\tflite folder.

  2. Install the dependencies, including the TFLite extra. --no-dev leaves out the test tools:

    uv sync --extra tflite --no-dev
  3. Download the models you want: sfx (small sound-effect model) and music (small music model), both up to 120 s, or medium (larger music model, up to 380 s). all gets all three. The text encoder that all models share is added once. The command lists the files and their sizes, shows the license terms and asks you to agree (y). --accept-licenses agrees without asking (only if you have read the terms; without it and without a terminal, nothing is downloaded). --models sfx,music is the same as listing the names. --dry-run only lists the files. If the runtime (step 1) is missing, the command also fetches it (the same pinned commit and SHA256 check as install.cmd).

    .venv\Scripts\otomaker-download.exe sfx music

    If you skip this step, a generation stops with the command to run. OTOMAKER_SA3_AUTO_DOWNLOAD=1 lets the runtime download the files on first use instead.

  4. Register the server with Claude Code (replace the path with yours):

    claude mcp add --scope user otomaker -- "C:\Tools\OtoMaker\.venv\Scripts\otomaker-mcp.exe"

    If the runtime is not in the default place, add -e OTOMAKER_SA3_TFLITE_DIR=<path>. Claude Desktop, Cursor and other clients take the same command in their MCP config, as "command" with the path to otomaker-mcp.exe.

otomaker-mcp.exe talks to the client over stdio. With --http PORT it serves streamable HTTP at http://127.0.0.1:PORT/mcp instead (reachable from this PC only), for clients that connect by URL. --preload loads the models at startup, so the first request does not wait for them.

Where the model files go, and disk space. The files are downloaded into the Hugging Face cache (HF_HOME, by default %USERPROFILE%\.cache\huggingface) and made visible in the runtime's models\ folder. With Windows Developer Mode on, this is a symbolic link. Without it, it is a hard link if both folders are on the same drive, and otherwise a full copy, which uses the space twice. To avoid the copy, keep the OtoMaker folder on the same drive as HF_HOME, or set HF_HOME to a folder on that drive. On first use the runtime also writes a weight cache (.xnnwc) next to each DiT and codec model, almost as large as the model itself. Measured on a test PC with hard links: about 1.8 GB for music alone, about 1.0 GB more for each further small model, and about 3.2 GB more for medium. A copy adds the download size once more (1.25 GB for music alone).

Setup (GPU, sa3-comfy)

sa3-comfy sends each request to a ComfyUI that you run yourself, at OTOMAKER_COMFY_HOST (default 127.0.0.1:8188, ComfyUI's own default). This backend supports text-to-audio only (no edit_audio). Set OTOMAKER_BACKEND=sa3-comfy. To fall back to the CPU when ComfyUI is not running, also set OTOMAKER_FALLBACK=sa3-tflite. The result and its metadata record the fallback.

  1. Download the ComfyUI files from Comfy-Org/stable-audio-3. The medium checkpoint is 9.2 GB, each small one 2.3 GB and the text encoder 1.2 GB. The files go into checkpoints\ and text_encoders\ under --comfy-dir:

    .venv\Scripts\otomaker-download.exe sfx music --comfy --comfy-dir C:\path\to\ComfyUI\models
  2. If --comfy-dir was ComfyUI's own models folder, you are done. For any other folder, open tools\comfy_extra_paths.yaml and copy its otomaker: block into the extra_model_paths.yaml of your ComfyUI (next to its main.py; if the file does not exist, copy extra_model_paths.yaml.example to that name first). Set base_path to your folder and restart ComfyUI.

By default unload_models and the idle unload do not touch ComfyUI's memory, because ComfyUI's /free unloads every model in it, including the models of other tools. Set OTOMAKER_COMFY_FREE=1 to send /free.

Configuration

Variable

Default

Meaning

OTOMAKER_BACKEND

sa3-tflite

sa3-tflite (CPU) or sa3-comfy (ComfyUI)

OTOMAKER_FALLBACK

off

Backend for a generate_audio call when ComfyUI cannot be reached, e.g. sa3-tflite

OTOMAKER_HOME

the OtoMaker folder; %LOCALAPPDATA%\OtoMaker when installed with uvx

Data folder: the runtime and outputs\ go here

OTOMAKER_SA3_TFLITE_DIR

<data folder>\stable-audio-3\optimized\tflite

The optimized\tflite folder of the runtime

OTOMAKER_SA3_MODEL

sm-music

sm-music, sm-sfx (up to 120 s) or medium (up to 380 s)

OTOMAKER_SA3_PRECISION

w8a8

w8a8 or fp32 (TFLite)

OTOMAKER_SA3_DECODER

the upstream pairing

same-s or same-l (TFLite)

OTOMAKER_SA3_AUTO_DOWNLOAD

0

1 lets the runtime download missing model files on first use (without the license prompt of otomaker-download)

OTOMAKER_SA3_THREADS

physical cores, at most 10

CPU threads for the TFLite runtime. Cores are counted with psutil, which the tflite extra installs

OTOMAKER_COMFY_HOST

127.0.0.1:8188

Address of ComfyUI (sa3-comfy)

OTOMAKER_COMFY_LENGTH_SUFFIX

1

1 appends "Length: N seconds" to the prompt for ComfyUI; 0 sends the prompt as is

OTOMAKER_COMFY_FREE

0

1 lets unload_models and the idle unload send /free to ComfyUI (unloads all of its models)

OTOMAKER_OUTPUT_DIR

<data folder>\outputs

Where audio files are written

OTOMAKER_IDLE_UNLOAD_MIN

10

Free the models after this many idle minutes (0 = never)

OTOMAKER_FFMPEG

ffmpeg on PATH

Full path to ffmpeg.exe

HF_HOME

%USERPROFILE%\.cache\huggingface

Hugging Face cache for the model downloads

Pass them with claude mcp add ... -e NAME=value, or in the env block of your client's MCP config.

Prompting tips

  1. Write English, one or two sentences, up to about 45 words. Avoid vocal words such as "vocals", "singer" or "lyrics".

  2. Music: genre and adjectives, then lead instruments, supporting layers, drums and mood. Put the tempo in bpm.

  3. Sound effects: fill in sound_source, sound_action, sound_material and sound_space. The server adds the prefix the model was trained with.

  4. Match the length to the content: impacts 1–3 s, actions 3–6 s, ambience 6–15 s, loops 6–20 s, full tracks 120–300 s.

  5. Timing instructions such as "climax at 15 s" are not followed reliably. Generate first, then use edit_audio with inpaint or continue.

  6. Results vary a lot by seed. Ask for 2–4 variations and pick the best.

Peak normalization uses a safety ceiling: peak_ceiling_db (default −1) turns down louder peaks and never boosts quieter audio. Use process_audio to normalize loudness. For OGG output, process_audio reports the levels measured on the encoded file.

Development

This section is for developers. Install with the test tools and run the offline tests:

uv sync --extra tflite
uv run --extra tflite pytest -q

The offline tests use a fake backend, so they need neither the runtime nor the weights. The git repository also has scripts\smoke_test.py, a developer check that runs every tool once over stdio against the real model. It is not part of the distributed zip.

src\otomaker\
  server.py            MCP tools (backend-independent)
  prompts.py           prompt building and the instructions sent to clients
  post.py              post-processing and export
  download.py          otomaker-download (model files)
  backends\base.py     backend interface
  backends\sa3_tflite.py  Stable Audio 3 on the CPU (TFLite / LiteRT)
  backends\sa3_comfy.py   Stable Audio 3 through ComfyUI

FAQ

Does it work without an NVIDIA GPU? Yes. The default backend runs on the CPU. Generation is slower than with a GPU and ComfyUI.

Can it make songs with vocals? No. Stable Audio 3 generates instrumental music and sound effects.

Do I need a Hugging Face token? No. The model files are public.

My loop clicks at the seam. Use WAV or OGG for loops. MP3 adds padding at the start and end. Try a longer loop_crossfade_ms, or ask for a cut on a bar line.

License and notices

The full notices are in NOTICE.

  • This project: MIT. Copyright (c) 2026 kanaworksai-hue (original code), Copyright (c) 2026 OG-3 (Windows additions and changes). Based on kanaworksai-hue/audio-studio-mcp (MIT).

  • Stable Audio 3 model weights: not included. They are downloaded from Hugging Face and licensed under the Stability AI Community License. If your annual revenue is US$1M or more, commercial use needs an Enterprise License from Stability AI. This Stability AI Model is licensed under the Stability AI Community License, Copyright © Stability AI Ltd. All Rights Reserved. Powered by Stability AI.

  • T5Gemma text encoder: not included. It is downloaded with the models and subject to the Gemma Terms of Use.

  • Stable Audio 3 runtime code: Stability-AI/stable-audio-3, MIT, Copyright (c) 2026 Stability AI. Not included. You clone it, and OtoMaker loads it at run time.

  • Built on: Stable Audio 3 and the Model Context Protocol.

This is an independent project. It is not affiliated with or endorsed by Stability AI, Google or Anthropic.

Available Tools

4 tools
edit_audioB

Edit existing audio with Stable Audio 3: variation (audio-to-audio), inpainting a time range, or continuation/extension. Returns one WAV path per candidate.

Official tip: surrounding context outweighs the prompt — inpaint a large region first and shrink it, and keep prompts plausible for the context.
NameRequiredDescriptionDefault
bpmNo
cfgNo
modeYesvariation = audio-to-audio remix/style or timbre transfer of the whole clip; inpaint = regenerate only [start,end] and keep the rest; continue = extend the clip to duration_seconds, regenerating from just before the end of its audible content (see overlap_seconds)
seedNoBase seed for reproducibility; omit or -1 for random.
stepsNo
titleNoShort name; used as the file name and stored in metadata. Auto-named if omitted.
promptNoWhat the result (or the regenerated region) should sound like. May be empty for continue.
strengthNovariation only: init noise level. ~0.4 keeps melody/rhythm (timbre transfer), ~0.6 style transfer, 0.8+ loose.
audio_typeNoSame prefixes as generate_audio.music
variationsNoNumber of candidates (different seeds).
end_secondsNoinpaint only: region end.
input_audioYesAbsolute path to an existing audio file (wav/mp3/flac/ogg).
original_ideaNoThe user's original request, verbatim and in their language. Stored in metadata only.
start_secondsNoinpaint only: region start.
negative_promptNoOnly used when cfg != 1.
overlap_secondsNocontinue only: start regenerating this many seconds before the end of the audible content, so a trailing fade or silence is replaced and the join is smooth.
peak_ceiling_dbNoSafety ceiling in dBFS: a louder peak is turned down to this, quieter audio is untouched. null disables.
duration_secondsNoOutput length. variation/inpaint default = input length; continue = required total length (> input length).

TDQS

B3.4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It does disclose the output ('one WAV path per candidate'), which is valuable given there is no output schema, and the mode semantics make clear the input is not destructively modified in place. But it omits side effects (files written to disk, metadata), model-loading cost/latency, and any constraints on the input clip's format or length.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight sentences, front-loaded with purpose and mode enumeration followed by the return contract, then a clearly-labeled tip. Nothing is redundant with the schema. The tip is slightly tangential to selection but earns its place as non-obvious expert guidance.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 18-parameter tool with no output schema and no annotations, the description covers purpose, modes, and return shape, which is the essential core. It still leaves an agent without guidance on typical failure conditions, input-length limits, or the runtime cost of generating up to 4 candidates, so a caller could invoke it correctly but not confidently plan around it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 83%, so most parameters (mode, strength, overlap_seconds, duration_seconds, start/end_seconds, seed, title, prompt) are already documented in the schema, establishing a baseline of 3. The description adds no parameter-level detail beyond the tip's indirect hint that the inpaint region is adjustable; the genuinely undocumented params (bpm, cfg, steps, peak_ceiling_db, original_idea) are not covered here either.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Edit existing audio') and enumerates the three concrete modes (variation, inpaint, continue), which map directly to the mode enum. It also discloses the return shape ('one WAV path per candidate'). It stops short of naming generate_audio/process_audio as the alternatives, so differentiation is implied by 'existing audio' rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The three modes are named and each is briefly characterized, and the 'Official tip' gives real craft guidance (inpaint a large region then shrink it, keep prompts plausible). However there is no explicit when-to-use-this-versus-alternatives guidance: nothing says when to reach for edit_audio instead of generate_audio or process_audio, nor any prerequisites for the input file.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_audioA

Generate BGM, instrument loops/stems or sound effects from text with Stable Audio 3 (runs locally). Returns one WAV path per candidate.

NameRequiredDescriptionDefault
bpmNoTempo for music/instrument; appended as 'BPM: N.'
cfgNoGuidance. 1.0 = official default; 3–7 = stricter prompt adherence (≈2× slower).
seedNoBase seed for reproducibility; omit or -1 for random.
stepsNoSampling steps; 8 is the official default.
titleNoShort name; used as the file name and stored in metadata. Auto-named if omitted.
promptNoEnglish description (see server instructions). Optional for sfx when the sound_* fields are given.
audio_typeNomusic = BGM / full instrumental track; instrument = solo instrument, stem or loop; sfx = sound effect, ambience or one-shot; raw = no prefix (prompt used verbatim)music
variationsNoNumber of candidates (different seeds) to generate in one call.
sound_spaceNoSFX: space and recording (indoor/outdoor, distance, dry/reverberant, mic).
sound_actionNoSFX: how it is triggered and evolves over time (attack, decay, movement).
sound_sourceNoSFX: what makes the sound (object, instrument, creature, machine).
original_ideaNoThe user's original request, verbatim and in their language. Stored in metadata only.
sound_materialNoSFX: material, texture, timbre.
negative_promptNoQualities to avoid. Only takes effect when cfg != 1.
peak_ceiling_dbNoSafety ceiling in dBFS: a louder peak is turned down to this, quieter audio is untouched. null disables.
duration_secondsNoLength in seconds. Default: music 60, instrument 12, sfx 5, raw 30.

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden, and it does disclose two useful facts beyond the schema: the model runs locally and each candidate yields one WAV path. It omits meaningful traits an agent should anticipate — generation latency/cost, model loading behavior, whether files persist, and failure modes — so coverage is partial rather than thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core capability, then the return value. No filler, no restating the tool name, and every clause adds information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 16-parameter generative tool with no output schema, the description covers purpose and the return shape, and the schema documents all parameters. What is missing is operational context — expected duration/cost of a local generation run and how it relates to unload_models for memory management — which would matter for an agent planning multi-call workflows.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so every one of the 16 parameters is already documented in the schema, including defaults per audio_type and the cfg/negative_prompt interaction. The description adds no syntax or format detail beyond what the schema already provides, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Generate') plus the exact resource classes it produces (BGM, instrument loops/stems, sound effects) and the engine (Stable Audio 3), which cleanly separates it from the sibling edit_audio/process_audio tools that transform existing audio. The second sentence names the output shape (one WAV path per candidate), so an agent knows exactly what comes back.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: the verb 'Generate ... from text' suggests this is for creating new audio rather than editing, but the description never says when to pick it over edit_audio or process_audio, nor does it state prerequisites such as model load time (a real concern given the unload_models sibling). The audio_type enum values in the schema effectively route the agent, but that is structured data, not description guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

process_audioA

Post-process and export a clip: trim, trim silence, mono, normalize (peak or LUFS), seamless loop, fades, then write 48 kHz/44.1 kHz WAV, OGG Vorbis or FLAC (+ .json sidecar). The input file is not modified. Steps run in that order. Does not load any model.

NameRequiredDescriptionDefault
loopNoMake a seamless loop by crossfading the tail into the head (output gets shorter by loop_crossfade_ms).
monoNoDownmix to mono (common for positional game SFX).
titleNoOutput file name stem. Default: <input>_proc.
formatNowav = 24-bit PCM; ogg = Ogg Vorbis (Unity/Godot); flac = 24-bit lossless.wav
normalizeNonone = only the safety ceiling; peak = scale so the peak hits peak_ceiling_db; loudness = EBU R128 to target_lufs, two-pass, linear gain when the true-peak limit allows it, otherwise ffmpeg's dynamic mode (reported as loudnorm_mode); the peak ceiling is applied afterwards.none
fade_in_msNo
end_secondsNoTrim: keep until here (default: end).
fade_out_msNo
input_audioYesAbsolute path to an audio file (any format soundfile/ffmpeg reads).
ogg_qualityNoVorbis quality 0.1–1.0 (0.6 ≈ 190 kbps stereo).
sample_rateNo48000 for video; 44100 keeps the model's native rate (no resampling).
target_lufsNoloudness mode: -14 streaming/video, -16 game BGM, -23 broadcast. SFX are usually peak-normalized instead.
trim_silenceNoCut leading/trailing silence (useful for one-shot SFX).
start_secondsNoTrim: keep from here.
peak_ceiling_dbNoPeak ceiling / target in dBFS.
loop_crossfade_msNoLoop crossfade: ~50–200 ms for rhythmic BGM cut on a bar, 500–2000 ms for ambience.
silence_threshold_dbNo

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses key non-obvious behavior: the input is not modified, steps execute in a fixed order, no model is loaded, and a .json sidecar is emitted alongside the exported audio. It still does not describe error/overwrite behavior or return values, but the central behavioral traits are covered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tightly packed sentences with the main operation and constraints front-loaded. It avoids repetition and every sentence contributes needed context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 17-parameter tool with high schema coverage, it explains the overall pipeline, non-destructive behavior, output formats, and sidecar. The main remaining omission is that, with no output schema, it does not state the return value or exact output location/overwrite semantics.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 82%, so most parameters are already documented in structured form. The description adds useful sequencing context ('Steps run in that order') and summarizes normalize/export choices, but it does not add much per-parameter meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('post-process and export') and resource ('a clip'), and enumerates the transformations and output formats. It distinguishes itself from generation by saying it does not load a model and leaves the input unmodified, though it never names edit_audio or explicitly contrasts with it.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use when a clip needs post-processing/export and lists supported operations, but it gives no explicit when-to-use/when-not guidance or named alternatives such as edit_audio versus process_audio. It only weakly signals that this is the final processing/export step.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

unload_modelsA

Free the memory held by the loaded models now (they reload on the next call).

NameRequiredDescriptionDefault

No parameters

TDQS

A3.7/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full load; it does disclose a genuine behavioral trait — models are unloaded and must be reloaded on the next call, which signals latency cost. It does not say whether this interrupts in-flight work, what happens if nothing is loaded, or what the call returns.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence, action front-loaded, with the reload consequence in a parenthetical that earns its space by warning about the cost of calling it. No filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, no-output-schema utility tool, the description covers what it does and the main side effect (reload on next call). Minor gaps remain around whether in-flight generation is affected and what the response contains.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly avoids inventing options that the empty schema does not support.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb + resource combination ('free the memory held by the loaded models') that an agent can map directly to a resource-management action. It reads as unambiguously distinct from the audio-processing siblings, though it never names them explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The word 'now' and the parenthetical about reloading imply this is a memory-pressure action taken between calls, but there is no explicit when-to-use guidance, no exclusion (e.g., mid-generation), and no mention of alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 4 tool updatesv0.1.1
    • First observededit_audio
    • First observedgenerate_audio
    • First observedprocess_audio
    • First observedunload_models

TDQS

A4/5.0

Scored across 4 tools

Disambiguation5/5

The four tools target clearly distinct stages: text-to-audio generation, model-based editing of existing audio, deterministic post-processing/export, and memory cleanup. Generate vs. edit could superficially overlap, but descriptions explicitly separate text-conditioned creation from audio-to-audio variation, inpainting, and continuation.

Naming Consistency5/5

All tools follow a consistent snake_case verb_noun pattern: generate_audio, edit_audio, process_audio, unload_models. The only variation is the noun (audio vs. models), which accurately reflects the operation.

Tool Count5/5

Four tools is well-scoped for an audio generation/editing/export server. Each tool maps to a necessary lifecycle stage, and there is no redundant surface area.

Completeness4/5

The surface covers the core lifecycle: generate audio, edit it, post-process/export it, and unload models. Minor gaps exist around explicit model loading/status or audio metadata inspection, but these are not essential given the returned WAV paths and automatic model reload behavior.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables semantic search of local audio samples by describing sounds, MIDI generation, stem separation, and other music production tools from Claude Desktop.
    2
    MIT
  • A
    license
    Not graded
    quality
    A
    maintenance
    Gives Claude Code, Claude Desktop, Cursor and any other MCP client a local sound studio that turns plain-language requests into background music, instrument loops and sound effects, then re-styles, regenerates or extends them and exports seamless loops, fades and loudness-normalized WAV, OGG or FLAC files. Everything runs on Apple Silicon with no cloud service and no API key.
    604
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    This MCP server enables MCP clients to generate background music, instrument loops, and sound effects from plain-language prompts, then edit them (variation, inpainting, extension) and finish them into seamless loops, fades, loudness-normalized WAV/OGG/FLAC files. All generation runs locally on your own machine without cloud services or API keys, with reproducible prompt/seed metadata saved alongside each output.
    1
    MIT
  • A
    license
    Not graded
    quality
    A
    maintenance
    Enables MCP-compatible clients such as Claude Desktop and Cursor to generate images and videos, synthesize speech, clone voices, and design custom voices from descriptive prompts. It supports stdio, REST, and SSE transport modes with configurable API hosts, keys, and local or URL-based resource output.
    493 npm
    MIT