Créez un serveur MCP text to speech qui offre à Claude une voix privée, exécutée sur votre propre ordinateur. Découvrez comment fonctionne le modèle Kokoro de 82 millions de paramètres, récupérez un serveur Python de 60 lignes, connectez-le à Claude Desktop et Claude Code, et comparez-le aux voix hébergées.
Claude peut rédiger un article de 2 000 mots en moins d’une minute, puis vous passez dix minutes à le parcourir les yeux plissés. Un serveur MCP text to speech comble cet écart. Claude appelle un outil, un petit modèle vocal installé sur votre propre machine transforme le texte en audio, et le résultat se lit sur vos enceintes avant que votre café ne refroidisse.
Kokoro est le modèle qui rend cette approche concrète. Il ne compte que 82 millions de paramètres, est distribué sous licence Apache 2.0 et produit une parole à 24 kHz qui tient la comparaison avec des systèmes bien plus grands. Pas de facture d’API, pas d’envoi de vos brouillons à un tiers, et aucune limite de débit. Cet article montre comment les pièces s’assemblent, vous fournit un serveur Python fonctionnel d’environ 60 lignes, le relie à Claude Desktop et Claude Code, puis examine honnêtement les cas où une voix hébergée est le meilleur choix.
Les voix dans le cloud sonnent très bien, mais elles ne sont pas sans contreparties. Chaque requête quitte votre machine, chaque caractère est compté, et chaque panne devient la vôtre. Un serveur local inverse chacun de ces inconvénients.
Quand Claude lit à voix haute un projet de contrat, une entrée de journal intime ou une fiche produit non publiée, le texte passe par votre serveur MCP et nulle part ailleurs. Kokoro exécute l’inférence sur votre CPU ou votre GPU, écrit un fichier WAV sur le disque, et la piste s’arrête là. Une réserve honnête : Claude lui-même reçoit toujours tout ce que vous saisissez, donc « local » décrit l’étape vocale, et non toute la conversation.
Les API de voix hébergées facturent généralement au caractère ou à la minute. C’est acceptable pour l’intro d’un podcast, mais pénible pour un agent qui lit chaque réponse toute la journée. Une fois les poids de Kokoro téléchargés, une phrase de plus ne coûte que quelques secondes d’électricité. Les longs documents, les reprises répétées et les essais avec différentes voix ont tous le même coût : rien.
Le premier lancement télécharge le modèle depuis Hugging Face. Ensuite, le serveur fonctionne dans un avion, dans un sous-sol ou derrière un pare-feu d’entreprise. La latence dépend de votre matériel et non d’un aller-retour réseau, le comportement reste donc identique à 3 h du matin comme à 3 h de l’après-midi.
Kokoro-82M est un modèle de synthèse vocale à poids ouverts, construit sur l’architecture StyleTTS 2 avec un vocodeur ISTFTNet. La version 1.0 est sortie le 27 janvier 2025, après une première publication le 25 décembre 2024. Les auteurs ont entraîné le modèle sur quelques centaines d’heures d’audio sous licence permissive et d’audio synthétique, ce qui explique que la licence Apache 2.0 convienne parfaitement aux projets commerciaux.
| Spécification | Valeur |
|---|---|
| Paramètres | 82 millions |
| Licence | Apache 2.0 |
| Fréquence d’échantillonnage en sortie | 24 kHz |
| Architecture | StyleTTS 2 avec vocodeur ISTFTNet |
| Voix dans la v1.0 | 54 |
| Langues dans la v1.0 | 8 |
| Dépendance système | espeak-ng |
💡 Petit ne veut pas dire faible. La taille de Kokoro lui permet de tourner sur un ordinateur portable. Pour la narration simple d’une prose anglaise, il est difficile à distinguer de nombreuses voix payantes à l’écoute distraite. L’expressivité à la demande, comme chuchoter ou rire, est le domaine où les grands modèles hébergés prennent l’avantage.
Les noms des voix suivent un schéma : la première lettre indique la langue ou l’accent, la seconde le genre. af_heart est une voix féminine en anglais américain, et bm_george une voix masculine en anglais britannique. Le pipeline a aussi besoin d’un lang_code correspondant pour que le texte soit correctement transformé en phonèmes.
| Code | Langue | Exemples de voix |
|---|---|---|
a | Anglais américain | af_heart, am_michael |
b | Anglais britannique | bf_emma, bm_george |
e | Espagnol | ef_dora |
f | Français | ff_siwis |
h | Hindi | hf_alpha |
i | Italien | if_sara |
j | Japonais | jf_alpha |
p | Portugais brésilien | pf_dora |
z | Mandarin | zf_xiaobei |
L’anglais américain et l’anglais britannique comptent pour une seule langue dans le chiffre « 8 langues ». Le japonais et le mandarin installent des paquets supplémentaires de la famille misaki, donc lisez le README du projet avant de les activer.
L’installation ne comporte que trois pièces, chacune avec un rôle précis :
Le déroulement est court. Claude décide d’appeler speak, envoie le texte accompagné d’un nom de voix, le serveur synthétise l’audio, le joue, puis renvoie le chemin du fichier en texte brut afin que Claude puisse vous indiquer où l’enregistrement a été sauvegardé.
Vous n’avez pas à tout écrire vous-même. Plusieurs projets communautaires encapsulent déjà Kokoro pour MCP :
Les serveurs préconstruits font gagner une après-midi. Écrire le vôtre, comme ci-dessous, prend environ une heure et vous donne un contrôle total sur le nettoyage du texte, les voix par défaut et l’emplacement des fichiers.
Utilisez un environnement virtuel pour que la pile PyTorch reste à l’écart de votre Python système. Python 3.10, 3.11 ou 3.12 est le choix sûr.
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install "kokoro>=0.9.2" soundfile sounddevice numpy "mcp[cli]"
Kokoro nécessite aussi le phonétiseur espeak-ng sur votre système :
brew install espeak-ngsudo apt-get install espeak-ng
Enregistrez ceci sous kokoro_server.py. Il expose deux outils, charge le pipeline anglais au démarrage, retire le markdown du texte et lit l’audio sans bloquer 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()
Trois choix de conception comptent ici. Le pipeline est mis en cache par langue, donc passer de l’anglais à l’espagnol ne recharge rien deux fois. La lecture utilise sd.play, qui rend la main immédiatement, si bien que Claude n’attend jamais la fin de l’audio. Et rien dans le fichier n’appelle print, car sur un serveur stdio, stdout appartient au protocole. Un print égaré corrompt le flux de messages.
Pour Claude Desktop, ouvrez claude_desktop_config.json. Sur macOS il se trouve dans ~/Library/Application Support/Claude/, et sur Windows dans %APPDATA%\Claude\. Faites pointer la commande vers l’interpréteur situé dans votre environnement virtuel, et non vers un simple python.
{
"mcpServers": {
"kokoro-tts": {
"command": "/absolute/path/to/.venv/bin/python",
"args": ["/absolute/path/to/kokoro_server.py"]
}
}
}
Pour Claude Code, une seule commande fait le même travail :
claude mcp add kokoro-tts -- /absolute/path/to/.venv/bin/python /absolute/path/to/kokoro_server.py
Redémarrez le client, puis testez avec une phrase simple : « Utilisez l’outil speak pour dire bonjour avec la voix bm_george. » Si vous entendez un gentleman britannique vous saluer, toute la chaîne fonctionne.
Un texte qui se lit bien à l’écran sonne souvent maladroitement à voix haute. Donnez à Claude une consigne permanente pour qu’il écrive pour l’écoute dès le premier jet :
Quand je vous demande de lire quelque chose à voix haute, appelez l’outil speak. Écrivez pour l’oreille : phrases courtes, pas de puces, pas d’URL, et écrivez en toutes lettres les nombres ou les acronymes lorsqu’ils sont difficiles à prononcer.
La fonction clean_text du serveur est votre filet de sécurité, mais elle ne peut pas sauver une phrase qui n’a aucune pause naturelle. Quelques habitudes améliorent immédiatement le résultat :
Un outil vocal se justifie dans les moments où vos yeux ou vos mains sont occupés :
Kokoro tourne sur le processeur d’un ordinateur portable ordinaire, et un GPU ou une puce Apple Silicon l’accélère encore. Plutôt que de faire confiance au benchmark de quelqu’un d’autre, faites votre propre test : envoyez un paragraphe de 200 mots et comparez le temps de rendu au temps de lecture. Si le rendu se termine en premier, vous disposez d’une marge en temps réel et les longs documents paraîtront instantanés.
Deux habitudes gardent une expérience fluide. Chargez le pipeline au démarrage, comme le fait le serveur ci-dessus, car la première synthèse est toujours la plus lente. Et gardez le modèle en mémoire : le client MCP maintient votre processus serveur en vie entre les appels, si bien que les poids restent en mémoire.
💡 Astuce : lancez le serveur une fois depuis un terminal avant de l’enregistrer. Toute dépendance manquante apparaît sous forme d’erreur Python lisible, au lieu d’un vague bandeau « server failed » dans le client.
| Symptôme | Cause probable | Solution |
|---|---|---|
| Le client indique que le serveur n’a pas réussi à démarrer | La configuration pointe vers le mauvais Python | Utilisez le chemin absolu de l’interpréteur de l’environnement virtuel |
| L’appel d’outil se bloque, puis renvoie une erreur | Un appel print a écrit sur stdout | Supprimez les print et journalisez sur stderr à la place |
| Erreur de phonème ou d’espeak | espeak-ng n’est pas dans le PATH | Installez-le, puis ouvrez un nouveau terminal |
| Fichier enregistré mais aucun son | Problème de périphérique de sortie audio ou de PortAudio | Installez PortAudio sous Linux, ou choisissez un périphérique dans sounddevice |
| Noms mal prononcés | Le phonétiseur a deviné à tort | Réécrivez le nom comme il se prononce |
Le local n’est pas toujours la bonne réponse. Kokoro est excellent pour une narration privée, reproductible et gratuite, mais certains travaux demandent plus que ce que 54 voix peuvent offrir.
Tournez-vous vers un modèle hébergé lorsque vous avez besoin de clonage vocal, d’une large couverture linguistique ou d’un contrôle émotionnel fin. La collection de synthèse vocale sur Picasso IA propose de nombreuses options, à un clic :
| Critère | Kokoro en local | Voix hébergées |
|---|---|---|
| Coût par phrase | Électricité uniquement | Facturé à l’usage ou par forfait |
| Le texte quitte votre machine | Non (étape vocale) | Oui |
| Temps de mise en place | Environ une heure | Quelques minutes |
| Clonage vocal | Non | Oui, sur plusieurs modèles |
| Couverture linguistique | 8 langues | Plus de 70 sur certains modèles |
| Fonctionne hors ligne | Oui | Non |
Une répartition raisonnable : utilisez Kokoro pour la lecture quotidienne, les brouillons et tout ce qui est privé, et passez à une voix hébergée pour la version finale d’une vidéo, d’un podcast ou d’une démo de produit.
Le serveur ne fait que parler. Ce qu’il dit dépend du modèle qui rédige les mots. Pour les longs brouillons et les réécritures soignées, Claude Sonnet 5 et Claude Opus 4.7 sont de bons choix, tandis que Claude 4.5 Haiku garde les réponses orales rapides et vives. Choisissez le modèle en fonction de la tâche, puis laissez Kokoro gérer la diction.
Vous disposez maintenant d’une voix privée pour Claude qui ne coûte rien par phrase. L’étape suivante consiste à donner un visage à vos projets. Le jour même où vous terminez ce serveur, vous pouvez créer des miniatures, des visuels d’articles et des illustrations de scènes sur Picasso IA pour les accompagner de votre audio.
Essayez Seedream 4.5 pour des scènes photoréalistes, ou Flux 2 Pro lorsque vous voulez des détails nets et une composition propre. Quand un projet demande une voix de studio, testez Speech 2.8 HD en parallèle de votre installation locale de Kokoro et comparez les résultats à l’oreille.
Ouvrez Picasso IA, écrivez un prompt et voyez ce que vous obtenez. Puis essayez-en un second avec un angle de caméra différent. Expérimentez librement, car les meilleurs prompts naissent de l’essai, de l’écoute et de l’ajustement.
Choisissez votre langue
