Streaming adatfolyam LLM-től a TTS-ig
Ezen az oldalon
Frissítve: 2026. november 3., az xAI Text to Speech oldala alapján: minden
text.deltalegfeljebb 60 000 karaktert tartalmazhat. Forrás: Text to Speech.
LLM csatlakoztatása valós idejű beszédszintézishez
A TTS WebSocket leghatékonyabb alkalmazása egy streaming LLM-mel való láncolás. Az LLM tokenről tokenre generálja a szöveget, minden egyes token a WebSocketen keresztül a TTS-hez kerül, és a hanganyag már érkezés közben lejátszásra kerül. A felhasználó már akkor hallja a választ, amikor az LLM még mindig a gondolkodási fázisban van.
A rendszerarchitektúra
Az adatfolyam három szakaszon halad át:
Felhasználó -> LLM (streaming) -> TTS WebSocket -> Hang (lejátszás)
kérdés szöveg tokenek audio.delta hangszóró
Minden szakasz streaming módban működik, ami minimalizálja az észlelt késleltetést. A felhasználónak nem kell megvárnia, amíg az LLM befejezi a teljes válasz generálását, mielőtt elkezdené hallani azt.
Megvalósítás Pythonban
Íme egy teljes körű adatfolyam, amely összeköti a Grok Chat Completions API-t a TTS WebSockettel:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# 1. lépés: TTS WebSocket kapcsolat
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:
# 2. lépés: Streaming LLM hívás
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:
# 3. lépés: Minden 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
# Teljes mondatok küldése
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# A pufferben maradt tartalom elküldése
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# 4. lépés: Hanganyag összegyűjtése
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)
Pufferelési stratégiák
Az egyes tokenek egyenkénti elküldése a TTS-nek nem ideális: a szintetizáló motor jobb eredményeket produkál, ha rendelkezik kontextussal. Három fő pufferelési stratégia létezik.
Mondatonként
Várj egy mondatlezáró karakterre (., !, ?, sorvége) a küldés előtt:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Ez biztosítja a legjobb egyensúlyt a minőség és a késleltetés között.
Méret alapján
Küldj, amikor a puffer elér egy bizonyos méretet (például 200 karaktert):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Ez egyszerűbb, de előfordulhat, hogy félbevág egy szót.
Időtúllépés alapján
Küldj egy késleltetés után, ha nem érkezik új token (hasznos, amíg az LLM gondolkodik):
last_token_time = time.time()
# Ha több mint 500 ms telik el token nélkül, küldd el a puffert
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Valós idejű hanglejátszás
Ahhoz, hogy a hanganyagot érkezés közben lejátszd (ne csak összegyűjtsd), használj egy aszinkron queue-t:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Fogadja a hangrészeket, és beteszi őket a queue-ba."""
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) # Lezáró jelző
break
async def play_audio():
"""Lejátssza a hangrészeket a queue-ból."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# A rész lejátszása (pyaudio, sounddevice, stb.)
play_chunk(chunk)
A receive_audio és a play_audio párhuzamos futtatásával a lejátszás már az első beérkező résszel elindul.
Hibakezelés az adatfolyamban
Az adatfolyam három helyen is meghibásodhat: az LLM-nél, a TTS-nél vagy a hálózaton. Kezeld le mindegyiket:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM hiba: ellenőrizd a kapcsolatot")
except websockets.ConnectionClosed:
print("TTS kapcsolat megszakadt: újracsatlakozás szükséges")
except json.JSONDecodeError:
print("Érvénytelen válasz: váratlan formátum")
except Exception as e:
print(f"Váratlan hiba: {e}")
return None
Főbb megállapítások
- Egy streaming LLM, amely táplálja a TTS WebSocketet, biztosítja a legalacsonyabb késleltetést
- Pufferelj mondatonként a minőség és a késleltetés legjobb egyensúlya érdekében
- Használj aszinkron queue-t a valós idejű hanglejátszáshoz
- Kezeld a hibákat az adatfolyam minden szakaszában
- A WebSocketen keresztül küldött teljes szöveg mennyisége korlátlan (legfeljebb 60 000 karakteres delták)
- Az egyszerre 50 munkamenetre vonatkozó korlát az egész csapatodra érvényes