Optimisation de la latence
Sellel lehel
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.
La latence : l’ennemie de la conversation naturelle
Dans une conversation humaine, le temps de réponse moyen se situe autour de 200 millisecondes. Au-delà de 500 ms, ton interlocuteur perçoit un délai ; au-delà d’une seconde, il suppose que tu ne l’as pas entendu et répète sa question. Pour qu’un assistant vocal paraisse naturel, le temps écoulé entre la fin de la question et le début de la réponse doit rester inférieur à une seconde.
Voxtral annonce une latence modèle d’environ 90 ms, et c’est là que de nombreuses équipes se trompent : ce chiffre ne décrit qu’un maillon d’une chaîne bien plus longue. Ce que l’utilisateur ressent est la somme de tous les maillons. L’optimisation exige donc de connaître le coût de chaque composant.
Anatomie de la latence totale
Le trajet commence par le réseau sortant : le temps nécessaire pour acheminer ta requête vers les serveurs de Mistral. Cela dépend de ta localisation et de la qualité de ta connexion ; depuis l’Europe, compte entre 20 et 80 ms. Vient ensuite la latence du modèle, ces fameux 90 ms de traitement avant le premier fragment audio — la seule partie sur laquelle tu n’as aucun contrôle, car elle appartient à l’infrastructure de Mistral.
L’étape suivante est l’encodage, et c’est là que se cachent les pires surprises. Le PCM ne coûte rien, ou presque, car il n’y a rien à encoder. L’Opus ajoute 5 à 10 ms, ce qui reste négligeable. Le MP3, en revanche, exige 200 à 500 ms : son codec doit accumuler suffisamment de données avant de produire la première trame. Autrement dit, un développeur qui laisse response_format="mp3" par habitude ajoute plus de délai de son côté que l’ensemble du modèle.
Enfin, le réseau de retour pèse peu en streaming car les fragments sont petits. Il reste le tampon côté client : ton application accumule généralement deux ou trois fragments avant de lancer la lecture pour éviter les micro-coupures. Ajoute 50 à 150 ms — un coût délibéré qui achète de la fluidité.
Streaming contre Batch : les chiffres
| Métrique | Batch (sans streaming) | Streaming PCM | Streaming MP3 |
|---|---|---|---|
| Premier son | 1-3 secondes | ~0,7 seconde | ~2 secondes |
| Latence perçue | Élevée | Très faible | Moyenne |
| Bande passante | Pic unique | Distribuée | Distribuée |
Ces ordres de grandeur ont été enregistrés avec Voxtral 2. Mistral annonce environ 90 ms avant le premier son pour Voxtral TTS 3 côté modèle, et recommande de remesurer la latence depuis ton application après la migration : refais ces mesures avec ton réseau et ton format.
Passer du batch au streaming PCM divise la latence perçue par trois ou quatre. Aucune autre optimisation dans cette leçon n’aura un effet comparable : c’est la première chose à changer, même avant de mesurer.
Trois leviers côté serveur
Le premier levier est le format. Pour toute application conversationnelle, le streaming PCM est le paramètre de référence, et le changement s’opère sans réécrire ta logique.
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=text,
voice_id=voice_id,
response_format="pcm", # Latence minimale
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
play_audio(base64.b64decode(event.data.audio_data))
Le deuxième levier réside dans le choix entre une voix enregistrée et un clonage à la volée. Un voice_id désigne une voix déjà traitée côté serveur, tandis que ref_audio force le retraitement de l’échantillon à chaque requête. Pour un agent répondant cent fois par heure avec la même voix, ce détail économise 50 à 100 ms par tour de parole.
Le troisième levier consiste à raccourcir ce que tu demandes. Plus le texte est court, plus le premier fragment arrive vite : générer une réponse de cinq phrases en un seul bloc signifie faire attendre l’utilisateur pour un contenu qu’il n’entendra pas avant quinze secondes. Le générateur suivant découpe la réponse phrase par phrase et produit l’audio pour la première pendant que les autres attendent.
def generate_by_sentence(full_text, voice_id):
"""Génère l'audio phrase par phrase pour minimiser la latence."""
sentences = full_text.split(". ")
for sentence in sentences:
sentence = sentence.strip()
if not sentence:
continue
if not sentence.endswith("."):
sentence += "."
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=sentence,
voice_id=voice_id,
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
yield base64.b64decode(event.data.audio_data)
Deux leviers côté client
Un tampon fixe est toujours un compromis mal placé : trop petit, il laisse passer des micro-coupures sur un réseau chargé ; trop grand, il ajoute un délai inutile sur une bonne connexion. La classe ci-dessous lance la lecture dès que deux fragments sont disponibles, puis laisse passer les suivants au fur et à mesure qu’ils arrivent, sans jamais accumuler au-delà de cinq.
class AdaptiveBuffer:
def __init__(self):
self.buffer = []
self.min_threshold = 2 # Nombre minimum de chunks avant lecture
self.max_threshold = 5 # Ne pas accumuler davantage
self.playback_started = False
def add_chunk(self, chunk):
self.buffer.append(chunk)
if not self.playback_started:
if len(self.buffer) >= self.min_threshold:
self.playback_started = True
return self.empty_buffer()
else:
return chunk
return None
def empty_buffer(self):
data = b"".join(self.buffer)
self.buffer = []
return data
Le deuxième levier ne coûte que quelques lignes : envoie une requête de test au démarrage de ton application. Cela établit la connexion TCP et la poignée de main TLS une fois pour toutes, et le keep-alive HTTP permet à toutes les requêtes suivantes de bénéficier de cette préparation. Sans cet échauffement, ton premier utilisateur de la journée en paie le prix.
Mesurer avant d’optimiser
Toutes ces estimations doivent être validées sur ta configuration réelle. La mesure minimale consiste à chronométrer le délai jusqu’à la réception du premier fragment, puis à sortir de la boucle : c’est ce chiffre, et non la durée totale, qui correspond à ce que l’utilisateur ressent.
import time
t0 = time.perf_counter()
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="Latency test.",
voice_id=voice_id,
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
t1 = time.perf_counter()
print(f"First chunk received in {(t1 - t0)*1000:.0f} ms")
break
Exécute cette mesure depuis ton serveur de production, pas depuis ton poste de travail : la différence réseau suffit souvent à expliquer l’écart entre une démo convaincante et un déploiement décevant.
Peamised punktid
- La latence totale inclut le réseau, le modèle (~90 ms), l’encodage et le tampon client
- Le format PCM offre la latence la plus faible car il n’y a pas d’encodage
- Le streaming réduit la latence perçue d’un facteur 3 à 4 par rapport au batch
- Utilise un
voice_idplutôt queref_audiopour économiser 50-100 ms - Génère phrase par phrase pour minimiser le temps jusqu’au premier son