Introduction à la Transcription Temps Réel

Cours mis à jour le 3 novembre 2026 pour Voxtral 3, d’après le guide Migrate from Voxtral 2 de Mistral : les modèles Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), dépréciés le 31 octobre 2026 et retirés le 30 avril 2027, sont remplacés dans les exemples par voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 et voxtral-mini-tts-3-0. À connaître : horodatage par segment uniquement (word renvoie une erreur 400), diarisation possible en temps réel, réglages d’une session temps réel figés dès le premier morceau d’audio, entrées context_bias libres (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text.

Un nouveau paradigme : le streaming audio

Jusqu’à présent, vous avez travaillé en mode offline : vous envoyez un fichier audio complet, vous attendez que le modèle le traite, puis vous exploitez le résultat. Ce fonctionnement convient aux enregistrements déjà constitués, réunion archivée, podcast ou interview. Il devient inopérant dès que l’audio arrive en continu : personne n’attendra la fin d’une conférence de deux heures pour voir les premiers sous-titres, et un assistant vocal qui ne comprend la question qu’après un long silence semble en panne.

Voxtral Realtime répond à ce besoin avec une architecture streaming. L’audio est transcrit au fil de l’eau, mot par mot, et le délai entre le son et le texte devient un réglage que vous maîtrisez, jusqu’à descendre sous 200 millisecondes. Le changement est autant technique que mental : vous ne raisonnez plus en requêtes isolées mais en flux, et votre programme doit être prêt à recevoir du texte à n’importe quel instant.

Ce que propose le modèle Realtime

Le modèle s’invoque sous l’identifiant voxtral-mini-transcribe-realtime-3 et diffère en profondeur de son homologue offline. Il reçoit des chunks d’audio et émet des fragments de texte en continu, sans jamais attendre la fin de l’enregistrement. Sa latence se pilote par le paramètre target_streaming_delay_ms, que vous découvrirez en détail plus loin dans la formation. Il couvre 45 langues et dialectes, et la langue peut être fixée ou détectée. Son prédécesseur de génération 2, voxtral-mini-transcribe-realtime-2602 (4 milliards de paramètres), est publié en poids ouverts sous licence Apache 2.0 sur le Hugging Face Hub, pour une installation entièrement souveraine sur vos propres serveurs.

Avec Voxtral 3, le temps réel a comblé une bonne partie de son retard sur le mode offline. La diarisation y est disponible — mais pas dans la même session que la détection de fin de tour —, tout comme le context biasing et la détection de fin de tour. Deux différences demeurent : les segments portent le locuteur mais pas d’heure de début ni de fin, et tous les réglages de la session (langue, vocabulaire, diarisation, délai) doivent être envoyés avant le premier morceau d’audio, après quoi ils sont figés. Si votre besoin porte sur un horodatage précis, c’est le mode offline qu’il vous faut, éventuellement en complément du temps réel.

Installation

Le SDK Mistral ne charge pas les dépendances de streaming par défaut. Il faut demander explicitement l’extra realtime, qui apporte le support des connexions WebSocket et du traitement audio asynchrone :

pip install "mistralai[realtime]"

Le format audio imposé

Contrairement au mode offline, qui accepte une large gamme de conteneurs, Voxtral Realtime attend un flux brut dans un format unique et non négociable :

• Encodage : PCM 16 bits signé little-endian (pcm_s16le)
• Taux d’échantillonnage : 16 000 Hz (16 kHz)
• Canaux : Mono (1 canal)

Cette contrainte n’a rien de bloquant : ce format est le plus standard qui soit et tous les outils de capture le produisent nativement, qu’il s’agisse de PyAudio, de FFmpeg ou de PulseAudio. Vous le déclarez une fois pour toutes au client, qui s’en sert pour interpréter les octets que vous lui transmettez.

from mistralai.client.models import AudioFormat

# Définir le format audio
audio_format = AudioFormat(
    encoding="pcm_s16le",
    sample_rate=16000
)

Les deux événements du flux

Lorsque vous itérez sur la transcription, le SDK vous remet deux types d’objets. TranscriptionStreamTextDelta est émis à chaque nouveau fragment transcrit et porte le texte partiel que vous pouvez afficher immédiatement ; c’est lui qui alimente l’écran de l’utilisateur. TranscriptionStreamDone arrive une seule fois, quand le flux audio se termine, que ce soit la fin d’un fichier ou la fermeture du microphone ; il vous signale que plus rien ne viendra et que vous pouvez consolider le résultat. Toute votre logique tient donc dans une boucle asynchrone qui distingue ces deux cas :

from mistralai.client.models import (
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

async for event in flux_transcription:
    if isinstance(event, TranscriptionStreamTextDelta):
        # Nouveau texte disponible
        print(event.text, end="", flush=True)
    elif isinstance(event, TranscriptionStreamDone):
        # Transcription terminée
        print("\n[Terminé]")

Premier exemple complet

Pour vous familiariser avec le mécanisme sans dépendre d’un microphone, le plus simple est de simuler un flux à partir d’un fichier déjà converti en PCM. La fonction lire_fichier_pcm est un générateur asynchrone : elle lit le fichier par blocs et les livre un par un, exactement comme le ferait une carte son. Le reste du programme est celui que vous réutiliserez ensuite sans le modifier.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

async def lire_fichier_pcm(chemin: str, taille_chunk: int = 32000):
    """Lit un fichier PCM par chunks pour simuler un flux."""
    with open(chemin, "rb") as f:
        while True:
            chunk = f.read(taille_chunk)
            if not chunk:
                break
            yield chunk

async def main():
    flux_audio = lire_fichier_pcm("audio.pcm")

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=flux_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            print("\n\nTranscription terminée.")

asyncio.run(main())

Si votre fichier source est un MP3, il ne peut pas être envoyé tel quel : convertissez-le d’abord avec FFmpeg, en imposant les trois caractéristiques exigées par le modèle.

ffmpeg -i audio.mp3 -f s16le -acodec pcm_s16le -ar 16000 -ac 1 audio.pcm

Quand basculer en temps réel

Le critère de choix est simple : le temps réel se justifie quand quelqu’un attend le texte pendant que le son est produit. C’est le cas du sous-titrage en direct d’une conférence, d’un webinaire ou d’un cours en ligne, où le public lit en même temps qu’il écoute ; d’un assistant vocal, qui doit comprendre l’utilisateur pendant qu’il parle pour répondre sans blanc gênant ; de la dictée, où la parole devient du texte sous les yeux de celui qui parle ; de la transcription de conférence, enfin, quand le texte doit s’afficher au fur et à mesure. Partout ailleurs, le mode offline reste plus riche et plus simple à écrire.

Les leçons suivantes vous feront capturer le microphone, régler la latence et construire ces cas d’usage de bout en bout.

Points clés à retenir

• Voxtral Mini Transcribe Realtime 3 transcrit l’audio en streaming avec un délai réglable de 80 ms à 1,2 s (ou 2,4 s)
• Format audio requis : PCM 16 bits, 16 kHz, mono
• Deux types d’événements : TextDelta (texte partiel) et Done (fin)
• Installation avec pip install "mistralai[realtime]"
• Programmation asynchrone obligatoire (async/await)
• Diarisation (hors détection de fin de tour) et context biasing disponibles en temps réel, sans horodatage des segments ; réglages figés dès le premier audio
• La génération 2 du modèle temps réel est en open weights Apache 2.0, pour un déploiement souverain