Streaming en temps réel
Op deze pagina
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 le streaming change tout
Jusqu’à présent, vous avez travaillé en mode synchrone : vous envoyez le texte, attendez la fin complète de la synthèse, puis recevez le fichier audio intégral. 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é.
Le streaming é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 de génération total 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 vous concernent :
speech.audio.delta: contient un fragment audio en base64. C’est l’événement principal que vous traiterez.speech.audio.done: signal de fin, la génération est terminée.
Côté code, passer au streaming 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 s’appuiera.
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, cessez d’accumuler et écrivez 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, vous l’envoyez à un flux de sortie ouvert au préalable, configuré en mono Float32 à 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 vous lisez 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 effectuées avec Voxtral 2, à refaire avec Voxtral TTS 3 — au prix d’un débit élevé. L’Opus perd un peu en latence mais compresse fortement, ce qui en fait le bon compromis lorsque vos utilisateurs sont sur mobile.
Belangrijkste punten
- Le streaming envoie l’audio fragment par fragment durant la génération
- Activez-le 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 le streaming (~0,7 s contre ~2 s pour le MP3)
- Pour une lecture en temps réel, utilisez
pyaudioou WebSockets + Web Audio API