Cevovod za pretakanje od LLM do TTS
Na tej strani
Posodobljeno 3. novembra 2026, na podlagi strani xAI Text to Speech: vsak
text.deltalahko vsebuje do 60.000 znakov. Vir: Text to Speech.
Poveži LLM s sintezo govora v realnem času
Najzmogljivejša uporaba TTS WebSocket je njegovo zaporedno povezovanje s pretakajočim se LLM. LLM generira besedilo žeton za žetonom, vsak žeton potuje do TTS prek WebSocket, zvok pa se predvaja, ko prispe. Uporabnik sliši odgovor, medtem ko LLM še vedno razmišlja.
Arhitektura cevovoda
Podatki tečejo skozi tri faze:
Uporabnik -> LLM (pretakanje) -> TTS WebSocket -> Zvok (predvajanje)
vprašanje besedilni žetoni audio.delta zvočnik
Vsaka faza deluje s pretakanjem, kar minimizira zaznavno zakasnitev. Uporabniku ni treba čakati, da LLM konča z generiranjem celotnega odgovora, preden ga začne slišati.
Implementacija v Pythonu
Tukaj je celovit cevovod, ki povezuje Grok Chat Completions API s TTS WebSocket:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# 1. korak: Povezava TTS WebSocket
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. korak: Klic pretakajočega se 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:
# 3. korak: Vsak žeton LLM -> delta 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
# Pošlji kompletne stavke
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Pošlji vse, kar je ostalo v medpomnilniku
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# 4. korak: Zberi zvok
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)
Strategija medpomnjenja
Pošiljanje vsakega žetona v TTS posebej ni idealno: sintezni motor daje boljše rezultate, ko ima kontekst. Obstajajo tri strategije medpomnjenja.
Po stavkih
Počakaj na ločilo stavka (., !, ?, prelom vrstice), preden pošlješ:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
To je najboljše ravnovesje med kakovostjo in zakasnitvijo.
Po velikosti
Pošlji, ko medpomnilnik doseže določeno velikost (npr. 200 znakov):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
To je preprosteje, vendar lahko prereže besedo na pol.
Po časovni omejitvi
Pošlji po zamiku brez novega žetona (uporabno, medtem ko LLM razmišlja):
last_token_time = time.time()
# Če mine več kot 500 ms brez žetona, pošlji medpomnilnik
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Predvajanje zvoka v realnem času
Če želiš predvajati zvok, ko prispe (namesto da ga le zbiraš), uporabi asinhrono vrsto:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Prejme zvočne dele in jih doda v vrsto."""
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) # Končni sentinel
break
async def play_audio():
"""Predvaja zvočne dele iz vrste."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Predvajaj del (pyaudio, sounddevice itd.)
play_chunk(chunk)
S sočasnim zagonom receive_audio in play_audio se predvajanje začne s prvim prejetim delom.
Obravnava napak v cevovodu
Cevovod lahko odpove na treh mestih: pri LLM, TTS ali v omrežju. Obravnavaj vsakega posebej:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("Napaka LLM: preveri svojo povezavo")
except websockets.ConnectionClosed:
print("Povezava TTS prekinjena: potrebna je ponovna vzpostavitev")
except json.JSONDecodeError:
print("Neveljaven odgovor: nepričakovana oblika")
except Exception as e:
print(f"Nepričakovana napaka: {e}")
return None
Ključne ugotovitve
- Pretakajoč se LLM, ki napaja TTS WebSocket, zagotavlja najnižjo zakasnitev
- Medpomni po stavkih za najboljše ravnovesje med kakovostjo in zakasnitvijo
- Uporabi asinhrono vrsto za predvajanje zvoka v realnem času
- Obravnavaj napake na vsaki stopnji cevovoda
- Skupno besedilo prek WebSocket je neomejeno (delti do 60.000 znakov)
- Omejitev 50 sočasnih sej velja za celo tvojo ekipo