Pārraides konveijers no LLM uz TTS
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz xAI Text to Speech lapu: katrs
text.deltavar saturēt līdz 60 000 rakstzīmēm. Avots: Text to Speech.
Savieno LLM ar runas sintēzi reāllaikā
Visjaudīgākais TTS WebSocket pielietojums ir tā sasaiste ar straumējošu LLM. LLM ģenerē tekstu pa vienam tokenim, katrs tokens caur WebSocket nonāk TTS sistēmā, un audio atskaņošanās sākas līdz ar datu saņemšanu. Lietotājs dzird atbildi jau brīdī, kad LLM vēl domā.
Konveijera arhitektūra
Datu plūsma iziet cauri trim posmiem:
Lietotājs -> LLM (straumēšana) -> TTS WebSocket -> Audio (atskaņošana)
jautājums teksta tokeni audio.delta skaļrunis
Katrs posms darbojas straumēšanas režīmā, kas minimizē uztveramo latentumu. Lietotājam nav jāgaida, kamēr LLM būs ģenerējis visu atbildi, lai sāktu to dzirdēt.
Implementācija Python valodā
Lūk, pilns konveijers, kas savieno Grok Chat Completions API ar 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. solis: TTS WebSocket savienojums
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. solis: LLM straumēšanas izsaukums
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. solis: Katrs LLM tokens -> 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
# Sūti pabeigtus teikumus
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Nosūti visu, kas palicis buferī
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# 4. solis: Audio savākšana
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)
Buferizācijas stratēģija
Katra tokena nosūtīšana TTS sistēmai atsevišķi nav ideāls risinājums: sintēzes dzinējs sniedz labākus rezultātus, ja tam ir konteksts. Pastāv trīs buferizācijas stratēģijas.
Pa teikumiem
Gaidi teikuma beigšanas zīmi (., !, ?, jaunu rindu) pirms nosūtīšanas:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Šis ir labākais līdzsvars starp kvalitāti un latentumu.
Pēc izmēra
Nosūti, kad bufers sasniedz noteiktu izmēru (piemēram, 200 rakstzīmes):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Tas ir vienkāršāk, taču var pārraut vārdu uz pusēm.
Pēc noilguma
Nosūti pēc kavēšanās, ja jauni tokeni netiek saņemti (noderīgi, kamēr LLM domā):
last_token_time = time.time()
# Ja pagājuši vairāk nekā 500 ms bez tokena, nosūti buferi
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Audio atskaņošana reāllaikā
Lai atskaņotu audio uzreiz, tiklīdz tas tiek saņemts (nevis tikai savāktu to), izmanto asinhronu rindu:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Saņem audio fragmentus un ievieto tos rindā."""
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) # Beigu marķieris
break
async def play_audio():
"""Atskaņo audio fragmentus no rindas."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Atskaņo fragmentu (pyaudio, sounddevice u.c.)
play_chunk(chunk)
Palaižot receive_audio un play_audio paralēli, atskaņošana sākas līdz ar pirmā fragmenta saņemšanu.
Kļūdu apstrāde konveijerā
Konveijers var izgāzties trīs vietās: LLM, TTS vai tīklā. Apstrādā katru no tām:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM kļūda: pārbaudi savu savienojumu")
except websockets.ConnectionClosed:
print("TTS savienojums zaudēts: nepieciešama atkārtota savienošanās")
except json.JSONDecodeError:
print("Nederīga atbilde: negaidīts formāts")
except Exception as e:
print(f"Negaidīta kļūda: {e}")
return None
Galvenās atziņas
- Straumējošs LLM, kas baro TTS WebSocket, nodrošina viszemāko latentumu
- Buferizē pa teikumiem, lai panāktu labāko līdzsvaru starp kvalitāti un latentumu
- Izmanto asinhronu rindu audio atskaņošanai reāllaikā
- Apstrādā kļūdas katrā konveijera posmā
- Kopējais teksta apjoms caur WebSocket ir neierobežots (deltas līdz 60 000 rakstzīmēm)
- 50 vienlaicīgu sesiju limits attiecas uz visu tavu komandu