Conductă de streaming de la LLM la TTS
Pe această pagină
Actualizat la 3 noiembrie 2026, pe baza paginii xAI Text to Speech: fiecare
text.deltapoate conține până la 60.000 de caractere. Sursă: Text to Speech.
Conectarea unui LLM la sinteza vocală în timp real
Cea mai puternică utilizare a WebSocket-ului TTS este înlănțuirea acestuia cu un LLM în streaming. LLM-ul generează text token cu token, fiecare token fiind trimis către TTS prin WebSocket, iar audio-ul este redat pe măsură ce sosește. Utilizatorul aude răspunsul în timp ce LLM-ul încă „gândește“.
Arhitectura conductei
Datele circulă prin trei etape:
Utilizator -> LLM (streaming) -> WebSocket TTS -> Audio (redare)
întrebare tokeni text audio.delta difuzor
Fiecare etapă funcționează în regim de streaming, ceea ce minimizează latența percepută. Utilizatorul nu așteaptă ca LLM-ul să termine de generat întregul răspuns înainte de a începe să îl audă.
Implementare în Python
Iată o conductă completă care conectează API-ul Grok Chat Completions la WebSocket-ul TTS:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Pasul 1: Conectarea la WebSocket TTS
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:
# Pasul 2: Apel streaming către 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:
# Pasul 3: Fiecare token 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
# Trimiterea propozițiilor complete
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Trimiterea oricărui conținut rămas în buffer
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Pasul 4: Colectarea audio-ului
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)
Strategii de tamponare (Buffering)
Trimiterea fiecărui token către TTS individual nu este ideală: motorul de sinteză produce rezultate mai bune atunci când dispune de context. Există trei strategii de tamponare.
Pe propoziție
Așteptați un delimitator de propoziție (., !, ?, sfârșit de linie) înainte de a trimite:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Aceasta este cea mai bună echilibrare între calitate și latență.
Pe dimensiune
Trimiteți când bufferul atinge o anumită dimensiune (de exemplu, 200 de caractere):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Este mai simplu, dar poate tăia un cuvânt la jumătate.
Pe bază de timp (Timeout)
Trimiteți după o întârziere fără niciun token nou (util în timp ce LLM-ul „gândește“):
last_token_time = time.time()
# Dacă trec mai mult de 500 ms fără un token, trimiteți bufferul
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Redarea audio în timp real
Pentru a reda audio-ul pe măsură ce sosește (nu doar pentru a-l colecta), utilizați o coadă asincronă:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Primește fragmente audio și le pune în coadă."""
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) # Sentinelă de final
break
async def play_audio():
"""Redă fragmentele audio din coadă."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Redă fragmentul (pyaudio, sounddevice, etc.)
play_chunk(chunk)
Prin rularea funcțiilor receive_audio și play_audio în paralel, redarea începe odată cu primirea primului fragment.
Gestionarea erorilor în conductă
Conducta poate eșua în trei locuri: la LLM, la TTS sau în rețea. Gestionați fiecare caz:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("Eroare LLM: verificați conexiunea")
except websockets.ConnectionClosed:
print("Conexiune TTS pierdută: este necesară reconectarea")
except json.JSONDecodeError:
print("Răspuns invalid: format neașteptat")
except Exception as e:
print(f"Eroare neașteptată: {e}")
return None
Puncte cheie
- Un LLM în streaming care alimentează WebSocket-ul TTS oferă cea mai mică latență
- Tamponați pe propoziție pentru cel mai bun echilibru între calitate și latență
- Utilizați o coadă asincronă pentru redarea audio în timp real
- Gestionați erorile la fiecare etapă a conductei
- Textul total prin WebSocket este nelimitat (delta-uri de până la 60.000 de caractere)
- Limita de 50 de sesiuni concurente se aplică întregii echipe