Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Datové potrubí od LLM k TTS v reálném čase

Lekce 12 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Propojení LLM se syntézou řeči v reálném čase
  2. Architektura potrubí
  3. Implementace v Pythonu
  4. Strategie bufferování
  5. Přehrávání zvuku v reálném čase
  6. Zpracování chyb v potrubí
  7. Klíčové poznatky

Aktualizováno 3. listopadu 2026 na základě stránky xAI Text to Speech: každý text.delta může obsahovat až 60 000 znaků. Zdroj: Text to Speech.

Propojení LLM se syntézou řeči v reálném čase

Nejsilnějším využitím WebSocketu pro TTS je jeho řetězení se streamujícím LLM. LLM generuje text token po tokenu, každý token putuje přes WebSocket do TTS a zvuk se přehrává, jakmile dorazí. Uživatel slyší odpověď ještě během toho, co LLM „přemýšlí“.

Architektura potrubí

Data protékají třemi fázemi:

Uživatel -> LLM (streaming) -> TTS WebSocket -> Zvuk (přehrávání)
otázka     textové tokeny      audio.delta       reproduktor

Každá fáze pracuje ve streamovacím režimu, což minimalizuje vnímanou latenci. Uživatel nečeká, až LLM dokončí celou odpověď, než ji začne slyšet.

Implementace v Pythonu

Zde je kompletní potrubí, které propojuje API Grok Chat Completions s TTS WebSocketem:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # Krok 1: Připojení k TTS WebSocketu
    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:

        # Krok 2: Volání streamujícího LLM
        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:

                # Krok 3: Každý token z LLM -> delta pro TTS
                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
                        # Odeslání celých vět
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Odeslání zbytku v bufferu
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

                await tts_ws.send(json.dumps({"type": "text.done"}))

        # Krok 4: Shromáždění zvuku
        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)

Strategie bufferování

Odesílání každého tokenu do TTS jednotlivě není ideální: syntetizační engine dosahuje lepších výsledků, když má k dispozici kontext. Existují tři strategie bufferování.

Podle věty

Počkej na oddělovač věty (., !, ?, konec řádku), než odešleš:

if any(c in token for c in ".!?\n"):
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

Toto je nejlepší rovnováha mezi kvalitou a latencí.

Podle velikosti

Odešli, když buffer dosáhne určité velikosti (například 200 znaků):

if len(buffer) >= 200:
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

Je to jednodušší, ale může to rozdělit slovo uprostřed.

Podle časového limitu

Odešli po prodlevě bez nového tokenu (užitečné, když LLM „přemýšlí“):

last_token_time = time.time()

# Pokud uplyne více než 500 ms bez tokenu, odešli buffer
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Přehrávání zvuku v reálném čase

Chceš-li přehrávat zvuk, jak přichází (ne jen jej shromažďovat), použij asynchronní frontu:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Přijímá zvukové chunky a vkládá je do fronty."""
    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)  # Koncový sentinel
            break

async def play_audio():
    """Přehrává zvukové chunky z fronty."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Přehrání chunku (pyaudio, sounddevice atd.)
        play_chunk(chunk)

Souběžným spuštěním receive_audio a play_audio začne přehrávání s prvním přijatým chunkem.

Zpracování chyb v potrubí

Potrubí může selhat na třech místech: u LLM, u TTS nebo v síti. Každou situaci ošetři:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("Chyba LLM: zkontroluj připojení")
    except websockets.ConnectionClosed:
        print("Připojení k TTS přerušeno: je třeba se znovu připojit")
    except json.JSONDecodeError:
        print("Neplatná odpověď: neočekávaný formát")
    except Exception as e:
        print(f"Neočekávaná chyba: {e}")
    return None

Klíčové poznatky

  • Streamující LLM napájející TTS přes WebSocket poskytuje nejnižší latenci
  • Bufferuj po větách pro nejlepší rovnováhu mezi kvalitou a latencí
  • Pro přehrávání zvuku v reálném čase použij asynchronní frontu
  • Ošetřuj chyby v každé fázi potrubí
  • Celkový text přes WebSocket není omezen (delt až 60 000 znaků)
  • Limit 50 souběžných relací platí pro celý tvůj tým