VOICEVOX TTS MCP

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.3.1
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: generate_query creates synthesis queries, get_speaker_detail and get_speakers handle speaker metadata, ping_voicevox checks engine status, speak plays audio, stop_speaker stops playback, and synthesize_file creates files. The descriptions make it easy to distinguish between query generation, metadata retrieval, status checking, real-time playback control, and file synthesis.
Naming Consistency4/5
The naming is mostly consistent with a verb_noun pattern (e.g., get_speakers, stop_speaker, synthesize_file), but there are minor deviations: generate_query uses 'generate' instead of a more specific verb like 'create', and ping_voicevox uses 'ping' as a verb which is less conventional but still understandable. All tools use snake_case consistently.
Tool Count5/5
With 7 tools, this server is well-scoped for a TTS system. It covers essential operations like checking engine status, retrieving speaker information, generating queries, real-time speech playback with control, and file synthesis. Each tool earns its place without feeling excessive or insufficient for the domain.
Completeness5/5
The tool set provides complete coverage for a TTS domain: it includes status checking (ping_voicevox), metadata retrieval (get_speakers, get_speaker_detail), query preparation (generate_query), real-time audio handling (speak, stop_speaker), and file output (synthesize_file). There are no obvious gaps—agents can perform the full lifecycle from setup to synthesis and playback control.
Average 3.2/5 across 7 of 7 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 7 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under ISC License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Generate a query' suggests this creates some intermediate representation, but doesn't disclose what happens next - does it return a query ID for later use? Does it validate parameters? Is it read-only or has side effects? The description lacks behavioral context about permissions, rate limits, or what 'query' means operationally.
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, efficient sentence with zero wasted words. It's appropriately sized for a tool with good schema coverage and gets straight to the point without unnecessary elaboration. Every word earns its place in conveying the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the generated query is used for, what format it returns, or how it differs from actual synthesis tools. Given the complexity of voice synthesis workflows and multiple sibling tools, more context about this tool's role in the ecosystem is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (text, speaker, speedScale) with their descriptions. The tool description adds no additional parameter semantics beyond what's in the schema. The baseline score of 3 reflects adequate but minimal value addition given the comprehensive schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Generate a query for voice synthesis' which provides a basic purpose (verb: generate, resource: query for voice synthesis). However, it's vague about what the query actually does - is it for previewing, testing, or preparing synthesis? It doesn't distinguish from sibling tools like 'synthesize_file' or 'speak' which also relate to voice synthesis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'synthesize_file' and 'speak' that also handle voice synthesis, there's no indication whether this tool is for preparation, testing, or a different phase of the synthesis workflow. No context about prerequisites or exclusions is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 of behavioral disclosure. It mentions 'Get detail' but doesn't specify if this is a read-only operation, what permissions are needed, error handling, or response format. This leaves significant gaps for a tool that likely interacts with a speaker database.
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, efficient sentence with no wasted words. It's front-loaded with the core action ('Get detail'), making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'detail' includes (e.g., speaker attributes, capabilities), potential errors, or how this fits with sibling tools like 'synthesize_file'. For a tool with one parameter but unknown behavioral traits, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'uuid' documented as 'Speaker UUID (speaker uuid)'. The description adds no additional meaning beyond this, such as format examples or where to obtain the UUID. Baseline 3 is appropriate since the schema does the heavy lifting.
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 verb ('Get detail') and resource ('speaker'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_speakers' (which likely lists speakers) or explain what 'detail' entails beyond the ID lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't clarify if this should be used after 'get_speakers' to fetch more information or in what contexts (e.g., before synthesis). The description only states the basic function without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves a list, implying a read-only operation, but doesn't cover aspects like whether it requires authentication, has rate limits, returns paginated results, or what format the list is in. For a tool with zero annotation coverage, this is a significant gap in transparency.
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, efficient sentence ('Get a list of available speakers') that is front-loaded and wastes no words. It directly states the tool's purpose without unnecessary elaboration, making it highly concise and well-structured for its simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple list retrieval) but lack of annotations and output schema, the description is incomplete. It doesn't explain what the list contains, how it's formatted, or any behavioral traits. For a tool with no structured data beyond the input schema, more context is needed to be fully helpful to an agent.
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 input schema has 0 parameters with 100% coverage, so the schema fully documents the lack of inputs. The description doesn't add parameter details beyond this, which is appropriate. Since there are no parameters, the baseline is 4, as the description doesn't need to compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose ('Get a list of available speakers'), which is clear but vague. It specifies the verb ('Get') and resource ('speakers'), but doesn't distinguish it from sibling tools like 'get_speaker_detail' or explain what 'available' means in this context. This is adequate but has clear gaps in specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_speaker_detail' for detailed information or 'synthesize_file' for synthesis operations, nor does it specify prerequisites or contexts for usage. This leaves the agent without explicit or implied usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions generating a file and returning a path, but lacks details on permissions, side effects (e.g., file system changes), rate limits, error handling, or audio format specifics. This is inadequate for a tool that creates files, as it doesn't clarify behavioral traits beyond the basic operation.
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, efficient sentence that front-loads the core action and return value. Every word earns its place, with no redundancy or unnecessary elaboration, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a file-generation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like side effects, error cases, or audio specifics, and lacks usage context. This leaves significant gaps for an AI agent to understand how to invoke it correctly in various scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly (e.g., precedence rules for text vs. query, optional defaults). The description adds no additional parameter semantics beyond what the schema provides, such as explaining the audio generation process or file format details. Baseline 3 is appropriate when the schema does the heavy lifting.
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 action ('Generate an audio file') and the resource ('audio file'), and specifies the return value ('return its absolute path'). It distinguishes from siblings like 'speak' (which might stream audio) and 'generate_query' (which likely creates queries rather than files). However, it doesn't explicitly differentiate from all siblings (e.g., 'stop_speaker' is clearly different).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context, or comparisons to siblings like 'speak' (which might be for immediate playback) or 'generate_query' (which might be for query generation without file creation).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 of behavioral disclosure. It states the tool checks if the engine is 'running and reachable,' implying a read-only, non-destructive operation, but doesn't detail what happens on failure (e.g., error responses), latency, or any side effects. For a tool with zero annotation coverage, this leaves gaps in understanding its behavior.
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, efficient sentence: 'Check if VOICEVOX Engine is running and reachable.' It is front-loaded with the core purpose, has no wasted words, and is appropriately sized for a simple tool. Every part of the sentence earns its place by conveying essential information.
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?
Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on usage context, error handling, or return values. Without an output schema, it doesn't explain what 'check' returns (e.g., status, boolean), leaving some gaps for an agent to understand fully.
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 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to explain parameters, so it naturally adds no value beyond the schema. A baseline score of 4 is appropriate for zero-parameter tools, as there's no parameter information to compensate for.
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's purpose: 'Check if VOICEVOX Engine is running and reachable.' It uses a specific verb ('Check') and identifies the target resource ('VOICEVOX Engine'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'get_speakers' or 'synthesize_file', which serve different purposes but also interact with VOICEVOX.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., before using other tools), exclusions, or contextual cues. For example, it doesn't specify if this should be called first to verify connectivity before invoking 'speak' or 'synthesize_file'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the basic action. It does not disclose behavioral traits like whether this requires specific permissions, what happens if no audio is playing, error conditions, or side effects. The description is minimal and lacks necessary context for safe invocation.
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 with zero wasted words. It is perfectly front-loaded and appropriately sized for a simple action tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete for a mutation tool. It does not explain what happens after stopping playback (e.g., success/failure response, state changes) or error handling, leaving significant gaps for the agent.
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 0 meaningful parameters (only a dummy parameter with 100% schema coverage). The description correctly omits parameter details since none are needed for the core functionality, adding appropriate 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 'Stop current audio playback' clearly states the specific action (stop) and resource (current audio playback). It distinguishes from siblings like 'speak' or 'synthesize_file' which initiate playback rather than stop it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when audio is currently playing, but does not explicitly state when to use this tool versus alternatives or provide any exclusions. It lacks guidance on prerequisites or timing considerations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: text is split by line breaks into separate speech units, each line processed independently, and the first line should be short for quick playback start. It doesn't mention error handling, rate limits, or authentication needs, but covers core playback behavior adequately.
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 front-loaded with the core purpose in the first sentence, followed by specific behavioral details in the second. Both sentences earn their place by providing essential information without redundancy. It's appropriately sized for the tool's complexity.
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 no annotations and no output schema, the description does well to cover the main behavior and text processing logic. However, it doesn't address potential side effects (e.g., interrupting current playback, which is hinted at in the 'immediate' parameter schema), error cases, or what the tool returns. For a 7-parameter tool with mutation implications, it's good but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds minimal parameter semantics beyond the schema—it mentions line break processing and first line optimization, which relates to the 'text' parameter but doesn't significantly enhance understanding of parameters like 'query' or 'speaker'. Baseline 3 is appropriate given high schema coverage.
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 specific action ('Convert text to speech and play it') and resource (audio output), distinguishing it from siblings like 'synthesize_file' (file output) and 'stop_speaker' (playback control). It explicitly mentions text processing by line breaks, which adds specificity beyond the basic function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for text-to-speech playback but doesn't explicitly state when to use this tool versus alternatives like 'synthesize_file' (for file output) or 'generate_query' (possibly for query generation). It provides some context about line break processing but lacks explicit guidance on tool selection scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-tts-voicevox MCP server](https://glama.ai/mcp/servers/kajidog/mcp-tts-voicevox/badges/card.svg)](https://glama.ai/mcp/servers/kajidog/mcp-tts-voicevox)

Score Badge

Copy to your README.md:

[![mcp-tts-voicevox MCP server](https://glama.ai/mcp/servers/kajidog/mcp-tts-voicevox/badges/score.svg)](https://glama.ai/mcp/servers/kajidog/mcp-tts-voicevox)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/kajidog/mcp-tts-voicevox'

If you have feedback or need assistance with the MCP directory API, please join our Discord server