Crie um servidor MCP de texto para fala que dá ao Claude uma voz privada, rodando no seu próprio computador. Veja como funciona o modelo Kokoro, de 82 milhões de parâmetros, consiga um servidor em Python de cerca de 60 linhas, conecte-o ao Claude Desktop e ao Claude Code e compare com vozes hospedadas.
O Claude pode escrever um artigo de 2.000 palavras em menos de um minuto, e aí você passa dez minutos semicerrando os olhos para ler. Um servidor MCP de texto para fala fecha essa lacuna. O Claude chama uma ferramenta, um pequeno modelo de voz na sua própria máquina transforma o texto em áudio, e o resultado toca nos seus alto-falantes antes que o seu café esfrie.
O Kokoro é o modelo que torna isso prático. Ele tem apenas 82 milhões de parâmetros, é distribuído sob a licença Apache 2.0 e produz fala em 24 kHz que se sustenta ao lado de sistemas bem maiores. Não há cobrança de API, nem envio dos seus rascunhos para terceiros, nem limite de requisições. Este artigo mostra como as peças se conectam, oferece um servidor Python funcional de cerca de 60 linhas, integra tudo ao Claude Desktop e ao Claude Code e, depois, analisa com honestidade quando uma voz hospedada é a melhor escolha.
As vozes na nuvem soam ótimas, mas vêm com condições. Cada requisição sai da sua máquina, cada caractere é cobrado e cada queda do serviço vira uma queda sua. Um servidor local muda todos esses pontos.
Quando o Claude lê em voz alta um rascunho de contrato, uma entrada de diário particular ou uma especificação de produto ainda não lançada, o texto passa pelo seu servidor MCP e por mais nada. O Kokoro faz a inferência na sua CPU ou GPU, grava um arquivo WAV no disco, e o rastro termina aí. Uma ressalva honesta: o próprio Claude continua recebendo tudo o que você digita, então "local" descreve a etapa da voz, não a conversa inteira.
APIs de voz hospedadas costumam cobrar por caractere ou por minuto. Isso é aceitável para a abertura de um podcast e pesado para um agente que narra cada resposta o dia inteiro. Quando os pesos do Kokoro estiverem baixados, mais uma frase custa alguns segundos de eletricidade. Documentos longos, regravações repetidas e testes com vozes diferentes custam todos a mesma coisa: nada.
A primeira execução baixa o modelo do Hugging Face. Depois disso, o servidor funciona num avião, num porão ou atrás do firewall de uma empresa. A latência depende do seu hardware, não de uma ida e volta pela rede, então o comportamento continua idêntico às 3 da manhã e às 3 da tarde.
O Kokoro-82M é um modelo de texto para fala com pesos abertos, construído sobre a arquitetura StyleTTS 2 com um vocoder ISTFTNet. A versão 1.0 chegou em 27 de janeiro de 2025, depois de uma versão anterior em 25 de dezembro de 2024. Os autores treinaram o modelo com algumas centenas de horas de áudio sintético e de fontes com licença permissiva, e é por isso que a licença Apache 2.0 combina bem com projetos comerciais.
| Especificação | Valor |
|---|---|
| Parâmetros | 82 milhões |
| Licença | Apache 2.0 |
| Taxa de amostragem de saída | 24 kHz |
| Arquitetura | StyleTTS 2 com vocoder ISTFTNet |
| Vozes na v1.0 | 54 |
| Idiomas na v1.0 | 8 |
| Dependência do sistema | espeak-ng |
💡 Pequeno não significa fraco. O tamanho do Kokoro é o que permite rodar num notebook. Para a narração simples de textos em inglês, ele é difícil de distinguir de muitas vozes pagas numa escuta casual. A expressividade sob comando, como sussurrar ou rir, é onde os modelos hospedados maiores se destacam.
Os nomes das vozes seguem um padrão: a primeira letra indica o idioma ou sotaque, e a segunda, o gênero. af_heart é uma voz feminina em inglês americano, e bm_george é uma voz masculina em inglês britânico. O pipeline também precisa de um lang_code correspondente para que o texto seja convertido em fonemas corretamente.
| Código | Idioma | Vozes de exemplo |
|---|---|---|
a | Inglês americano | af_heart, am_michael |
b | Inglês britânico | bf_emma, bm_george |
e | Espanhol | ef_dora |
f | Francês | ff_siwis |
h | Hindi | hf_alpha |
i | Italiano | if_sara |
j | Japonês | jf_alpha |
p | Português brasileiro | pf_dora |
z | Chinês mandarim | zf_xiaobei |
O inglês americano e o britânico contam como um único idioma no número "8 idiomas". O japonês e o mandarim instalam pacotes extras da família misaki, então leia o README do projeto antes de ativá-los.
A configuração tem apenas três partes, e cada uma tem uma função bem definida:
O fluxo é curto. O Claude decide chamar speak, envia o texto junto com um nome de voz, o servidor sintetiza o áudio, toca-o e devolve o caminho do arquivo como texto simples, para que o Claude possa informar onde a gravação foi salva.
Você não precisa escrever tudo sozinho. Vários projetos da comunidade já empacotam o Kokoro para MCP:
Servidores prontos economizam uma tarde. Escrever o seu próprio, como abaixo, leva cerca de uma hora e dá controle total sobre a limpeza do texto, os valores padrão das vozes e o local onde os arquivos são salvos.
Use um ambiente virtual para que o conjunto de bibliotecas do PyTorch fique separado do Python do sistema. Python 3.10, 3.11 ou 3.12 é a escolha segura.
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install "kokoro>=0.9.2" soundfile sounddevice numpy "mcp[cli]"
O Kokoro também precisa do fonemizador espeak-ng no seu sistema:
brew install espeak-ngsudo apt-get install espeak-ng
Salve isto como kokoro_server.py. Ele expõe duas ferramentas, carrega o pipeline em inglês na inicialização, remove a marcação markdown do texto e reproduz o áudio sem bloquear o 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()
Três escolhas de design são importantes aqui. O pipeline fica em cache por idioma, então alternar entre inglês e espanhol não recarrega nada duas vezes. A reprodução usa sd.play, que retorna imediatamente, então o Claude nunca espera o áudio terminar. E nada no arquivo chama print, porque num servidor stdio a stdout pertence ao protocolo. Um print perdido corrompe o fluxo de mensagens.
Para o Claude Desktop, abra claude_desktop_config.json. No macOS ele fica em ~/Library/Application Support/Claude/, e no Windows em %APPDATA%\Claude\. Aponte o comando para o interpretador dentro do seu ambiente virtual, e não para um python puro.
{
"mcpServers": {
"kokoro-tts": {
"command": "/absolute/path/to/.venv/bin/python",
"args": ["/absolute/path/to/kokoro_server.py"]
}
}
}
Para o Claude Code, um único comando faz o mesmo trabalho:
claude mcp add kokoro-tts -- /absolute/path/to/.venv/bin/python /absolute/path/to/kokoro_server.py
Reinicie o cliente e teste com uma frase simples: "Use a ferramenta speak para dizer olá com a voz bm_george." Se você ouvir um cavalheiro britânico te cumprimentar, toda a cadeia funciona.
Texto que lê bem na tela muitas vezes soa desajeitado em voz alta. Dê ao Claude uma instrução permanente para que ele escreva pensando em quem vai ouvir desde o primeiro rascunho:
Quando eu pedir que você leia algo em voz alta, chame a ferramenta speak. Escreva para o ouvido: frases curtas, sem símbolos de marcadores, sem URLs, e escreva por extenso números ou siglas quando forem difíceis de falar.
A função clean_text do servidor é a sua rede de segurança, mas ela não consegue salvar uma frase que não tem pausas naturais. Alguns hábitos melhoram a saída de imediato:
Uma ferramenta de voz se justifica em momentos em que seus olhos ou suas mãos estão ocupados:
O Kokoro roda em uma CPU de notebook comum, e uma GPU ou o Apple Silicon o deixam ainda mais rápido. Em vez de confiar no benchmark de alguém, faça o seu próprio teste: envie um parágrafo de 200 palavras e compare o tempo de renderização com o tempo de reprodução. Se a renderização terminar primeiro, você tem folga em tempo real e documentos longos vão parecer instantâneos.
Dois hábitos mantêm a experiência fluida. Carregue o pipeline na inicialização, como faz o servidor acima, porque a primeira síntese é sempre a mais lenta. E mantenha o modelo residente: o cliente MCP mantém o processo do servidor ativo entre as chamadas, então os pesos ficam na memória.
💡 Dica: Rode o servidor uma vez pelo terminal antes de registrá-lo. Qualquer dependência ausente aparece como um erro legível do Python, em vez de um vago "server failed" no cliente.
| Sintoma | Causa provável | Correção |
|---|---|---|
| O cliente informa que o servidor não iniciou | A configuração aponta para o Python errado | Use o caminho absoluto para o interpretador do ambiente virtual |
| A chamada da ferramenta trava e depois dá erro | Uma chamada print escreveu na stdout | Remova os prints e registre os logs na stderr |
| Erro de fonema ou de espeak | O espeak-ng não está no PATH | Instale-o e depois abra um terminal novo |
| Arquivo salvo, mas sem som | Problema com o dispositivo de áudio ou com o PortAudio | Instale o PortAudio no Linux ou escolha um dispositivo em sounddevice |
| Nomes pronunciados de forma estranha | O fonemizador adivinhou errado | Reescreva o nome do jeito que ele soa |
O local nem sempre é a resposta. O Kokoro é excelente para narração privada, repetível e gratuita, mas alguns trabalhos exigem mais do que 54 vozes podem oferecer.
Recorra a um modelo hospedado quando precisar de clonagem de voz, amplo suporte a idiomas ou controle emocional refinado. A coleção de texto para fala na Picasso IA tem muitas opções, todas a um clique de distância:
| Fator | Kokoro local | Vozes hospedadas |
|---|---|---|
| Custo por frase | Apenas eletricidade | Cobrado por uso ou por plano |
| O texto sai da sua máquina | Não (etapa da voz) | Sim |
| Tempo de configuração | Cerca de uma hora | Minutos |
| Clonagem de voz | Não | Sim, em vários modelos |
| Alcance de idiomas | 8 idiomas | Até mais de 70 em alguns modelos |
| Funciona offline | Sim | Não |
Uma divisão sensata: use o Kokoro para a leitura do dia a dia, rascunhos e tudo o que for privado, e troque para uma voz hospedada na versão final de um vídeo, podcast ou demonstração de produto.
O servidor apenas fala. O que ele fala depende do modelo que escreve as palavras. Para rascunhos longos e reescrita cuidadosa, o Claude Sonnet 5 e o Claude Opus 4.7 são boas escolhas, enquanto o Claude 4.5 Haiku mantém as respostas faladas rápidas e objetivas. Combine o modelo com o trabalho e deixe o Kokoro cuidar da entrega.
Agora você tem uma voz privada para o Claude que não custa nada por frase. O próximo passo é dar um rosto aos seus projetos. Na mesma tarde em que você terminar este servidor, você pode criar miniaturas, cabeçalhos de artigos e arte de cenas na Picasso IA para acompanhar seu áudio.
Experimente o Seedream 4.5 para cenas fotorrealistas, ou o Flux 2 Pro quando quiser detalhes nítidos e uma composição limpa. Quando um projeto exigir uma voz de estúdio, teste o Speech 2.8 HD junto com a sua configuração local do Kokoro e compare os resultados pelo ouvido.
Abra a Picasso IA, escreva um prompt e veja o que você obtém. Depois tente um segundo com um ângulo de câmera diferente. Experimente à vontade, porque os melhores prompts vêm de testar, ouvir e ajustar.
Escolha seu idioma
