Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Inleiding tot realtime transcriptie

Les 9 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Een nieuw paradigma: audiostreaming
  2. Wat het realtime model biedt
  3. Installatie
  4. Het vereiste audioformaat
  5. De twee stream-events
  6. Eerst volledig voorbeeld
  7. Wanneer overstappen op realtime
  8. Belangrijkste punten

Cursus bijgewerkt op 3 november 2026 voor Voxtral 3, gebaseerd op de gids Migrate from Voxtral 2 van Mistral: Voxtral 2-modellen (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, verouderd op 31 oktober 2026 en buiten gebruik gesteld op 30 april 2027) worden in de voorbeelden vervangen door voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 en voxtral-mini-tts-3-0. Belangrijkste wijzigingen: tijdstempels zijn alleen beschikbaar per segment (word geeft een 400-fout), sprekerherkenning (diarization) is beschikbaar in realtime, sessie-instellingen voor realtime worden vergrendeld na het eerste audioblok, en context_bias-invoer is vrij vormgegeven (zinnen met spaties). Bronnen: Migrate from Voxtral 2 · Speech to Text.

Een nieuw paradigma: audiostreaming

Tot nu toe heeft u gewerkt in de offline modus: u stuurt een compleet audiobestand, wacht tot het model dit heeft verwerkt en gebruikt vervolgens het resultaat. Deze workflow is geschikt voor bestaande opnames, zoals gearchiveerde vergaderingen, podcasts of interviews. Het faalt echter wanneer audio continu binnenkomt: niemand wacht tot het einde van een conferentie van twee uur om de eerste ondertiteling te zien, en een spraakassistent die een vraag pas begrijpt na een lange stilte, lijkt defect.

Voxtral Realtime speelt hierop in met een streaming architectuur. Audio wordt on-the-fly getranscribeerd, woord voor woord, en de vertraging tussen geluid en tekst wordt een instelling die u beheert, tot wel 200 milliseconden. Deze verschuiving is zowel mentaal als technisch: u denkt niet langer in geïsoleerde verzoeken, maar in streams, en uw programma moet klaar zijn om op elk moment tekst te ontvangen.

Wat het realtime model biedt

Het model wordt aangeroepen onder de identificatie voxtral-mini-transcribe-realtime-3 en verschilt fundamenteel van zijn offline tegenhanger. Het ontvangt audioblokken en zendt continu tekstfragmenten uit, zonder te wachten tot de opname eindigt. De latentie wordt geregeld door de parameter target_streaming_delay_ms, die u later in deze cursus gedetailleerd zult verkennen. Het bestrijkt 45 talen en dialecten; de taal kan worden vastgelegd of automatisch gedetecteerd. De voorganger uit Generatie 2, voxtral-mini-transcribe-realtime-2602 (4 miljard parameters), is gepubliceerd als open weights onder de Apache 2.0-licentie op de Hugging Face Hub voor volledig soevereine installatie op uw eigen servers.

Met Voxtral 3 heeft de realtime prestatie de kloof met de offline modus grotendeels gedicht. Sprekerherkenning (diarization) is beschikbaar—hoewel niet in dezelfde sessie als detectie van het einde van een beurt—net als context biasing en detectie van het einde van een beurt. Twee verschillen blijven bestaan: segmenten dragen het sprekerslabel maar geen start- of eindtijd, en alle sessie-instellingen (taal, vocabulaire, sprekerherkenning, vertraging) moeten vóór het eerste audioblok worden verzonden, waarna ze vergrendeld zijn. Als uw use case nauwkeurige tijdstempels vereist, heeft u de offline modus nodig, mogelijk als aanvulling op realtime.

Installatie

De Mistral SDK laadt streaming-afhankelijkheden niet standaard. U moet expliciet de realtime extra aanvragen, wat ondersteuning toevoegt voor WebSocket-verbindingen en asynchrone audioverwerking:

pip install "mistralai[realtime]"

Het vereiste audioformaat

