Skip to main content
Glama

supertone-mcp

CAUTION

⚠️ 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.

supertone-inc/supertone-mcp MCP server

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 of output_mode (files / resources / both), autoplay, streaming, model, plus include_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 via output_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

SUPERTONE_MCP_OUTPUT_MODE=files|resources|both

text_to_speech(output_mode=...)

Default still files

SUPERTONE_MCP_AUTOPLAY=true

text_to_speech(autoplay=...)

Default changed truefalse (playback is now explicit)

(always streamed)

text_to_speech(streaming=...)

New, default false (one-shot). streaming=true requires model="sona_speech_1"

Other changes:

  • Default model changed sona_speech_1sona_speech_2_flash.

  • list_voices was removed (since the discovery release) and replaced by search_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-mcp

Configuration

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

SUPERTONE_API_KEY

Yes

Your Supertone API key

SUPERTONE_MCP_VOICE_ID

No

preset voice (Aiden, multilingual)

Default voice_id for text_to_speech / predict_duration (override per call)

SUPERTONE_OUTPUT_DIR

No

~/supertone-tts-output/

Directory where audio files are saved (used by output_mode=files/both)

Removed in 0.2.0: SUPERTONE_MCP_OUTPUT_MODE and SUPERTONE_MCP_AUTOPLAY — see Migration.

Output modes (text_to_speech output_mode)

Mode

Returns

Use when

files (default)

Plain text with the saved file path + metadata

You want the file on disk

resources

MCP AudioContent + TextContent (no file written)

The client renders audio inline (e.g., Claude.ai chat)

both

File on disk and AudioContent/TextContent

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")                           # synthesize

Example 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

autoplay is a per-call parameter (default false), so playback happens only when explicitly requested.

Tool Parameters

text_to_speech

Parameter

Type

Required

Default

Description

text

string

Yes

Text to convert (long text is auto-chunked by the SDK)

voice_id

string

No

env or preset

Voice identifier (browse via search_voice)

language

string

No

ko

Language code — one of 31 (ko, en, ja, …)

output_format

string

No

mp3

mp3 or wav

model

string

No

sona_speech_2_flash

sona_speech_1, sona_speech_2, sona_speech_2_flash, sona_speech_2t, sona_speech_3t, supertonic_api_1, supertonic_api_3

speed

float

No

1.0

0.5–2.0

pitch_shift

int

No

0

-24 to +24 semitones

style

string

No

Emotion style (varies by voice)

output_mode

string

No

files

files, resources, or both (see Output modes)

autoplay

bool

No

false

Play the audio locally after synthesis (macOS afplay)

streaming

bool

No

false

Stream synthesis. Only supported by model="sona_speech_1"

include_phonemes

bool

No

false

Return phoneme timing data alongside the audio

normalized_text

string

No

Pre-normalized text (only used by sona_speech_2 / sona_speech_2_flash)

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

language

string

e.g., ko, en, ja

gender

string

e.g., male, female

age

string

e.g., young_adult, child

use_case

string

e.g., narration, advertisement

style

string

e.g., neutral, happy

model

string

e.g., sona_speech_2_flash

name

string

partial match

description

string

partial match

get_voice / preview_voice

Tool

Required

Optional

get_voice

voice_id

preview_voice

voice_id

language, style, model (filter samples)

clone_voice

Parameter

Type

Required

Description

name

string

Yes

Display name (non-empty)

audio_path

string

Yes

Local WAV or MP3 path (≤3MB). Supports ~ expansion

description

string

No

Optional note

Custom voice CRUD

Tool

Required

Optional

search_custom_voice

name, description (partial match)

get_custom_voice

voice_id

edit_custom_voice

voice_id

name, description (at least one required)

delete_custom_voice

voice_id

(IRREVERSIBLE)

Usage & credits

Tool

Required

Optional

get_credit_balance

get_usage_history

— (reports a recent default window)

get_voice_usage

voice_id

merge_audio_files

Parameter

Type

Required

Description

input_paths

string[]

Yes

Two or more local mp3/wav paths (~ expansion supported). A single file is returned as-is

gap_ms

int

No

Silence (ms) inserted at each junction. Default 0. Mutually exclusive with crossfade_ms

crossfade_ms

int

No

Crossfade blend (ms) at each junction. Default 0. Mutually exclusive with gap_ms

output_format

string

No

Force mp3 or wav. If omitted: all-same-ext → that ext; mixed → mp3

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-missing

License

MIT

Available Tools

14 tools
clone_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").

ParametersJSON Schema
NameRequiredDescriptionDefault
nameYes
audio_pathYes
descriptionNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.7/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
voice_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.1/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameNo
voice_idYes
descriptionNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.7/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
voice_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.1/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
voice_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.7/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
voice_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
gap_msNo
input_pathsYes
crossfade_msNo
output_formatNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.6/5.0
Behavior5/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
textYes
modelNo
speedNo
styleNo
languageNo
voice_idNo
pitch_shiftNo
output_formatNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
modelNo
styleNo
languageNo
voice_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameNo
descriptionNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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: ...".

ParametersJSON Schema
NameRequiredDescriptionDefault
ageNo
nameNo
modelNo
styleNo
genderNo
languageNo
use_caseNo
descriptionNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.8/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 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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
textYes
modelNo
speedNo
styleNo
autoplayNo
languageNo
voice_idNo
streamingNoWhen 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_modeNo
pitch_shiftNo
output_formatNo
normalized_textNoOptional 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_phonemesNoWhen 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

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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.

  1. 5 tool updatesv0.3.1
    • Addedget_custom_voice
    • Addedget_usage_history
    • Addedget_voice_usage
    • Addedmerge_audio_files
    • Changedtext_to_speech5 fields changed
      • addedInput schema / properties / autoplay
        Added value: +{
        +  "default": false,
        +  "title": "Autoplay",
        +  "type": "boolean"
        +}
      • addedInput schema / properties / include_phonemes
        Added 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"
        +}
      • addedInput schema / properties / normalized_text
        Added 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"
        +}
      • addedInput schema / properties / output_mode
        Added value: +{
        +  "anyOf": [
        +    {
        +      "type": "string"
        +    },
        +    {
        +      "type": "null"
        +    }
        +  ],
        +  "default": null,
        +  "title": "Output Mode"
        +}
      • addedInput schema / properties / streaming
        Added 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"
        +}
  2. 10 tool updatesv0.1.1
    • First observedclone_voice
    • First observeddelete_custom_voice
    • First observededit_custom_voice
    • First observedget_credit_balance
    • First observedget_voice
    • First observedpredict_duration
    • First observedpreview_voice
    • First observedsearch_custom_voice
    • First observedsearch_voice
    • First observedtext_to_speech

TDQS

A4.2/5.0
Disambiguation5/5

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).

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness5/5

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

ActivitySlowing
ResponsivenessSyncing

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

Related MCP Servers

Latest Blog Posts

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