Datové potrubí od LLM k TTS v reálném čase
Na této stránce
Aktualizováno 3. listopadu 2026 na základě stránky xAI Text to Speech: každý
text.deltamůž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