Introduction à la Transcription Temps Réel

Un nouveau paradigme : le streaming audio

Jusqu’ici, vous avez travaillé en mode offline : envoyer un fichier audio complet, attendre la transcription, exploiter le résultat. C’est parfait pour les fichiers enregistrés, mais insuffisant lorsque l’audio arrive en continu — dictée vocale, sous-titrage en direct, assistant vocal.

Voxtral Realtime résout ce problème avec une architecture streaming : l’audio est transcrit au fil de l’eau, mot par mot, avec une latence configurable pouvant descendre sous 200 millisecondes.

Voxtral Realtime : caractéristiques

Identifiant API : voxtral-mini-transcribe-realtime-2602

Le modèle Voxtral Realtime est fondamentalement différent du modèle offline :

• Architecture streaming — Le modèle reçoit des chunks d’audio et émet des fragments de texte en continu
• Ultra-faible latence — Configurable via target_streaming_delay_ms, peut descendre sous 200 ms
• 4 milliards de paramètres — Compact pour un déploiement edge
• Open weights — Licence Apache 2.0, disponible sur Hugging Face Hub
• 13 langues — Même couverture linguistique que le modèle offline
• Programmation asynchrone — L’API utilise async/await et des itérateurs asynchrones

Ce que Voxtral Realtime ne fait pas

• Pas de diarisation — Incompatible avec le streaming temps réel
• Pas de context biasing — Non supporté dans ce mode
• Pas de timestamps structurés — Le texte arrive au fil de l’eau sans horodatage par segment

Installation

Le SDK Mistral nécessite l’extra realtime pour le support du streaming :

pip install "mistralai[realtime]"

Cet extra installe les dépendances nécessaires pour les connexions WebSocket et le traitement audio asynchrone.

Format audio requis

Voxtral Realtime attend un flux audio dans un format spécifique :

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

Ce format est standard et supporté par tous les outils de capture audio (PyAudio, FFmpeg, PulseAudio, etc.).

from mistralai.models import AudioFormat

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

Les événements du streaming

Lorsque vous itérez sur le flux de transcription, vous recevez deux types d’événements :

TranscriptionStreamTextDelta

Émis à chaque nouveau fragment de texte transcrit. Contient le texte partiel que vous pouvez afficher immédiatement.

TranscriptionStreamDone

Émis lorsque le flux audio est terminé (fin du fichier ou fermeture du microphone). Signal de fin de transcription.

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

Voici un exemple minimal qui transcrit un fichier audio en mode streaming :

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())

Convertir un MP3 en PCM

Si votre fichier source est en MP3, convertissez-le d’abord en PCM avec FFmpeg :

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

Quand utiliser le mode temps réel

• Sous-titrage en direct — Conférences, webinaires, cours en ligne
• Assistant vocal — Comprendre l’utilisateur pendant qu’il parle
• Dictée — Transcrire la parole en texte en temps réel
• Transcription de conférence — Afficher le texte au fur et à mesure

Dans les leçons suivantes, vous apprendrez à capturer le microphone, contrôler la latence et implémenter des cas d’usage complets.

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