supertone-mcp
OfficialThe supertone-mcp server provides a full-featured interface to the Supertone TTS API, enabling speech synthesis, voice management, and custom voice cloning from MCP-compatible clients.
Text-to-Speech Synthesis: Convert text into natural-sounding audio across 23+ languages, with support for speed (0.5x–2.0x), pitch shift (-24 to +24 semitones), emotion styles, and MP3/WAV output. Audio can be saved to disk, returned as MCP resources, or both. Long text is auto-chunked beyond the 300-character limit.
Duration & Cost Prediction: Estimate output audio duration and credit cost before synthesizing, using the same parameters as synthesis.
Voice Catalog Search: Browse and filter Supertone's preset voice catalog by language, gender, age, use case, style, model, name, or description.
Voice Details & Previews: Retrieve full metadata for a specific voice and access sample audio URLs, optionally filtered by language, style, and model.
Credit Balance Check: Monitor the remaining API credit balance for your Supertone API key.
Voice Cloning: Create a custom cloned voice from a local WAV or MP3 file (max 3MB), immediately usable for synthesis.
Custom Voice Management: List/filter cloned voices, update their name or description, or permanently delete them.
supertone-mcp
⚠️ Service Discontinuation Notice
The Supertone API will be permanently shut down on August 31, 2026. After this date, all API requests will stop being served and this package will no longer work.
👉 For the full timeline, refund policy, and details, see the End-of-Life Guide.
A composable MCP toolkit for the Supertone TTS API. Rather than a single "speak this text" command, it exposes Supertone's SDK as a set of building-block tools — synthesis, voice discovery, preview, duration/credit prediction, usage tracking, and full voice-cloning CRUD — that an LLM assembles to fulfill a request. Works in Claude Desktop, Cursor, or any MCP-compatible client.
Covers Korean, English, Japanese, and 31 languages total. Speed (0.5x–2.0x), pitch shift (-24 to +24 semitones), emotion styles, per-call output mode, streaming, and model selection.
Related MCP server: FlowSpeech MCP Server
Features
Synthesis
text_to_speech— Convert text to audio. Per-call control ofoutput_mode(files / resources / both),autoplay,streaming,model, plusinclude_phonemes/normalized_text. Long text is auto-chunked by the SDK.predict_duration— Estimate audio length (and credit cost) without synthesizing.
Voice discovery (preset)
search_voice— Filter the catalog by language, gender, age, use_case, style, model, name, or description.get_voice— Full detail for one voice.preview_voice— Sample audio URLs for a voice (filterable by language/style/model).
Custom voice cloning
clone_voice— Create a cloned voice from a local WAV/MP3 (≤3MB).search_custom_voice— List/filter cloned voices.get_custom_voice— Full detail for one cloned voice.edit_custom_voice— Update name and/or description.delete_custom_voice— Permanently delete (irreversible).
Audio assembly
merge_audio_files— Concatenate two or more local audio files (mp3/wav) into one via a bundled ffmpeg. Supports plain concat, silence gaps between clips (gap_ms), or crossfade blending (crossfade_ms). Output format auto-detected (mixed → mp3) or forced viaoutput_format. No system ffmpeg required.
Usage & credits
get_credit_balance— Remaining credits.get_usage_history— Usage over a time window.get_voice_usage— Usage for a specific voice.
Breaking changes & migration (0.2.0)
0.2.0 moves behavior control out of environment variables and into per-call tool parameters — so the LLM decides per request, not the server config.
Before (env var) | After (per-call parameter) | Note |
|
| Default still |
|
| Default changed |
(always streamed) |
| New, default |
Other changes:
Default model changed
sona_speech_1→sona_speech_2_flash.list_voiceswas removed (since the discovery release) and replaced bysearch_voice— call it with no arguments to reproduce the old "list everything" behavior.No more hard 300-character limit — longer text is auto-chunked by the SDK (credit/latency scale with length).
If you previously set SUPERTONE_MCP_OUTPUT_MODE or SUPERTONE_MCP_AUTOPLAY, remove them from your client config and pass output_mode / autoplay per call instead. (The server prints a one-time stderr notice if it sees the removed vars.)
Installation
# Using uvx (recommended)
uvx supertone-mcp
# Using pip
pip install supertone-mcpConfiguration
Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"supertone-tts": {
"command": "uvx",
"args": ["supertone-mcp"],
"env": {
"SUPERTONE_API_KEY": "your-api-key-here"
}
}
}
}Cursor
Add to your Cursor MCP settings (same JSON shape as above).
Environment Variables
Only authentication and stable defaults are configured via the environment — all behavior is controlled per call.
Variable | Required | Default | Description |
| Yes | — | Your Supertone API key |
| No | preset voice (Aiden, multilingual) | Default |
| No |
| Directory where audio files are saved (used by |
Removed in 0.2.0:
SUPERTONE_MCP_OUTPUT_MODEandSUPERTONE_MCP_AUTOPLAY— see Migration.
Output modes (text_to_speech output_mode)
Mode | Returns | Use when |
| Plain text with the saved file path + metadata | You want the file on disk |
| MCP | The client renders audio inline (e.g., Claude.ai chat) |
| File on disk and | You want both — preview inline, keep the file |
Usage Examples
The MCP client routes natural-language requests across these tools — the value of the toolkit is composition: the LLM chains several tools to satisfy one request.
Example 1 — Discover → preview → estimate cost → synthesize
"Find a calm Korean female voice, let me hear a sample, check the cost, then make this announcement as an mp3."
The LLM assembles:
search_voice(language="ko", gender="female", style="neutral") # find candidates
→ preview_voice(voice_id) # sample URLs to confirm the voice
→ predict_duration(text, voice_id) + get_credit_balance() # gauge cost before spending
→ text_to_speech(text, voice_id, output_format="mp3",
output_mode="files") # synthesizeExample 2 — Clone my voice → use it right away
"Make a cloned voice from ~/recordings/sample.wav named MyVoice, then read this greeting with it and play it for me."
The LLM assembles:
clone_voice(name="MyVoice", audio_path="~/recordings/sample.wav") # create the cloned voice
→ get_custom_voice(voice_id) # confirm it was created
→ text_to_speech(text, voice_id=<cloned>, autoplay=true) # synthesize, then play immediately
autoplayis a per-call parameter (defaultfalse), so playback happens only when explicitly requested.
Tool Parameters
text_to_speech
Parameter | Type | Required | Default | Description |
| string | Yes | — | Text to convert (long text is auto-chunked by the SDK) |
| string | No | env or preset | Voice identifier (browse via |
| string | No |
| Language code — one of 31 ( |
| string | No |
|
|
| string | No |
|
|
| float | No |
| 0.5–2.0 |
| int | No |
| -24 to +24 semitones |
| string | No | — | Emotion style (varies by voice) |
| string | No |
|
|
| bool | No |
| Play the audio locally after synthesis (macOS |
| bool | No |
| Stream synthesis. Only supported by |
| bool | No |
| Return phoneme timing data alongside the audio |
| string | No | — | Pre-normalized text (only used by |
predict_duration
Same core parameter schema as text_to_speech (long text auto-chunked). Returns "Predicted duration: 2.34s (credit usage is proportional to duration).".
search_voice
All parameters optional. With no filters → full catalog. With any filter → first response line is Filters applied: ....
Parameter | Type | Description |
| string | e.g., |
| string | e.g., |
| string | e.g., |
| string | e.g., |
| string | e.g., |
| string | e.g., |
| string | partial match |
| string | partial match |
get_voice / preview_voice
Tool | Required | Optional |
|
| — |
|
|
|
clone_voice
Parameter | Type | Required | Description |
| string | Yes | Display name (non-empty) |
| string | Yes | Local WAV or MP3 path (≤3MB). Supports |
| string | No | Optional note |
Custom voice CRUD
Tool | Required | Optional |
| — |
|
|
| — |
|
|
|
|
| — (IRREVERSIBLE) |
Usage & credits
Tool | Required | Optional |
| — | — |
| — | — (reports a recent default window) |
|
| — |
merge_audio_files
Parameter | Type | Required | Description |
| string[] | Yes | Two or more local mp3/wav paths ( |
| int | No | Silence (ms) inserted at each junction. Default |
| int | No | Crossfade blend (ms) at each junction. Default |
| string | No | Force |
Development
# Clone and install
git clone https://github.com/supertone-inc/supertone-mcp.git
cd supertone-mcp
uv sync
# Run tests
uv run pytest -q
# Run with coverage
uv run pytest --cov=src --cov-report=term-missingLicense
MIT
Available Tools
14 toolsclone_voiceA
Create a custom voice from a single local audio file. Constraints: WAV or MP3 only, max 3MB, exactly one file. The returned voice_id can be used immediately in text_to_speech. Path supports ~ expansion (e.g., "~/sample.wav").
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| audio_path | Yes | ||
| description | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description must disclose behavior. It specifies file constraints, path expansion, and voice_id usability, but lacks details on idempotency, error handling, or potential side effects like credit consumption.
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?
Three concise sentences with all essential information, no redundancy. Front-loaded with main action.
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?
Given the tool's simplicity and existence of output schema, description covers main behavioral aspects and constraints. However, missing parameter details for name and description leave a gap, preventing a perfect score.
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 coverage is 0%, so description must explain all parameters. It only addresses audio_path (local file, expansion) but leaves name and description unexplained. This is insufficient for parameter understanding.
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?
Description clearly states the action 'Create a custom voice from a single local audio file' and specifies constraints (WAV/MP3, max 3MB, one file). This differentiates it from sibling tools like search_custom_voice and text_to_speech, which operate on existing voices or perform different tasks.
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?
Description provides clear context for when to use (creating a voice from audio) but does not explicitly exclude other use cases or mention alternatives among siblings. It gives usage constraints but no guidance on when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
delete_custom_voiceA
Permanently delete a custom (cloned) voice. THIS IS IRREVERSIBLE — once deleted, the voice cannot be recovered and any saved voice_id referencing it will stop working. Confirm with the user before calling.
| Name | Required | Description | Default |
|---|---|---|---|
| voice_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses irreversibility, unrecoverable deletion, and impact on saved voice_ids. No annotations present, so description carries full burden; covers key behavioral traits without mentioning potential restrictions or side effects.
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?
Four concise, well-structured sentences with no superfluous information. Each sentence adds value: action, irreversibility, consequences, user confirmation.
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?
Adequately covers deletion warnings for a simple tool with one parameter and output schema. Could mention permissions or soft delete but sufficient for safe invocation.
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?
Only one parameter (voice_id) with no schema description coverage. Description does not explain what voice_id represents or how to obtain it, relying solely on the schema's type requirement.
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 clearly states the action ('permanently delete a custom (cloned) voice') and resource, distinguishes from siblings like clone_voice or edit_custom_voice, and emphasizes irreversibility.
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?
Explicitly instructs to confirm with user before calling, warns about irreversibility and consequences. Does not explicitly state when not to use or alternatives, but direct instruction suffices.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
edit_custom_voiceA
Update the name and/or description of an existing custom voice. At least one of name or description must be provided.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| voice_id | Yes | ||
| description | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It reveals the operation is an update but omits details like whether it overwrites or merges, permission requirements, or error conditions.
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, clear sentence that efficiently conveys the purpose and a key constraint with no unnecessary words.
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?
For a simple mutation tool with 3 parameters and an output schema, the description is minimally adequate but could mention that the voice must exist or what the response contains.
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 0%, and the description adds meaning by noting 'at least one' constraint. However, it doesn't explain voice_id or the nullability of name and description beyond the schema.
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 clearly states the tool updates name and/or description of an existing custom voice, distinguishing it from sibling tools like clone or delete.
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 explicitly requires at least one of name or description, providing a clear constraint. It implies usage for metadata updates but doesn't explicitly exclude other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_credit_balanceA
Returns the remaining Supertone credit balance for the current API key. Use this before long TTS calls to confirm you have enough characters left.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations were provided, so the description carries full burden. It correctly indicates a read operation that returns balance for the current API key. While it could mention potential error conditions or rate limits, the simplicity of the tool makes the disclosure adequate.
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?
Two sentences with zero waste. The first sentence states purpose, the second provides usage guidance. Front-loaded and efficient.
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?
Given zero parameters and the presence of an output schema, the description is complete. It provides purpose and usage context, sufficient for an agent to decide when to invoke this tool.
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?
The tool has no parameters, and the schema covers 100% of them (none). The description adds no parameter-specific info, which is appropriate as none exist. Baseline 4 is justified.
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?
Description clearly states the tool returns the remaining Supertone credit balance for the current API key, using a specific verb and resource. It distinguishes from siblings like text_to_speech by focusing on balance rather than voice generation.
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?
Explicitly advises using this tool before long TTS calls to confirm sufficient characters, providing clear context. It does not mention when not to use or alternatives, but the guidance is direct and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_custom_voiceA
Fetch the detail of a single custom (cloned) voice by voice_id. Returns the voice's name and description. Use search_custom_voice to list custom voices and find a voice_id.
| Name | Required | Description | Default |
|---|---|---|---|
| voice_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. Specifies return values (name and description) but does not mention potential errors, authorization needs, or side effects. Adequate but not comprehensive.
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?
Three sentences, each serving a distinct purpose: action, output, usage guidance. No redundant information; highly efficient.
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?
Given the tool's simplicity (single parameter, output schema exists), the description covers purpose, parameter usage, and output. Completeness is sufficient for an agent to use 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 coverage is 0% with no parameter description. The description adds 'by voice_id' and guidance to use search_custom_voice, providing context beyond the schema. However, lacks format or source details for the ID.
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?
Description clearly states the action 'Fetch the detail of a single custom voice' and the resource 'by voice_id', distinguishing it from sibling search_custom_voice which lists voices.
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?
Explicitly references search_custom_voice to find a voice_id, providing clear context for when to use this tool. Lacks explicit when-not or alternative tool exclusions, but sufficient for a simple retrieval.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_usage_historyA
Retrieve recent TTS API usage history for the current API key. Returns a plain-text summary broken down by time period, showing the minutes used (and, when available, the voice and model) in each period. Takes no parameters — it reports usage over a recent default window. Use this to review how much synthesis has been consumed.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It explains the output is a plain-text summary with minutes used, voice, and model when available. It mentions a 'recent default window' but doesn't specify its length, which is a minor gap.
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 two sentences, front-loaded with the main action, and contains no fluff. Every sentence provides essential information.
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?
Given the presence of an output schema and zero parameters, the description adequately explains the return format and content. The exact time window is not specified, but it is acceptable for a simple usage retrieval tool.
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?
There are zero parameters, so baseline is 4. The description confirms it takes no parameters and reports over a default window, which adds value beyond the empty schema.
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 clearly states the tool retrieves TTS API usage history for the current API key, specifying the verb (retrieve) and resource (usage history). It is distinct from sibling tools like get_credit_balance or get_voice, which serve different purposes.
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 notes the tool takes no parameters and is meant for reviewing synthesis consumption. While it doesn't explicitly contrast with alternatives, the zero-parameter nature makes its use case straightforward.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_voiceA
Fetch full detail for a single voice by voice_id. Returns name, description, age, gender, use_cases, languages, styles, supported models, sample count, and thumbnail URL. Use preview_voice to get the actual sample audio URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| voice_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden of behavioral disclosure. It does not mention that the tool is read-only, safe, or any potential side effects, rate limits, or auth requirements. While the description correctly describes the output, it lacks explicit behavioral transparency beyond that.
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 concise (two sentences), with the first sentence clearly stating the purpose and listing return fields, and the second providing a relevant sibling tool reference. No unnecessary words or repetition.
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?
An output schema exists, so the description does not need to detail return format, but it still lists key fields. It guides users to preview_voice for audio URLs. Given the simplicity of the tool (one required parameter, read operation), the description is largely complete, though it omits error handling or source of voice_id.
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?
The only parameter is voice_id, and the schema has no description (0% coverage). The description mentions 'by voice_id' but does not explain what a voice_id is, how to obtain it, or any constraints. It adds minimal value beyond the schema itself.
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 clearly states the tool fetches full detail for a single voice by voice_id, listing the returned fields. It distinguishes from sibling tool preview_voice, which provides actual audio URLs.
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 explicitly directs users to preview_voice for sample audio URLs, providing clear guidance on when to use this tool vs an alternative. However, it does not explicitly state when not to use this tool (e.g., for searching or listing voices), but the context implies it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_voice_usageA
Retrieve recent usage for a single voice by voice_id. Returns a plain-text summary of the voice's per-day minutes used over a recent default window. Use search_voice or search_custom_voice to find a voice_id.
| Name | Required | Description | Default |
|---|---|---|---|
| voice_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It explains output is a plain-text summary of per-day minutes over a recent default window, which adds behavioral context. Could be improved by stating non-destructive nature.
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?
Three concise sentences, all essential. First states purpose, second describes output, third gives usage guidance. No fluff.
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?
Has output schema, so return details are covered. Description adds value by summarizing output and mentioning time window. Could specify default window duration, but adequate for a simple tool.
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 has 0% description coverage, so description must compensate. It mentions voice_id and how to obtain it, but does not elaborate on format or constraints. Adequate but not exceptional.
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?
Description explicitly states 'Retrieve recent usage for a single voice by voice_id', which is a specific verb and resource. It clearly distinguishes from sibling tools like search_voice and get_usage_history.
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?
Provides guidance to use search_voice or search_custom_voice to find a voice_id, indicating when to use alternative tools. However, it does not explicitly state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
merge_audio_filesA
Merge two or more local audio files into a single file using ffmpeg. Supports plain concatenation, silence-gap insertion between clips (gap_ms), or crossfade blending (crossfade_ms). gap_ms and crossfade_ms are mutually exclusive. Output format is auto-detected from the inputs (all-same-ext -> that ext; mixed -> mp3) or overridden via output_format. Use this to stitch multiple text_to_speech outputs into one deliverable.
| Name | Required | Description | Default |
|---|---|---|---|
| gap_ms | No | ||
| input_paths | Yes | ||
| crossfade_ms | No | ||
| output_format | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description carries full burden. Discloses ffmpeg usage, merge modes (plain, gap, crossfade), mutual exclusivity of gap_ms and crossfade_ms, and output format auto-detection. Fully transparent.
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?
Three sentences that are front-loaded with purpose, then detail. No unnecessary words or repetition. Efficient and clear.
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?
With output schema present, description covers key behavioral aspects and use case. Slight lack of edge-case handling (e.g., unsupported formats) but overall complete for the tool's complexity.
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 0%, but description explains gap_ms, crossfade_ms, and output_format in detail. Input_paths is self-explanatory. Compensates well for missing schema descriptions.
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 clearly states the tool merges local audio files using ffmpeg, specifying the verb 'merge' and the resource 'audio files'. It distinguishes from siblings (e.g., text_to_speech) which are unrelated.
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?
Provides explicit use case: 'stitch multiple text_to_speech outputs into one deliverable'. Does not explicitly list when not to use or compare to other tools, but siblings are clearly different, so guidance is adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
predict_durationA
Predict the expected output audio duration in seconds for a given text WITHOUT producing any audio file. Accepts the same parameters as text_to_speech. There is no text-length limit: long text is automatically split (auto-chunked), and credit usage and latency scale with the length of the text. Use this to estimate credit cost before synthesizing — credit usage is proportional to the predicted duration.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| model | No | ||
| speed | No | ||
| style | No | ||
| language | No | ||
| voice_id | No | ||
| pitch_shift | No | ||
| output_format | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses key behaviors: no audio output, auto-chunking for long text, credit and latency scaling with text length, and that it predicts duration. It does not mention idempotence or authorization, but the disclosed traits are comprehensive for a prediction tool.
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 three sentences, each serving a distinct purpose: defining the action, linking to text_to_speech parameters, and providing scaling/credit context. No unnecessary words, highly efficient.
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 is largely complete: it explains purpose, usage, key behaviors, and scaling. It does not cover error handling or prerequisites (like authentication), but for a prediction tool with an output schema, it is adequately comprehensive.
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 0%, but the description states 'Accepts the same parameters as text_to_speech', which adds meaning by linking to a known sibling. However, it does not detail individual parameters further, so it adds moderate value beyond the schema.
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 clearly states the tool predicts audio duration without producing audio, using verb 'predict' and resource 'expected output audio duration'. It distinguishes from the sibling 'text_to_speech' by emphasizing no audio file is produced.
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 explicitly tells the agent to use this to estimate credit cost before synthesizing, providing clear context. It also notes that it accepts the same parameters as text_to_speech, implying a cost estimation use case. However, it does not explicitly state when not to use it or mention alternatives, but the context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
preview_voiceA
Fetch sample audio URLs for a voice. Optionally filter samples by language, style, and model. Returns one URL per matching sample. v0.2 does NOT play the audio locally; pass the URL to your client to listen.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | ||
| style | No | ||
| language | No | ||
| voice_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool does not play audio locally and returns one URL per matching sample, which are important behavioral traits.
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?
Two sentences with no wasted words. The first sentence states the action and filters; the second provides a critical behavioral caveat.
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?
Given the tool's simplicity and the presence of an output schema, the description covers the core purpose, filters, and a key behavior. It is complete enough for an agent to use 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 0%, but the description adds meaning by stating that language, style, and model are optional filters. This compensates for the lack of parameter descriptions in the schema.
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 clearly states the action ('Fetch sample audio URLs'), the resource ('a voice'), and optionally filters by language, style, and model. It distinguishes from sibling tools like text_to_speech by focusing on samples.
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 provides a usage note about not playing audio locally, but lacks explicit guidance on when to use this tool versus alternatives like search_voice or get_voice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_custom_voiceA
List custom (cloned) voices created by this API key. Optional name and description filters perform partial matching. Pagination is handled internally; v0.2 returns the SDK default page.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | ||
| description | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses pagination internal handling and partial matching behavior. It does not explicitly confirm read-only nature, but it is implied.
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?
Two succinct sentences with no fluff, front-loading the core purpose, then adding filter and pagination details efficiently.
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?
Given output schema exists (not shown), description adequately covers input behavior and pagination for a listing tool. No additional explanation needed.
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 coverage is 0%, but description adds that name and description filters perform partial matching, providing functional meaning beyond schema types.
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 clearly states it lists custom (cloned) voices created by the API key, distinguishing it from sibling tools like search_voice (general voices) and clone_voice (creation).
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?
It indicates when to use (to list custom voices with optional name/description filters) but does not explicitly state when not to use or mention alternatives like search_voice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_voiceA
Search the Supertone voice catalog. Filters are optional and combined with AND semantics: name, description, language, gender, age, use_case, style, model. With no filters, returns the full catalog (the v0.1 list_voices behavior). The output is a numbered plain-text list; when any filter is set, the first line shows "Filters applied: ...".
| Name | Required | Description | Default |
|---|---|---|---|
| age | No | ||
| name | No | ||
| model | No | ||
| style | No | ||
| gender | No | ||
| language | No | ||
| use_case | No | ||
| description | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the output format (numbered plain-text list) and the filter indicator line. It does not mention authentication, rate limits, or side effects, but the mutation-free nature is implied by 'search'.
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 three concise sentences. The first sentence states the core purpose, the second clarifies filter behavior, and the third describes the output format. No redundant information.
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?
Given the tool's simplicity (all optional string parameters), the description covers the essential functionality, filter semantics, and output format. It lacks mention of pagination or limits, but the output schema likely covers return values.
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?
The schema has 0% description coverage, so parameters are minimally described. The description lists the filterable fields (name, description, language, etc.) and notes AND semantics, but provides no allowed values or examples.
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 clearly states the tool searches the Supertone voice catalog and lists filterable fields. It mentions the behavior without filters, but does not explicitly distinguish from the sibling tool 'search_custom_voice'.
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 explains that filters are optional and combined with AND semantics, and that no filters returns the full catalog. However, it does not provide when-not-to-use or comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
text_to_speechA
Generate natural-sounding speech audio from text. Use this when the user wants to: hear text read aloud, create narration or voiceover, generate voice audio, preview how text sounds when spoken, or convert any writing into spoken audio. Supports 31 languages including Korean, English, and Japanese. There is no text-length limit: long text is automatically split (auto-chunked) by the service, and credit usage and latency scale with the length of the text. Set output_mode ('files', 'resources', or 'both') to control how audio is returned, and autoplay=true to play it back on macOS. These per-call parameters REPLACE the removed SUPERTONE_MCP_OUTPUT_MODE and SUPERTONE_MCP_AUTOPLAY environment variables; autoplay now defaults to false. A default voice is already configured -- just call this tool directly. Only call search_voice if the user explicitly asks to change or browse voices.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| model | No | ||
| speed | No | ||
| style | No | ||
| autoplay | No | ||
| language | No | ||
| voice_id | No | ||
| streaming | No | When true, stream the audio via the chunked synthesize path instead of a single one-shot request. Streaming is ONLY supported by model=sona_speech_1; using streaming=true with any other model returns a validation error. Defaults to false (one-shot synthesize). | |
| output_mode | No | ||
| pitch_shift | No | ||
| output_format | No | ||
| normalized_text | No | Optional pre-normalized text to use for synthesis (SDK 0.2.3). Only applies to the sona_speech_2 and sona_speech_2_flash models; other models ignore it. When omitted, the SDK default (None) is used. | |
| include_phonemes | No | When true, request phoneme timing data alongside the audio (SDK 0.2.3). Defaults to false. Note: the phoneme data is not yet surfaced in the tool response — this is a pass-through flag for now. |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses auto-chunking for long text, credit and latency scaling, output mode options, autoplay default false, and that parameters replace environment variables. Lacks details on error handling or model-specific behaviors, but covers key behavioral traits.
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?
Well-structured and front-loaded. Begins with purpose, lists use cases, then key behaviors, parameter guidance, and sibling differentiation. Every sentence adds value without 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?
Tool has 13 parameters and no annotations; an output schema exists. Description covers essential use case and key behaviors but lacks details on many parameters' semantics and error conditions. Adequate for simple usage but incomplete for complex parameter combinations.
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 only 23%, so description must compensate. It adds meaning for output_mode and autoplay (options, defaults) and mentions text length behavior, but does not elaborate on model, speed, style, voice_id, pitch_shift, output_format, normalized_text, or include_phonemes beyond what the schema defines. Adequate for basic use but incomplete.
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 clearly states the tool generates speech audio from text, lists specific use cases (hear text read aloud, narration, voiceover, etc.), and differentiates from sibling search_voice by explicitly stating to only use search_voice for changing voices.
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?
Provides explicit when-to-use conditions (user wants to hear text, create narration, etc.) and when-not-to-use (only call search_voice for changing voices). Also notes that a default voice is configured, so no need to set voice_id unless the user requests a change.
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. Dates show when Glama detected each change.
5 tool updates
v0.3.1- Added
get_custom_voice - Added
get_usage_history - Added
get_voice_usage - Added
merge_audio_files - Changed
text_to_speech5 fields changed- added
Input schema / properties / autoplayAdded value: +{ + "default": false, + "title": "Autoplay", + "type": "boolean" +} - added
Input schema / properties / include_phonemesAdded value: +{ + "default": false, + "description": "When true, request phoneme timing data alongside the audio (SDK 0.2.3). Defaults to false. Note: the phoneme data is not yet surfaced in the tool response — this is a pass-through flag for now.", + "title": "Include Phonemes", + "type": "boolean" +} - added
Input schema / properties / normalized_textAdded value: +{ + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "description": "Optional pre-normalized text to use for synthesis (SDK 0.2.3). Only applies to the sona_speech_2 and sona_speech_2_flash models; other models ignore it. When omitted, the SDK default (None) is used.", + "title": "Normalized Text" +} - added
Input schema / properties / output_modeAdded value: +{ + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ], + "default": null, + "title": "Output Mode" +} - added
Input schema / properties / streamingAdded value: +{ + "default": false, + "description": "When true, stream the audio via the chunked synthesize path instead of a single one-shot request. Streaming is ONLY supported by model=sona_speech_1; using streaming=true with any other model returns a validation error. Defaults to false (one-shot synthesize).", + "title": "Streaming", + "type": "boolean" +}
10 tool updates
v0.1.1- First observed
clone_voice - First observed
delete_custom_voice - First observed
edit_custom_voice - First observed
get_credit_balance - First observed
get_voice - First observed
predict_duration - First observed
preview_voice - First observed
search_custom_voice - First observed
search_voice - First observed
text_to_speech
TDQS
Each tool targets a distinct action or resource: voice cloning, custom voice CRUD, catalog browsing, TTS, duration prediction, audio merging, and usage tracking. No two tools have overlapping purposes; even the get functions are clearly differentiated by domain (custom vs. catalog).
All tools use a consistent snake_case verb_noun pattern (e.g., clone_voice, delete_custom_voice, get_credit_balance). This makes it easy for an agent to infer action and target from the name alone.
With 14 tools, the server covers all core functionalities without being bloated. Each tool serves a necessary role in voice cloning, synthesis, audio manipulation, and account management. The number is well-scoped for the domain.
The tool surface covers the full lifecycle for custom voices (create, read, update, delete, search), catalog exploration, TTS with duration estimation, audio merging, and usage tracking. There are no obvious gaps that would hinder typical workflows.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
AI voice generation: text-to-speech and voice cloning from any MCP client.
MCP server for Text-to-Speech
MCP server exposing the AceDataCloud Fish Audio API (text-to-speech with voice conditioning)
MCP server for Speech-to-Text
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA Model Context Protocol server that integrates high-quality text-to-speech capabilities with Claude Desktop and other MCP-compatible clients, supporting multiple voice options and audio formats.171MIT
- AlicenseAqualityDmaintenanceA Model Context Protocol server for FlowSpeech text-to-speech. It lets MCP-compatible clients generate human-like audio with context-aware emotion control, pause control, multi-speaker dialogue, and 30+ available voices.324MIT
- AlicenseAqualityBmaintenanceEnables local text-to-speech synthesis for Claude and Cursor using Supertonic 3, with support for multiple voices, expressions, and languages. No API key or cloud required.3MIT
- AlicenseNot gradedqualityAmaintenanceLocal Korean text-to-speech MCP server using a fine-tuned CosyVoice2 model, enabling voice synthesis directly from Claude or Codex with privacy and no API costs.1Apache 2.0
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/supertone-inc/supertone-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server