Diffusion en temps réel
Šajā lapā
Cours mis à jour le 3 novembre 2026 pour Voxtral TTS 3, sur la base du guide Migrate from Voxtral 2 et des pages Text to Speech de Mistral :
voxtral-mini-tts-2603, déprécié le 31 octobre 2026 et retiré le 30 avril 2027, est remplacé dans les exemples parvoxtral-mini-tts-3-0. Les voix prédéfinies de Voxtral 2 (gb_jane_neutral…) restent prises en charge ; Voxtral 3 ajoute les balises[emotion=…]et[pace=…]dans le texte, le paramètreexpressiveness, la prononciation personnalisée (phoneme_hints) et 35 langues. Mistral recommande de remesurer la latence après la migration. Sources : Migrate from Voxtral 2 · Speech generation.
Pourquoi la diffusion change tout
Jusqu’à présent, tu as travaillé en mode synchrone : tu envoies le texte, tu attends la fin complète de la synthèse, puis tu reçois le fichier audio entier. Pour une salutation pré-générée la veille, cette attente importe peu. Pour un assistant vocal répondant à un client au téléphone, c’est rédhibitoire : deux secondes de silence après une question et l’utilisateur pense que l’appel a coupé.
La diffusion élimine cette attente. L’audio est expédié au fur et à mesure de sa génération, fragment par fragment, de sorte que l’utilisateur entend les premiers mots tandis que le modèle produit encore la fin de la phrase. Le temps total de génération ne change pas ; c’est le délai avant le premier son qui s’effondre.
Le protocole d’événements
Le flux repose sur les Server-Sent Events. Chaque message reçu est un événement typé, et deux types te concernent :
speech.audio.delta: contient un fragment audio en base64. C’est l’événement principal que tu vas gérer.speech.audio.done: signal de fin — la génération est terminée.
Côté code, passer à la diffusion signifie ajouter stream=True et consommer la réponse dans un bloc with. L’exemple suivant accumule les fragments en mémoire pour écrire un fichier à la fin : ce n’est pas encore du temps réel, mais c’est la structure de boucle sur laquelle le reste de la leçon va s’appuyer.
import base64
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
audio_chunks = []
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="Streaming makes voice agents responsive and natural.",
voice_id="your-voice-id",
response_format="opus",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
chunk = base64.b64decode(event.data.audio_data)
audio_chunks.append(chunk)
print(f"Chunk received: {len(chunk)} bytes")
# Assemble all chunks
audio_complet = b"".join(audio_chunks)
Path("streaming-output.opus").write_bytes(audio_complet)
print(f"Final audio: {len(audio_complet)} bytes")
Lire le son à mesure qu’il arrive
Pour obtenir la réactivité promise, cesse d’accumuler et écris chaque fragment directement sur la carte son. Avec pyaudio, le changement tient en une ligne : au lieu d’ajouter le fragment décodé à une liste, tu l’envoies à un flux de sortie ouvert au préalable, configuré pour du Float32 mono à 24 000 Hz.
import base64
import pyaudio
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# PCM audio configuration (fastest format)
p = pyaudio.PyAudio()
stream_audio = p.open(
format=pyaudio.paFloat32,
channels=1,
rate=24000,
output=True,
)
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="You're hearing this sentence while I generate it.",
voice_id="your-voice-id",
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
audio_data = base64.b64decode(event.data.audio_data)
stream_audio.write(audio_data)
stream_audio.stop_stream()
stream_audio.close()
p.terminate()
Le format demandé est passé de opus à pcm, et cela compte. Le PCM ne nécessite aucun décodage : les octets reçus sont prêts à être lus immédiatement, ce qui en fait le format recommandé pour un usage en temps réel.
Relayer le flux vers un navigateur
Dans une application web, le serveur ne lit pas le son : il le relaie. Le schéma classique utilise un WebSocket qui reçoit le texte du navigateur, ouvre le flux Voxtral et pousse chaque fragment décodé vers le client. Côté navigateur, l’API Web Audio prend le relais pour lire les fragments PCM reçus.
# Server side (FastAPI example)
from fastapi import FastAPI, WebSocket
import base64
from mistralai.client import Mistral
app = FastAPI()
client = Mistral(api_key="your-api-key")
@app.websocket("/ws/tts")
async def tts_websocket(websocket: WebSocket):
await websocket.accept()
texte = await websocket.receive_text()
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=texte,
voice_id="your-voice-id",
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
await websocket.send_bytes(
base64.b64decode(event.data.audio_data)
)
await websocket.close()
Le paramètre qui fait la différence : le tampon
La taille des fragments varie et représente généralement quelques millisecondes d’audio chacun. Si tu lis le premier fragment dès son arrivée, la moindre irrégularité du réseau provoque une micro-coupure audible — un hoquet dans la voix qui trahit immédiatement la machine. La solution consiste à mettre en tampon deux ou trois fragments avant de démarrer la lecture, ce qui coûte quelques dizaines de millisecondes et lisse le reste du flux.
Ensuite, il y a le choix du format, qui arbitre entre latence et bande passante. Le PCM délivre le premier son le plus rapidement — environ 0,7 seconde selon les mesures faites avec Voxtral 2, à refaire avec Voxtral TTS 3 — au prix d’un débit élevé. Opus perd un peu en latence mais compresse fortement, ce qui en fait le bon compromis lorsque tes utilisateurs sont sur mobile.
Galvenās atziņas
- La diffusion envoie l’audio fragment par fragment pendant la génération
- Active-la avec
stream=Truedans l’appelaudio.speech.complete() - Les événements
speech.audio.deltacontiennent des fragments audio en base64 - Le format PCM offre la latence la plus faible pour la diffusion (~0,7 s contre ~2 s pour le MP3)
- Pour la lecture en temps réel, utilise
pyaudioou WebSockets + Web Audio API