In tegenstelling tot de offline modus, die een breed scala aan containers accepteert, verwacht Voxtral Realtime een ruwe stream in één enkel, niet-onderhandelbaar formaat:

  • Codering: 16-bit signed little-endian PCM (pcm_s16le)
  • Sample rate: 16.000 Hz (16 kHz)
  • Kanalen: Mono (1 kanaal)

Deze beperking is geen blokkade: dit formaat is de meest beschikbare standaard en alle opnametools produceren dit native, of het nu PyAudio, FFmpeg of PulseAudio is. U declareert dit eenmaal aan de client, die het gebruikt om de bytes die u verzendt te interpreteren.

from mistralai.client.models import AudioFormat

# Definieer het audioformaat
audio_format = AudioFormat(
    encoding="pcm_s16le",
    sample_rate=16000
)

De twee stream-events

Wanneer u iteratie toepast op de transcriptie, retourneert de SDK twee soorten objecten. TranscriptionStreamTextDelta wordt gegenereerd voor elk nieuw getranscribeerd fragment en bevat de gedeeltelijke tekst die u direct kunt weergeven; dit is wat het scherm van de gebruiker voedt. TranscriptionStreamDone arriveert precies één keer, wanneer de audiostream eindigt, hetzij aan het einde van een bestand of wanneer de microfoon sluit; het signaleert dat er niets meer komt en dat u het resultaat kunt consolideren. Uw volledige logica past daarom in een asynchrone lus die deze twee gevallen onderscheidt:

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

async for event in flux_transcription:
    if isinstance(event, TranscriptionStreamTextDelta):
        # Nieuwe tekst beschikbaar
        print(event.text, end="", flush=True)
    elif isinstance(event, TranscriptionStreamDone):
        # Transcriptie voltooid
        print("\n[Voltooid]")

Eerst volledig voorbeeld

Om vertrouwd te raken met het mechanisme zonder een microfoon te gebruiken, is de eenvoudigste aanpak het simuleren van een stream vanuit een bestand dat reeds is geconverteerd naar PCM. De functie lire_fichier_pcm is een asynchrone generator: deze leest het bestand in blokken en yieldt ze één voor één, precies zoals een geluidskaart dat zou doen. De rest van het programma is wat u later zonder wijzigingen zult hergebruiken.

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):
    """Leest een PCM-bestand in blokken om een stream te simuleren."""
    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\nTranscriptie voltooid.")

asyncio.run(main())

Als uw bronbestand een MP3 is, kan dit niet als zodanig worden verzonden: converteer het eerst met FFmpeg, waarbij u de drie door het model vereiste kenmerken afdwingt.

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

Wanneer overstappen op realtime

Het selectiecriterium is eenvoudig: realtime is gerechtvaardigd wanneer iemand wacht op de tekst terwijl het geluid wordt geproduceerd. Dit geldt voor live ondertiteling tijdens een conferentie, webinar of online cursus, waarbij het publiek meeleest terwijl het luistert; voor een spraakassistent, die de gebruiker moet begrijpen terwijl deze spreekt om te reageren zonder ongemakkelijke pauzes; voor dictatie, waarbij spraak voor de ogen van de spreker tot tekst wordt; en tot slot voor conferentietranscriptie, wanneer de tekst moet verschijnen terwijl deze wordt uitgesproken. Overal elders blijft de offline modus rijker en eenvoudiger te implementeren.

De volgende lessen laten u zien hoe u de microfoon vastlegt, de latentie afstemt en deze use cases end-to-end bouwt.

Belangrijkste punten

  • Voxtral Mini Transcribe Realtime 3 transcribeert audio in streaming-modus met een instelbare vertraging van 80 ms tot 1,2 s (of 2,4 s)
  • Vereist audioformaat: 16-bit PCM, 16 kHz, mono
  • Twee event-types: TextDelta (gedeeltelijke tekst) en Done (einde)
  • Installeer met pip install "mistralai[realtime]"
  • Asynchrone programmering vereist (async/await)
  • Sprekerherkenning (exclusief detectie van het einde van een beurt) en context biasing beschikbaar in realtime, zonder segment-tijdstempels; instellingen vergrendeld na het eerste audioblok
  • Generatie 2 van het realtime-model is open weights Apache 2.0, voor soevereine implementatie