Crea un servidor MCP de texto a voz que le da a Claude una voz privada que se ejecuta en tu propio equipo. Descubre cómo funciona el modelo Kokoro de 82 millones de parámetros, consigue un servidor en Python de 60 líneas, conéctalo a Claude Desktop y Claude Code, y compáralo con las voces alojadas en la nube.
Claude puede redactar un artículo de 2000 palabras en menos de un minuto, y luego tú pasas diez minutos entrecerrando los ojos para leerlo. Un servidor MCP de texto a voz acorta esa distancia. Claude llama a una herramienta, un pequeño modelo de voz en tu propio equipo convierte el texto en audio, y el resultado suena por tus altavoces antes de que se enfríe el café.
Kokoro es el modelo que hace esto práctico. Tiene solo 82 millones de parámetros, se distribuye bajo la licencia Apache 2.0 y produce voz a 24 kHz que aguanta la comparación con sistemas mucho más grandes. No hay factura de API, no hay subida de tus borradores a un tercero y no hay límite de uso. Este artículo muestra cómo encajan las piezas, te ofrece un servidor en Python funcional de unas 60 líneas, lo integra en Claude Desktop y Claude Code, y después analiza con honestidad cuándo es mejor opción una voz alojada.
Las voces en la nube suenan muy bien, pero tienen letra pequeña. Cada petición sale de tu equipo, cada carácter se cobra y cada caída del servicio se convierte en tu caída. Un servidor local da la vuelta a cada uno de esos puntos.
Cuando Claude lee en voz alta un contrato en borrador, una entrada de diario privada o una especificación de producto sin publicar, el texto pasa por tu servidor MCP y por nada más. Kokoro hace la inferencia en tu CPU o GPU, escribe un archivo WAV en el disco, y el rastro termina ahí. Una advertencia honesta: Claude sigue recibiendo todo lo que escribes, así que "local" describe el paso de la voz, no toda la conversación.
Las API de voz alojadas suelen cobrar por carácter o por minuto. Eso está bien para la introducción de un pódcast y resulta doloroso para un agente que narra cada respuesta todo el día. Una vez descargados los pesos de Kokoro, una frase más cuesta unos segundos de electricidad. Los documentos largos, las repeticiones y los experimentos con voces distintas cuestan todos lo mismo: nada.
El primer arranque descarga el modelo desde Hugging Face. Después, el servidor funciona en un avión, en un sótano o detrás del cortafuegos de una empresa. La latencia depende de tu hardware, no de un viaje de ida y vuelta por la red, así que el comportamiento es idéntico a las 3 de la madrugada y a las 3 de la tarde.
Kokoro-82M es un modelo de texto a voz de pesos abiertos construido sobre la arquitectura StyleTTS 2 con un vocoder ISTFTNet. La versión 1.0 llegó el 27 de enero de 2025, tras una publicación anterior el 25 de diciembre de 2024. Los autores entrenaron el modelo con unos pocos cientos de horas de audio sintético y con licencias permisivas, por eso la licencia Apache 2.0 encaja sin problemas con proyectos comerciales.
| Especificación | Valor |
|---|---|
| Parámetros | 82 millones |
| Licencia | Apache 2.0 |
| Frecuencia de muestreo de salida | 24 kHz |
| Arquitectura | StyleTTS 2 con vocoder ISTFTNet |
| Voces en la v1.0 | 54 |
| Idiomas en la v1.0 | 8 |
| Dependencia del sistema | espeak-ng |
💡 Pequeño no significa débil. El tamaño de Kokoro es lo que le permite funcionar en un equipo portátil. Para la narración sencilla de prosa en inglés, es difícil distinguirlo de muchas voces de pago en una escucha casual. La expresividad a demanda, como susurrar o reír, es donde los modelos alojados más grandes se adelantan.
Los nombres de las voces siguen un patrón: la primera letra indica el idioma o el acento, y la segunda, el género. af_heart es una voz femenina del inglés americano, y bm_george es una voz masculina del inglés británico. La canalización también necesita un lang_code correspondiente para que el texto se convierta en fonemas correctamente.
| Código | Idioma | Voces de ejemplo |
|---|---|---|
a | Inglés americano | af_heart, am_michael |
b | Inglés británico | bf_emma, bm_george |
e | Español | ef_dora |
f | Francés | ff_siwis |
h | Hindi | hf_alpha |
i | Italiano | if_sara |
j | Japonés | jf_alpha |
p | Portugués de Brasil | pf_dora |
z | Chino mandarín | zf_xiaobei |
El inglés americano y el británico cuentan como un solo idioma en la cifra de "8 idiomas". El japonés y el mandarín traen paquetes adicionales de la familia misaki, así que lee el README del proyecto antes de activarlos.
La configuración tiene solo tres piezas, y cada una tiene una tarea acotada:
El flujo es breve. Claude decide llamar a speak, envía el texto junto con el nombre de una voz, el servidor sintetiza el audio, lo reproduce y devuelve la ruta del archivo como texto plano para que Claude te diga dónde quedó la grabación.
No tienes que escribirlo todo tú. Varios proyectos de la comunidad ya envuelven Kokoro para MCP:
Los servidores preconfigurados ahorran una tarde. Escribir el tuyo, como se muestra a continuación, cuesta alrededor de una hora y te da control total sobre la limpieza del texto, las voces predeterminadas y el lugar donde se guardan los archivos.
Usa un entorno virtual para que las dependencias de PyTorch queden lejos del Python del sistema. Python 3.10, 3.11 o 3.12 es la opción segura.
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install "kokoro>=0.9.2" soundfile sounddevice numpy "mcp[cli]"
Kokoro también necesita el fonemizador espeak-ng en tu sistema:
brew install espeak-ngsudo apt-get install espeak-ng
Guárdalo como kokoro_server.py. Expone dos herramientas, carga la canalización en inglés al arrancar, elimina el markdown del texto y reproduce el audio sin bloquear a Claude.
import os
import re
import time
from pathlib import Path
import numpy as np
import sounddevice as sd
import soundfile as sf
from kokoro import KPipeline
from mcp.server.fastmcp import FastMCP
SAMPLE_RATE = 24000
OUT_DIR = Path(os.environ.get("KOKORO_OUT", Path.home() / "kokoro_audio"))
OUT_DIR.mkdir(parents=True, exist_ok=True)
mcp = FastMCP("kokoro-tts")
pipelines = {}
def get_pipeline(lang_code: str) -> KPipeline:
if lang_code not in pipelines:
pipelines[lang_code] = KPipeline(lang_code=lang_code)
return pipelines[lang_code]
def clean_text(text: str) -> str:
text = re.sub(r"`{3}.*?`{3}", " code block omitted. ", text, flags=re.S)
text = re.sub(r"https?://\S+", "link", text)
text = re.sub(r"[#*_`>]+", "", text)
return re.sub(r"[ \t]+", " ", text).strip()
@mcp.tool()
def speak(text: str, voice: str = "af_heart", speed: float = 1.0,
lang_code: str = "a", play: bool = True) -> str:
"""Read text aloud with Kokoro. Returns the path of the saved WAV file."""
pipeline = get_pipeline(lang_code)
parts = []
for _, _, audio in pipeline(clean_text(text), voice=voice, speed=speed):
if audio is not None:
parts.append(audio.detach().cpu().numpy())
if not parts:
return "No audio was produced. Check the text and the voice name."
wave = np.concatenate(parts)
path = OUT_DIR / f"speech_{time.strftime('%Y%m%d_%H%M%S')}.wav"
sf.write(path, wave, SAMPLE_RATE)
if play:
sd.play(wave, SAMPLE_RATE)
return f"Saved {len(wave) / SAMPLE_RATE:.1f}s of audio to {path}"
@mcp.tool()
def list_voices() -> str:
"""List a few Kokoro voices and the lang_code each one needs."""
return (
"a: af_heart, af_bella, am_michael | b: bf_emma, bm_george | "
"e: ef_dora | f: ff_siwis | j: jf_alpha"
)
if __name__ == "__main__":
get_pipeline("a")
mcp.run()
Tres decisiones de diseño importan aquí. La canalización se guarda en caché por idioma, así que cambiar entre inglés y español no recarga nada dos veces. La reproducción usa sd.play, que devuelve el control de inmediato, así que Claude nunca espera a que termine el audio. Y nada en el archivo llama a print, porque en un servidor stdio la salida estándar pertenece al protocolo. Un print suelto corrompe el flujo de mensajes.
Para Claude Desktop, abre claude_desktop_config.json. En macOS está en ~/Library/Application Support/Claude/, y en Windows, en %APPDATA%\Claude\. Apunta el comando al intérprete que está dentro de tu entorno virtual, no a un python sin más.
{
"mcpServers": {
"kokoro-tts": {
"command": "/absolute/path/to/.venv/bin/python",
"args": ["/absolute/path/to/kokoro_server.py"]
}
}
}
Para Claude Code, un solo comando hace el mismo trabajo:
claude mcp add kokoro-tts -- /absolute/path/to/.venv/bin/python /absolute/path/to/kokoro_server.py
Reinicia el cliente y prueba con una frase sencilla: "Usa la herramienta speak para decir hola con la voz bm_george". Si oyes a un caballero británico saludarte, toda la cadena funciona.
El texto que se lee bien en pantalla suele sonar torpe en voz alta. Dale a Claude una instrucción permanente para que escriba pensando en la escucha desde el primer borrador:
Cuando te pida que leas algo en voz alta, llama a la herramienta speak. Escribe para el oído: frases cortas, sin símbolos de viñeta, sin URL, y deletrea los números o las siglas cuando sean difíciles de pronunciar.
La función clean_text del servidor es tu red de seguridad, pero no puede salvar una frase que no tiene pausas naturales. Unos cuantos hábitos mejoran la salida de inmediato:
Una herramienta de voz se gana su sitio en los momentos en que tienes ocupados los ojos o las manos:
Kokoro funciona en la CPU de un equipo portátil corriente, y una GPU o Apple Silicon lo acelera todavía más. En lugar de fiarte del benchmark de nadie, haz tu propia prueba: envía un párrafo de 200 palabras y compara el tiempo de render con el tiempo de reproducción. Si el render termina antes, tienes margen para tiempo real y los documentos largos parecerán instantáneos.
Dos hábitos mantienen la experiencia fluida. Carga la canalización al arrancar, como hace el servidor de arriba, porque la primera síntesis siempre es la más lenta. Y mantén el modelo residente: el cliente MCP mantiene vivo el proceso del servidor entre llamadas, así que los pesos permanecen en memoria.
💡 Consejo: Ejecuta el servidor una vez desde una terminal antes de registrarlo. Cualquier dependencia que falte aparecerá como un error de Python legible, en lugar de un vago aviso de "el servidor falló" en el cliente.
| Síntoma | Causa probable | Solución |
|---|---|---|
| El cliente informa de que el servidor no pudo arrancar | La configuración apunta al Python equivocado | Usa la ruta absoluta al intérprete del entorno virtual |
| La llamada a la herramienta se queda colgada y luego da error | Una llamada a print escribió en stdout | Elimina los print y registra en stderr |
| Error de fonemas o de espeak | espeak-ng no está en el PATH | Instálalo y luego abre una terminal nueva |
| El archivo se guarda pero no hay sonido | Problema con el dispositivo de salida de audio o con PortAudio | Instala PortAudio en Linux, o elige un dispositivo en sounddevice |
| Algunos nombres se pronuncian raro | El fonemizador adivinó mal | Escribe el nombre como suena |
Lo local no siempre es la respuesta. Kokoro es excelente para narrar en privado, de forma repetible y gratuita, pero algunos trabajos necesitan más de lo que pueden ofrecer 54 voces.
Recurre a un modelo alojado cuando necesites clonación de voz, amplio soporte de idiomas o un control emocional fino. La colección de texto a voz de Picasso IA tiene muchas opciones, todas a un clic:
| Factor | Kokoro en local | Voces alojadas |
|---|---|---|
| Costo por frase | Solo electricidad | Por uso medido o según el plan |
| El texto sale de tu equipo | No (paso de voz) | Sí |
| Tiempo de configuración | Alrededor de una hora | Minutos |
| Clonación de voz | No | Sí, en varios modelos |
| Alcance de idiomas | 8 idiomas | Hasta más de 70 en algunos modelos |
| Funciona sin conexión | Sí | No |
Una división sensata: usa Kokoro para la lectura diaria, los borradores y todo lo privado, y cambia a una voz alojada para la toma final de un video, un pódcast o una demo de producto.
El servidor solo habla. Lo que dice depende del modelo que escribe las palabras. Para borradores largos y reescritura cuidadosa, Claude Sonnet 5 y Claude Opus 4.7 son buenas opciones, mientras que Claude 4.5 Haiku mantiene ágiles y rápidas las respuestas habladas. Elige el modelo según la tarea y deja que Kokoro se encargue de la entrega.
Ya tienes una voz privada para Claude que no cuesta nada por frase. El siguiente paso es darle cara a tus proyectos. La misma tarde en que termines este servidor, puedes crear miniaturas, cabeceras de artículos e ilustraciones de escena en Picasso IA para acompañar tu audio.
Prueba Seedream 4.5 para escenas fotorrealistas, o Flux 2 Pro cuando quieras detalle nítido y una composición limpia. Cuando un proyecto necesite una voz de estudio, prueba Speech 2.8 HD junto a tu configuración local de Kokoro y compara los resultados con el oído.
Abre Picasso IA, escribe un prompt y mira qué obtienes. Luego prueba un segundo con otro ángulo de cámara. Experimenta sin miedo, porque los mejores prompts salen de probar, escuchar y ajustar.
Elige tu idioma
