Streaming-pipeline van LLM naar TTS
Op deze pagina
Bijgewerkt op 3 november 2026, gebaseerd op de xAI-pagina Text to Speech: elke
text.deltakan tot 60.000 tekens bevatten. Bron: Text to Speech.
Een LLM koppelen aan real-time spraaksynthese
De krachtigste toepassing van TTS via WebSocket is het koppelen ervan aan een streamende LLM. De LLM genereert tekst token voor token, elk token gaat via WebSocket naar de TTS-engine en de audio wordt afgespeeld zodra deze binnenkomt. De gebruiker hoort het antwoord terwijl de LLM nog aan het denken is.
Pipeline-architectuur
De gegevens stromen door drie fasen:
User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question text tokens audio.delta speaker
Elke fase streamt, wat de waargenomen latentie minimaliseert. De gebruiker hoeft niet te wachten tot de LLM zijn volledige antwoord heeft gegenereerd voordat het horen begint.
Implementatie in Python
Hier volgt een complete pipeline die de Grok Chat Completions API koppelt aan TTS via WebSocket:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Stap 1: TTS WebSocket-verbinding
tts_uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
tts_headers = {"Authorization": f"Bearer {api_key}"}
audio_chunks = []
async with websockets.connect(tts_uri, additional_headers=tts_headers) as tts_ws:
# Stap 2: Streamende LLM-aanroep
async with aiohttp.ClientSession() as session:
async with session.post(
"https://api.x.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": "grok-4.5",
"messages": [{"role": "user", "content": prompt}],
"stream": True
}
) as llm_response:
# Stap 3: Elke LLM-token -> TTS delta
buffer = ""
async for line in llm_response.content:
line = line.decode().strip()
if not line.startswith("data: "):
continue
if line == "data: [DONE]":
break
chunk = json.loads(line[6:])
token = chunk["choices"][0].get("delta", {}).get("content", "")
if token:
buffer += token
# Volledige zinnen verzenden
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Verstuur wat er nog in de buffer zit
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Stap 4: Audio verzamelen
async for msg in tts_ws:
data = json.loads(msg)
if data["type"] == "audio.delta":
audio_chunks.append(base64.b64decode(data["delta"]))
elif data["type"] == "audio.done":
break
return b"".join(audio_chunks)
Bufferstrategie
Elk token individueel naar de TTS sturen is niet ideaal: de synthesengine levert betere resultaten wanneer deze context heeft. Er zijn drie bufferstrategieën.
Per zin
Wacht op een scheidingsteken voor zinnen (., !, ?, regeleinde) voordat u verzendt:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Dit biedt de beste balans tussen kwaliteit en latentie.
Op grootte
Verzend wanneer de buffer een bepaalde grootte bereikt (bijvoorbeeld 200 tekens):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Dit is eenvoudiger, maar kan een woord middenin afbreken.
Op timeout
Verzend na een vertraging zonder nieuwe token (handig terwijl de LLM aan het denken is):
last_token_time = time.time()
# Als er meer dan 500 ms verstrijken zonder token, verzend de buffer
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Real-time audio-afspeeling
Om de audio af te spelen zodra deze binnenkomt (in plaats van deze alleen te verzamelen), gebruikt u een asynchrone wachtrij:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Ontvangt audiofragmenten en plaatst ze in de wachtrij."""
async for msg in tts_ws:
data = json.loads(msg)
if data["type"] == "audio.delta":
audio_bytes = base64.b64decode(data["delta"])
await audio_queue.put(audio_bytes)
elif data["type"] == "audio.done":
await audio_queue.put(None) # Eindmarker
break
async def play_audio():
"""Speelt audiofragmenten af vanuit de wachtrij."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Speel het fragment af (pyaudio, sounddevice, enz.)
play_chunk(chunk)
Door receive_audio en play_audio parallel uit te voeren, start de weergave bij het eerste ontvangen fragment.
Foutafhandeling in de pipeline
De pipeline kan op drie plekken mislukken: de LLM, de TTS of het netwerk. Behandel elk geval apart:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM-fout: controleer uw verbinding")
except websockets.ConnectionClosed:
print("TTS-verbinding verbroken: opnieuw verbinden nodig")
except json.JSONDecodeError:
print("Ongeldig antwoord: onverwacht formaat")
except Exception as e:
print(f"Onverwachte fout: {e}")
return None
Belangrijkste punten
- Een streamende LLM die TTS via WebSocket voedt, biedt de laagste latentie
- Buffer per zin voor de beste balans tussen kwaliteit en latentie
- Gebruik een asynchrone wachtrij voor real-time audio-afspeeling
- Behandel fouten in elke fase van de pipeline
- De totale tekst via WebSocket is onbeperkt (delta’s tot 60.000 tekens)
- De limiet van 50 gelijktijdige sessies geldt voor uw hele team