Streaming i realtid
På denne side
Kurset opdateret 3. november 2026 til Voxtral TTS 3, baseret på guiden Migrate from Voxtral 2 og Mistrals sider om Text to Speech:
voxtral-mini-tts-2603, som blev afskrevet 31. oktober 2026 og udfases 30. april 2027, erstattes i eksemplerne afvoxtral-mini-tts-3-0. Voxtral 2’s foruddefinerede stemmer (gb_jane_neutral…) understøttes fortsat; Voxtral 3 tilføjer[emotion=…]- og[pace=…]-tags i teksten, indstillingenexpressiveness, brugerdefineret udtale (phoneme_hints) og 35 sprog. Mistral anbefaler at genmåle ventetiden efter migrationen. Kilder: Migrate from Voxtral 2 · Speech generation.
Hvorfor streaming ændrer alt
Indtil nu har du arbejdet i synkron tilstand: Du sender teksten, venter på, at syntesen er helt færdig, og modtager derefter hele lydfilen. For en forhåndsgenereret hilsen, der er lavet dagen før, betyder denne ventetid ikke noget. For en stemmeassistent, der svarer en kunde i telefonen, er det derimod en dealbreaker – to sekunders stilhed efter et spørgsmål, og brugeren tror, at opkaldet er afbrudt.
Streaming fjerner denne ventetid. Lyden sendes, efterhånden som den genereres, fragment for fragment, så brugeren hører de første ord, mens modellen stadig producerer slutningen af sætningen. Den samlede genereringstid ændrer sig ikke; det, der kollapser, er forsinkelsen før den første lyd.
Event-protokollen
Streamet afhænger af Server-Sent Events. Hver modtaget besked er en typebestemt event, og to typer vedrører dig:
speech.audio.delta: indeholder et lydfragment i base64. Dette er den primære event, du skal håndtere.speech.audio.done: slutsignal – genereringen er fuldført.
På kodesiden betyder skiftet til streaming, at du tilføjer stream=True og behandler svaret i en with-blok. Følgende eksempel akkumulerer fragmenter i hukommelsen for at skrive en fil til sidst: Dette er ikke rigtig realtid endnu, men det er den løkkestruktur, resten af lektionen vil bygge videre på.
import base64
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
audio_chunks = []
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="Streaming makes voice agents responsive and natural.",
voice_id="your-voice-id",
response_format="opus",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
chunk = base64.b64decode(event.data.audio_data)
audio_chunks.append(chunk)
print(f"Chunk received: {len(chunk)} bytes")
# Saml alle chunks
audio_complet = b"".join(audio_chunks)
Path("streaming-output.opus").write_bytes(audio_complet)
print(f"Final audio: {len(audio_complet)} bytes")
Afspilning af lyd, efterhånden som den ankommer
For at opnå den lovede responsivitet skal du stoppe med at akkumulere og i stedet skrive hvert fragment direkte til lydkortet. Med pyaudio kræver ændringen kun én linje: I stedet for at tilføje det dekoderte fragment til en liste, sender du det til en output-strøm, der er åbnet på forhånd og konfigureret til mono Float32 ved 24.000 Hz.
import base64
import pyaudio
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# PCM-lydkonfiguration (hurtigste format)
p = pyaudio.PyAudio()
stream_audio = p.open(
format=pyaudio.paFloat32,
channels=1,
rate=24000,
output=True,
)
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="You're hearing this sentence while I generate it.",
voice_id="your-voice-id",
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
audio_data = base64.b64decode(event.data.audio_data)
stream_audio.write(audio_data)
stream_audio.stop_stream()
stream_audio.close()
p.terminate()
Det anmodede format er ændret fra opus til pcm, og det betyder noget. PCM kræver ingen dekoding: De modtagne bytes er klar til afspilning med det samme, hvilket gør det til det anbefalede format til brug i realtid.
Videresendelse af streamen til en browser
I en webapp afspiller serveren ikke lyden; den videresender den blot. Det klassiske mønster bruger en WebSocket, der modtager tekst fra browseren, åbner Voxtral-streamen og pusher hvert dekodet fragment tilbage til klienten. På browsersiden overtager Web Audio API afspilningen af de modtagne PCM-fragmenter.
# Serverside (FastAPI-eksempel)
from fastapi import FastAPI, WebSocket
import base64
from mistralai.client import Mistral
app = FastAPI()
client = Mistral(api_key="your-api-key")
@app.websocket("/ws/tts")
async def tts_websocket(websocket: WebSocket):
await websocket.accept()
texte = await websocket.receive_text()
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=texte,
voice_id="your-voice-id",
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
await websocket.send_bytes(
base64.b64decode(event.data.audio_data)
)
await websocket.close()
Indstillingen, der gør forskellen: Bufferen
Fragmentstørrelser varierer og repræsenterer typisk få millisekunders lyd hver. Hvis du afspiller det første fragment, så snart det ankommer, vil enhver netværksuregelmæssighed forårsage et hørbart mikro-udfald – en hikken i stemmen, der øjeblikkeligt afslører maskinen. Løsningen er at buffre to eller tre fragmenter, før afspilningen startes. Det koster nogle få titals millisekunder, men udjævner resten af streamen.
Der er også valget af format, som afvejer ventetid mod båndbredde. PCM leverer den første lyd hurtigst – omkring 0,7 sekunder i målinger foretaget med Voxtral 2, hvilket skal genmåles med Voxtral TTS 3 – på bekostning af høj gennemstrømning. Opus taber lidt på ventetiden, men komprimerer kraftigt, hvilket gør det til det rigtige kompromis, når dine brugere er på mobil.
Vigtige pointer
- Streaming sender lyd chunk for chunk under genereringen
- Aktiver det med
stream=Truei kaldet tilaudio.speech.complete() speech.audio.delta-events indeholder lydfragmenter i base64- PCM-formatet tilbyder den laveste ventetid til streaming (~0,7 s mod ~2 s for MP3)
- Brug
pyaudioeller WebSockets + Web Audio API til afspilning i realtid