Streaming-putki LLM:stä puheeksi
Tällä sivulla
Päivitetty 3. marraskuuta 2026 xAI:n Text to Speech -sivun perusteella: jokainen
text.deltavoi sisältää jopa 60 000 merkkiä. Lähde: Text to Speech.
Yhdistä LLM reaaliaikaiseen puhesynteesiin
Tehokkain tapa hyödyntää TTS WebSocketia on ketjuttaa se suoratoistavaan LLM-malliin. LLM tuottaa tekstiä merkki merkiltä, jokainen merkki lähetetään TTS:lle WebSocketin yli, ja ääni toistetaan saapumisjärjestyksessä. Käyttäjä kuulee vastauksen jo mientras LLM vielä “ajattelee”.
Putkiarkkitehtuuri
Tieto virtaa kolmen vaiheen kautta:
Käyttäjä -> LLM (suoratoisto) -> TTS WebSocket -> Ääni (toisto)
kysymys tekstimerkit audio.delta kaiutin
Jokainen vaihe on suoratoistava, mikä minimoi koetun viiveen. Käyttäjän ei tarvitse odottaa LLM:n valmistavan koko vastausta ennen kuin hän alkaa kuulla sitä.
Toteutus Pythonilla
Tässä on täydellinen putki, joka yhdistää Grok Chat Completions -rajapinnan TTS WebSocketiin:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Vaihe 1: TTS WebSocket -yhteys
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:
# Vaihe 2: Suoratoistava LLM-kutsu
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:
# Vaihe 3: Jokainen LLM-merkki -> 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
# Lähetä kokonaiset lauseet
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Lähetä puskurissa oleva jäljellä oleva teksti
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Vaihe 4: Kerää ääni
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)
Puskurointistrategia
Jokaisen merkin lähettäminen erikseen TTS:lle ei ole ihanteellista: synteesimoottori tuottaa parempia tuloksia, kun sillä on kontekstia. Käytössä on kolme puskurointistrategiaa.
Lausetta kohden
Odota lauseen erotinmerkkiä (. ! ? tai rivinvaihtoa) ennen lähettämistä:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Tämä tarjoaa parhaan tasapainon laadun ja viiveen välillä.
Kokoa kohden
Lähetä, kun puskuri saavuttaa tietyn koon (esimerkiksi 200 merkkiä):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Tämä on yksinkertaisempaa, mutta voi katkaista sanan keskeltä.
Aikakatkaisua kohden
Lähetä viiveen jälkeen, jos uusia merkkejä ei ole saapunut (hyödyllinen, kun LLM “ajattelee”):
last_token_time = time.time()
# Jos yli 500 ms kuluu ilman merkkiä, lähetä puskuri
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Reaaliaikainen äänen toisto
Toista ääni saapumisjärjestyksessä (älä vain kerää sitä) käyttämällä asynkronista jonoa:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Vastaanottaa äänipaloja ja laittaa ne jonoon."""
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) # Lopetusmerkki
break
async def play_audio():
"""Toistaa äänipaloja jonosta."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Toista pala (pyaudio, sounddevice jne.)
play_chunk(chunk)
Kun suoritat receive_audio- ja play_audio-funktiot rinnakkain, toisto alkaa ensimmäisen vastaanotetun palan myötä.
Virheenkäsittely putkessa
Putki voi epäonnistua kolmessa paikassa: LLM, TTS tai verkko. Käsittele jokainen niistä:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM-virhe: tarkista yhteys")
except websockets.ConnectionClosed:
print("TTS-yhteys katkesi: uudelleenyhdistys tarvitaan")
except json.JSONDecodeError:
print("Virheellinen vastaus: odottamaton muoto")
except Exception as e:
print(f"Odottamaton virhe: {e}")
return None
Keskeiset asiat
- Suoratoistava LLM, joka syöttää TTS WebSocketia, tarjoaa pienimmän viiveen
- Puskuroi lausetta kohden saavuttaaksesi parhaan tasapainon laadun ja viiveen välillä
- Käytä asynkronista jonoa reaaliaikaiseen äänen toistoon
- Käsittele virheet putken jokaisessa vaiheessa
- WebSocketin yli lähetettävän tekstin kokonaismäärä on rajoittamaton (deltat jopa 60 000 merkkiä)
- 50 samanaikaisen istunnon raja koskee koko tiimiäsi