Introduction à la Transcription Temps Réel — Voxtral Audio — Transcription et 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-2602 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. Avec 4 milliards de paramètres, il reste assez compact pour un déploiement edge, et ses poids ouverts sous licence Apache 2.0, publiés sur le Hugging Face Hub, autorisent une installation entièrement souveraine sur vos propres serveurs. Sa couverture linguistique est identique à celle du modèle offline : 13 langues. Dernière conséquence pratique, l’API repose sur la programmation asynchrone, avec async/await et des itérateurs asynchrones.

Trois fonctionnalités du mode offline disparaissent en revanche, et il vaut mieux le savoir avant de concevoir votre application. La diarisation n’est pas disponible, parce qu’attribuer un tour de parole suppose d’avoir entendu la suite de la conversation, ce que le streaming interdit par construction. Le context biasing n’est pas supporté dans ce mode : vous ne pouvez pas injecter de vocabulaire métier pour guider la reconnaissance. Enfin, il n’y a pas de timestamps structurés — le texte arrive au fil de l’eau, sans horodatage par segment. Si votre besoin porte sur l’un de ces trois points, 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.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.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 import Mistral
from mistralai.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-2602",
        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 Realtime transcrit l’audio en streaming avec une latence sous 200 ms
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)
Pas de diarisation ni de context biasing en mode temps réel
Open weights Apache 2.0 pour un déploiement souverain