text-to-speech-mcp

# Text to Speech MCP Server

<!-- mcp-name: io.github.Engr-FaizanAli/text-to-speech -->

[![PyPI version](https://img.shields.io/pypi/v/text-to-speech-mcp.svg)](https://pypi.org/project/text-to-speech-mcp/)
[![Downloads](https://img.shields.io/pypi/dm/text-to-speech-mcp.svg)](https://pypi.org/project/text-to-speech-mcp/)
[![Python versions](https://img.shields.io/pypi/pyversions/text-to-speech-mcp.svg)](https://pypi.org/project/text-to-speech-mcp/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
[![CI](https://github.com/Engr-FaizanAli/text-to-speech-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/Engr-FaizanAli/text-to-speech-mcp/actions/workflows/ci.yml)

**Give your AI assistant a voice — locally, with no API key, no account, and no
cloud service.**

Text to Speech is an open-source Model Context Protocol (MCP) server that lets
AI assistants read text aloud on the user's computer. It uses the speech
synthesizer already present on the host operating system, so nothing you ask it
to say ever leaves your machine.

Runs on **Windows, macOS, and Linux**. Install is one line:

```text
uvx text-to-speech-mcp
```

The server exposes one model-controlled tool:

```text
speak_text(text: string)
```

Use it for user-provided text, assistant answers, accessibility workflows, or
spoken progress updates while an agent works.

### Why this one

Most text-to-speech MCP servers wrap a cloud API, which means an account, a
key, per-character billing, and your text leaving the machine. This one uses
the speech engine your operating system already ships, so it works offline,
costs nothing, and keeps text local — which matters if you work anywhere that
regulates where data may go.

It also ships an [agent narration skill](#agent-narration-skill), so an
assistant knows *how* to narrate, not just that it can.

## Features

- Local playback through the platform's built-in synthesizer by default:
  Windows SAPI, macOS `say`, or `espeak-ng` on Linux.
- No cloud API and no API key for the default setup.
- FIFO playback: concurrent requests are spoken one at a time, in order.
- Blocking tool completion: each call returns after its audio finishes.
- Bounded input and queue sizes to prevent unbounded resource use.
- Temporary generated WAV files are removed after playback by default.
- Standard MCP `stdio` transport through the official Python SDK.
- Optional Piper, Transformers MMS, and local HTTP backends for advanced users.

> The MCP server source is open source under the MIT License. Windows SAPI and
> the macOS `say` command are proprietary components of their operating
> systems; they are not open-source speech engines. `espeak-ng` is separately
> licensed open-source software.

## Requirements

- Python 3.10 or newer.
- An MCP client that supports stdio MCP servers.
- `uv`/`uvx` is recommended for package-based MCP installation.

Per platform, for the zero-configuration default:

| Platform | Synthesis | Playback | Extra install |
| --- | --- | --- | --- |
| Windows 10/11 | SAPI via PowerShell | `System.Media.SoundPlayer` | None |
| macOS | `say` | `afplay` | None |
| Linux / other Unix | `espeak-ng` or `espeak` | `aplay`, `paplay`, `play`, or `ffplay` | `espeak-ng` and one player |

On Debian or Ubuntu that is typically:

```bash
sudo apt install espeak-ng alsa-utils
```

Set `TEXT_TO_SPEECH_BACKEND` or `TEXT_TO_SPEECH_PLAYER` to override either
choice. If a required command is missing, the server reports which one and how
to install it rather than failing silently.

## Install

Configure an MCP client to run the published PyPI package:

```text
uvx text-to-speech-mcp
```

For MCP clients that accept command-based server configuration, use:

```toml
command = "uvx"
args = ["text-to-speech-mcp"]
startup_timeout_sec = 30
tool_timeout_sec = 300
enabled = true
```

Some clients use TOML, JSON, or a graphical settings page. Use
`uvx text-to-speech-mcp` as the server command and restart the client after
changing its configuration.

### Install from source

```powershell
git clone https://github.com/Engr-FaizanAli/text-to-speech-mcp.git
cd text-to-speech-mcp
python -m pip install .
```

Then configure the client to run `text-to-speech-mcp` directly.

## Prompt Examples

Read arbitrary text:

```text
Use the Text to Speech tool to read aloud: The deployment completed successfully.
```

Read the final answer:

```text
Use the Text to Speech tool to read your final response aloud before displaying it.
```

Read visible intermediate progress updates in order:

```text
Use the text_to_speech MCP server's speak_text tool for spoken progress updates.

For every meaningful intermediate update that you display to me:
1. Call speak_text with the exact update text you are about to display.
2. Wait for the call to finish before producing or speaking the next update.
3. Then display the same update in text.

Also call speak_text with the exact final answer before displaying it. Never
narrate hidden reasoning, chain-of-thought, secrets, credentials, raw tool
output, terminal logs, or source code unless I explicitly ask you to read that
content aloud. Do not invoke speech calls in parallel. If the tool is
unavailable, continue normally in text and report the failure once.
```

The `text_to_speech` portion is an example client-side server name. Clients may
display a different namespace while keeping the tool name `speak_text`.

## Tool Contract

| Field | Value |
| --- | --- |
| Tool name | `speak_text` |
| Input | `text`, required string, 1-50,000 characters |
| Result | Completion message after local playback finishes |
| Ordering | FIFO, one active playback at a time |
| Queue limit | 32 pending requests |
| Network use with a built-in backend | None |

The tool is model-controlled under MCP. The user decides when to ask the model
to call it, and the MCP client may show or require approval for tool calls.

## Privacy

With any of the built-in backends, text is passed from the MCP client to a local
Python process and then to the operating system's speech components. It is not
sent to this project, an external API, or a cloud TTS provider. Generated WAV
files are written to a `text-to-speech-mcp` directory inside the system
temporary directory (`%TEMP%` on Windows, `/tmp` on macOS and Linux) and
deleted after playback unless `TEXT_TO_SPEECH_KEEP_AUDIO=true` is set.

The `http` backend is the exception: whether text leaves the machine depends
entirely on the endpoint you configure.

Do not ask an AI assistant to speak secrets, credentials, private keys, hidden
reasoning, or sensitive tool output.

## Optional Backends

The default requires no configuration. `TEXT_TO_SPEECH_BACKEND` is unset and the
server selects `sapi`, `say`, or `espeak` to match the host platform.

To pin one explicitly, or to use a backend that is not built into the OS, set
`TEXT_TO_SPEECH_BACKEND` to `sapi`, `say`, `espeak`, `piper`,
`transformers_mms`, or `http`. The last three require their own local model,
binary, Python dependencies, or endpoint. `TEXT_TO_SPEECH_FALLBACK_BACKEND`
names a second backend to try if the first fails. See
[backend configuration](https://github.com/Engr-FaizanAli/text-to-speech-mcp/blob/main/CONFIGURATION.md).

## Agent Narration Skill

A speech tool alone does not tell an assistant *when* or *how* to speak. Left to
improvise, agents narrate hidden reasoning, skip the parts you actually needed,
or read a paraphrase instead of what is on screen.

[`skills/project-tts-responder/SKILL.md`](skills/project-tts-responder/SKILL.md)
is a ready-made narration policy built on `speak_text`. Copy it into your
project's `.claude/skills/` directory:

| Mode | Behaviour |
| --- | --- |
| **Batch** (default) | One playback at the end of a turn, covering every visible update plus the final answer |
| **Streaming** | Narrate each update as it appears — good for demos and walkthroughs |
| **Read on request** | Read a named file or block of text verbatim |

It also handles the parts that are easy to get wrong:

- **Interactive questions are narrated *before* the picker opens.** An
  interactive question tool is itself the pause, and its options live in the
  tool's parameters rather than in visible text — so any rule that narrates
  "once the options are visible" fires only after the user has already
  answered. This is the most common way narration silently fails.
- Speaks exactly what is on screen, never a paraphrase.
- Never speaks hidden reasoning, secrets, credentials, or raw tool output.
- One playback call per turn, never parallel, with defined behaviour when a
  call fails.

The skill applies when you ask for audio. To make a project narrate every
response, say so in that project's own agent instructions — for example
"narrate every response in Batch mode unless I opt out".

## MCP Compatibility

- MCP transport: `stdio`
- MCP tool implementation: official Python MCP SDK
- Registry metadata: `server.json` using the 2025-12-11 schema
- Package registry: PyPI
- Registry ownership marker: this README's `mcp-name` comment
- Registry namespace: `io.github.Engr-FaizanAli/text-to-speech`

## License

MIT. See [LICENSE](LICENSE).