Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@lyrics-mcp Write a wistful indie folk song about a rainy night drive, in English"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that writes original song lyrics with Claude.
Give it a brief, get back a title and a full set of lyrics marked up with English
section tags — [Verse], [Pre-Chorus], [Chorus], [Bridge], [Outro] — that stay
English whatever language the lyrics themselves are in. That is the format music
generation models expect, so the output pastes straight in.
Bring your own Anthropic API key. There is no hosted service behind this: the server runs on your machine, calls the Anthropic API with your credentials, and sends nothing anywhere else.
There is nothing to install. Add this to your MCP client's config — for Claude Code,
.mcp.json in your project root:
{
"mcpServers": {
"lyrics": {
"command": "uvx",
"args": ["--from", "git+https://github.com/musegen/lyrics-mcp.git", "lyrics-mcp"],
"env": {
"ANTHROPIC_API_KEY": "sk-ant-..."
}
}
}
}Restart your client and ask it to write you a song.
This needs uv, which builds the server in a throwaway
environment on first launch and handles Python for you. If you would rather not put
your key in the config file, drop the env block and export ANTHROPIC_API_KEY in
the environment your client launches from.
Related MCP server: suno-mcp
Installed on your PATH. Python 3.10 or newer:
pip install git+https://github.com/musegen/lyrics-mcp.git{
"mcpServers": {
"lyrics": {
"command": "lyrics-mcp",
"env": { "ANTHROPIC_API_KEY": "sk-ant-..." }
}
}
}Note that command is resolved against the PATH your MCP client sees, which is not
always the shell you installed from — a virtualenv or a --user install often lands
somewhere the client cannot find. If the server fails to start, use the absolute path
to the lyrics-mcp executable, or go back to uvx.
From a clone, for hacking on it:
{
"mcpServers": {
"lyrics": {
"command": "python",
"args": ["-m", "lyrics_mcp.server"],
"cwd": "/path/to/lyrics-mcp",
"env": { "PYTHONPATH": "src", "ANTHROPIC_API_KEY": "sk-ant-..." }
}
}
}write_lyrics — one required argument, four optional ones.
Argument | Required | Description |
| yes | What the song is about. Concrete imagery beats abstraction: "walking home alone through a quiet city after a late shift" gets a much better song than "a sad song". |
| no | Language for the lyrics ( |
| no |
|
| no |
|
| no |
|
Returns {"title": ..., "lyrics": ...}.
Everything is an environment variable. Only the first one is required.
Variable | Default | Purpose |
| — | Your API key. The Anthropic SDK also accepts |
| Anthropic API | Point the SDK at a gateway or proxy. |
|
| Which model writes the lyrics. |
|
| Where a declined request is retried (see below). Set to empty to disable. |
|
| Requests per minute this process will make. |
LYRICS_MCP_RPM is a token bucket over this process's API calls. It exists because an
agent that gets stuck in a loop on this tool can spend a lot of your money quickly, and
ten calls a minute is more than any human songwriting session needs.
It is not a security control. It lives in the process, so it caps your own runaway loops and nothing else — every user runs their own copy and spends their own money.
Safety classifiers sometimes decline a request, which is a real possibility for lyrics
about grief, violence or addiction. By default the server enables server-side fallbacks,
so a declined request is re-run on LYRICS_MCP_FALLBACK_MODEL inside the same API call
and you usually never notice. If the whole chain declines, you get a clear error, and
softening the wording of the brief normally gets a result.
Gateways that have not adopted the fallback beta will reject it; the server notices, logs a line to stderr, and carries on without it.
Every call is billed to your key at your model's rates. A song is typically a few
thousand output tokens. Check Anthropic's pricing
for the current numbers, and set LYRICS_MCP_MODEL to a smaller model if you would
rather trade some quality for cost.
smoke_test.py checks prompt assembly, output parsing, the rate limiter and the tool
schema. It needs no API key and makes no network calls:
pip install -e .
python smoke_test.pyMIT — see LICENSE.
Write a complete set of original song lyrics from a creative brief. Returns a title and a body marked up with English section tags ([Verse], [Pre-Chorus], [Chorus], [Bridge], [Outro]) that stay English whatever language the lyrics are in, ready to paste into a music-generation model.
| Name | Required | Description | Default |
|---|---|---|---|
| mood | No | Emotional register, e.g. 'wistful but hopeful', 'defiant'. | |
| brief | Yes | What the song is about. The more concrete the imagery, the better the result -- 'walking home alone through a quiet city after a late shift' beats 'a sad song'. Narrative point of view and specific details belong here too. | |
| genre | No | Musical genre, e.g. 'indie folk', 'synth pop', 'trap'. | |
| language | No | Language for the lyrics, e.g. 'English', 'Chinese', 'Japanese'. Leave empty to follow the brief's own language. Section tags stay English regardless. | |
| structure | No | Song structure, e.g. 'ABABCB' or 'Verse/Chorus/Verse/Chorus/Bridge/Chorus'. Leave empty to let the model pick one that fits the emotion. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It adds useful context by specifying that section tags stay English regardless of lyric language and that the output is ready to paste into a music-generation model. However, it does not disclose potential limitations, such as length constraints or behavior when the brief is too vague.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, information-dense sentence. It front-loads the core purpose, then adds only high-value details about the output format and intended downstream use, with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers what the tool does, the required input, the output structure, the language-agnostic behavior of section tags, and the intended use case. Since an output schema exists for structured return details, the description is complete enough for an agent to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description reinforces that 'brief' is the central creative input but does not add parameter-specific meaning beyond what the schema already documents. No deduction is warranted because the schema fully covers parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Write'), a concrete resource ('original song lyrics'), and a clear input ('from a creative brief'). It also describes the output format (title plus section-tagged body), making the tool's function unambiguous even without sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly conveys when to use the tool: whenever a complete set of original lyrics is wanted from a creative brief. It does not list exclusions or alternatives, but no sibling tools exist and the context is clear enough to select the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0write_lyricsScored across 1 tool
With only one tool, there is zero ambiguity between tools. The single tool's purpose is clearly defined and self-contained.
The sole tool name, write_lyrics, follows a clear verb_noun pattern. While there is no broader set to compare against, the name is descriptive and internally consistent.
A single tool feels thin for a domain like lyrics, but it is focused on one concrete action: generating complete lyrics. It is not an extreme mismatch, just minimal.
The tool covers the core workflow of generating original lyrics with structure tags, which fully addresses the server's apparent purpose. Minor gaps exist, such as no separate editing or variation tools, but these are workable around.
Write lyrics in 100+ styles, score them, generate full songs with 4 engines, split stems. OAuth.
AI music studio: song generation with vocals, covers, stems, voice conversion, mastering, editing.
Make a finished AI song with real vocals from a brief, or search and stream StarSinger's AI catalog
Generate Suno AI music (v5.5) from any MCP client. Async; billed only on success.
