Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Streaming-pipeline van LLM naar TTS

Les 12 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Een LLM koppelen aan real-time spraaksynthese
  2. Pipeline-architectuur
  3. Implementatie in Python
  4. Bufferstrategie
  5. Real-time audio-afspeeling
  6. Foutafhandeling in de pipeline
  7. Belangrijkste punten

Bijgewerkt op 3 november 2026, gebaseerd op de xAI-pagina Text to Speech: elke text.delta kan 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