Andmevoogude torustik LLM-ist kõnesünteesi
Sellel lehel
Uuendatud 3. novembril 2026, tuginedes xAI Text to Speech lehele: iga
text.deltavõib sisaldada kuni 60 000 tähemärki. Allikas: Text to Speech.
Ühenda LLM reaalajas kõnesünteesiga
TTS WebSocketi võimsaim kasutusviis on selle aheldamine voogedastava LLM-iga. LLM genereerib teksti tokenite kaupa, iga token saadetakse TTS-ile üle WebSocketi ja heli esitatakse saabumise hetkel. Kasutaja kuuleb vastust juba siis, kui LLM veel mõtleb.
Torustiku arhitektuur
Andmed läbivad kolm etappi:
Kasutaja -> LLM (voogedastus) -> TTS WebSocket -> Heli (esitus)
küsimus teksti tokenid audio.delta kõlar
Iga etapp toimib voogedastusena, mis minimeerib tajutavat latentsust. Kasutaja ei pea ootama, kuni LLM on kogu vastuse genereerinud, enne kui ta seda kuulma hakkab.
Teostus Pythonis
Siin on täielik torustik, mis ühendab Grok Chat Completions API TTS WebSocketiga:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# 1. samm: TTS WebSocketi ühendus
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. samm: Voogedastav LLM-i päring
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. samm: Iga LLM-i 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
# Saada terved laused
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Saada puhvrisse jäänud ülejääk
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# 4. samm: Heli kogumine
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)
Puhverdamise strateegia
Iga tokeni eraldi saatmine TTS-ile pole ideaalne: sünteesimootor annab paremaid tulemusi, kui tal on konteksti. On olemas kolm puhverdamise strateegiat.
Lauseti
Oota lause eraldusmärki (., !, ?, reavahetus) enne saatmist:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
See on parim tasakaal kvaliteedi ja latentsuse vahel.
Mahuti
Saada, kui puhver jõuab teatud suurusele (näiteks 200 tähemärki):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
See on lihtsam, kuid võib sõna pooleli jätta.
Ajapiirangu järgi
Saada pärast viivitust ilma uue tokenita (kasulik, kui LLM mõtleb):
last_token_time = time.time()
# Kui möödub rohkem kui 500 ms ilma tokenita, saada puhver
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Reaalajas heliesitus
Heli esitamiseks saabumise hetkel (mitte ainult selle kogumiseks) kasuta asünkroonset järjekorda:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Võtab vastu helilõike ja paneb need järjekorda."""
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) # Lõpumarker
break
async def play_audio():
"""Esitab helilõike järjekorrast."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Esita lõik (pyaudio, sounddevice jne)
play_chunk(chunk)
Käivitades receive_audio ja play_audio paralleelselt, algab esitus esimese saabunud lõiguga.
Veakäsitlus torustikus
Torustik võib nurjuda kolmes kohas: LLM, TTS või võrk. Käitle igaüks neist:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM-i viga: kontrolli ühendust")
except websockets.ConnectionClosed:
print("TTS-i ühendus katkes: vaja uuesti ühenduda")
except json.JSONDecodeError:
print("Vigane vastus: ootamatu vorming")
except Exception as e:
print(f"Ootamatu viga: {e}")
return None
Peamised punktid
- Voogedastav LLM, mis toidab TTS WebSocketit, annab väikseima latentsuse
- Puhverda lauseti parima kvaliteedi ja latentsuse tasakaalu saavutamiseks
- Kasuta reaalajas heliesituseks asünkroonset järjekorda
- Käitle vigu torustiku igas etapis
- Teksti üldmaht üle WebSocketi on piiramatu (deltasid kuni 60 000 tähemärki)
- Piirang 50 samaaegsele seansile kehtib kogu meeskonna kohta