Cheema Text-to-Voice MCP Server

Cheema Text-to-Voice is a free, open-source MCP server that gives any MCP-compatible AI assistant, including Claude Desktop, Claude Code, and n8n, a real voice. It runs the NeuTTS text-to-speech models locally on your own CPU or GPU, so there are no API keys to configure, no cloud service in the loop, and no per-character billing: text goes in, a WAV file comes out, entirely on your machine. Ask your assistant to speak and it synthesizes natural speech in five built-in voices across four languages, or clones a new voice from a short recording in seconds.

Links

• MCP directory: listed on mcpservers.org
• Case study: how Cheema Text-to-Voice was built

Built by Tayyab Ilyas, AI Agent Engineer in Barcelona.

What Can It Do?

Just ask your AI assistant to speak, and it handles the rest:

> *"Say hello in French using the juliette voice"*

> *"Convert this paragraph to speech and save it as intro.wav"*

> *"Clone my voice from this recording and use it to read my essay"*

Features:

• 5 built-in voices across 4 languages: English (jo, dave), German (greta), French (juliette), Spanish (mateo)
• Instant voice cloning from a 3-15 second WAV sample, persisted across restarts
• 5 MCP tools (`tts_help`, `tts_list_speakers`, `tts_list_models`, `tts_synthesize`, `tts_add_speaker`) plus 2 ready-made prompt templates
• 3 transports: stdio for Claude Desktop and Claude Code, SSE and Streamable HTTP for n8n and other remote clients
• Swappable NeuTTS backbone models, including smaller quantized GGUF variants, with optional CUDA acceleration
• 100% local: no API keys, no cloud calls, no per-character billing

Quick Start

1. Install Prerequisites

You need Python 3.10+ and espeak-ng:

# Ubuntu / Debian
sudo apt install espeak-ng

# macOS
brew install espeak-ng

# Windows
choco install espeak-ng

2. Clone & Install

git clone https://github.com/MuhammadTayyabIlyas/CHeema-Text-to-Voice-MCP-Server.git
cd CHeema-Text-to-Voice-MCP-Server

python -m venv venv
source venv/bin/activate        # Linux/macOS
# venv\Scripts\activate          # Windows

pip install -e .
pip install "mcp[cli]"

3. Connect to Your AI Assistant

Pick your platform and follow the steps below.

Setup by Platform

Claude Desktop

Add this to your config file:

• macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
• Windows: `%APPDATA%\Claude\claude_desktop_config.json`

{
  "mcpServers": {
    "cheema-tts": {
      "command": "/full/path/to/CHeema-Text-to-Voice-MCP-Server/venv/bin/python",
      "args": ["/full/path/to/CHeema-Text-to-Voice-MCP-Server/mcp_server.py"],
      "env": {}
    }
  }
}

Restart Claude Desktop. You'll see the TTS tools appear in the tools menu.

Claude Code

claude mcp add cheema-tts -- /full/path/to/venv/bin/python /full/path/to/mcp_server.py

Then just ask Claude to generate speech in any conversation.

n8n

Start the server in SSE mode:

cd CHeema-Text-to-Voice-MCP-Server
source venv/bin/activate
python mcp_server.py --transport sse --host 127.0.0.1 --port 8000

In your n8n workflow:

1. Add an AI Agent node with an MCP Client Tool

2. Set connection type to SSE

3. Enter the URL: `http://127.0.0.1:8000/sse`

4. The agent can now call any TTS tool

Any Other MCP Client

Start the server with your preferred transport:

# SSE (for web platforms and remote clients)
python mcp_server.py --transport sse --host 0.0.0.0 --port 8000

# Streamable HTTP
python mcp_server.py --transport streamable-http --host 0.0.0.0 --port 8000

Connect your MCP client to:

• SSE: `http://:8000/sse`
• HTTP: `http://:8000/mcp`

Available Voices

Use `tts_list_speakers` to see all voices including any custom ones you've added.

Voice Cloning

Clone any voice from a short audio sample:

1. Record or find a WAV file: 3 to 15 seconds of clean speech

2. Know the transcript: the exact words spoken in the recording

3. Ask your AI assistant:

> *"Add a new speaker called 'alex' from /path/to/recording.wav, with the transcript 'This is what I said in the recording'"*

Or call the tool directly:

tts_add_speaker(name="alex", wav_path="/path/to/recording.wav", ref_text="This is what I said in the recording")

Custom voices are saved permanently and available across restarts.

Tips for best results:

• Mono audio, 16-44 kHz sample rate
• 3-15 seconds of continuous, natural speech
• Minimal background noise

Available Tools

tts_synthesize Parameters

MCP Prompts (Templates)

These appear automatically in Claude Desktop's prompt picker.

Models

The default model (`neutts-nano`) works great on CPU. Larger models produce higher quality but need more resources.

Switch models using environment variables:

NEUTTS_BACKBONE="neuphonic/neutts-air" python mcp_server.py

Configuration

All settings are optional. Defaults work out of the box.

GPU Acceleration

For faster synthesis on NVIDIA GPUs:

NEUTTS_BACKBONE_DEVICE=cuda NEUTTS_CODEC_DEVICE=cuda python mcp_server.py

Requires PyTorch with CUDA support.

Running as a Service

For production use, create a systemd service so it starts automatically:

# /etc/systemd/system/cheema-tts.service
[Unit]
Description=Cheema Text-to-Voice MCP Server
After=network.target

[Service]
Type=simple
WorkingDirectory=/path/to/CHeema-Text-to-Voice-MCP-Server
ExecStart=/path/to/venv/bin/python mcp_server.py --transport sse --host 127.0.0.1 --port 8000
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now cheema-tts

To expose it over HTTPS, put an Nginx or Caddy reverse proxy in front with these key settings for SSE:

• Disable proxy buffering (`proxy_buffering off`)
• Set a long read timeout (`proxy_read_timeout 86400`)
• Add `X-Accel-Buffering: no` header

Troubleshooting

Server won't start?

• Check espeak-ng: `espeak-ng --version`
• Check dependencies: `pip list | grep -E "mcp|neutts|torch|soundfile"`

No audio output?

• Check the `output/` directory for WAV files
• Verify speaker name with `tts_list_speakers`

Slow first run?

• Normal: the first run downloads model weights from HuggingFace (~200-500MB). Cached after that.

Want GPU acceleration?

• Set `NEUTTS_BACKBONE_DEVICE=cuda` and `NEUTTS_CODEC_DEVICE=cuda`

How It Works

1. The server loads the NeuTTS backbone model and audio codec on startup

2. Speaker voice prints (`.pt` files) are loaded into memory

3. When you request speech, text is phonemized and combined with the speaker's voice reference

4. The model generates speech tokens, decoded into a 24kHz waveform

5. Output is saved as a standard WAV file

Project Structure

CHeema-Text-to-Voice-MCP-Server/
├── mcp_server.py       # MCP server entry point
├── neutts/             # NeuTTS engine
├── samples/            # Built-in speaker voices (.wav, .pt, .txt)
├── speakers/           # Custom cloned voices (auto-created)
├── output/             # Generated audio files (auto-created)
└── examples/           # Usage examples

Credits

• **NeuTTS** by Neuphonic, the TTS engine
• **MCP Protocol** by Anthropic, the AI tool standard

Author

Tayyab Ilyas, PhD Researcher & EdTech Founder

Building AI-powered tools for educators and researchers.

License

MIT License. The underlying NeuTTS models have their own licenses. See the NeuTTS repository for details.

Cheema Text-to-Voice MCP Server

Give your AI assistant a voice.