Píblíne sruthú ó LLM go TTS
Ar an leathanach seo
Nuashonraithe an 3 Samhain 2026, bunaithe ar an leathanach Text to Speech ó xAI: is féidir le gach
text.deltasuas le 60,000 carachtar a shealbhú. Foinse: Text to Speech.
LLM a nascadh le sintéis cainte fíor-ama
Is é an úsáid is cumhachtaí a bhaintear as TTS WebSocket ná é a shlabhrú le LLM sruthúcháin. Gineann an LLM téacs token ar thoken, téann gach token chuig an TTS thar WebSocket, agus seinntear an fuaime de réir mar a thagann sí. Cloiseann an t-úsáideoir an freagra agus an LLM fós ag smaoineamh.
Ailtireacht na píblíne
Sreabhann na sonraí trí thrí chéim:
User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question text tokens audio.delta speaker
Déanann gach céim sruthú, rud a íoslaghdaíonn an mhoill mheasta. Ní gá don úsáideoir fanacht go gcríochnóidh an LLM a fhreagra iomlán sula dtosaíonn sé/sí ag éisteacht leis.
Cur chun feidhme i bPython
Seo píblíne iomlán a nascann API Críochnuithe Comhrá Grok le TTS WebSocket:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Céim 1: Nasc 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:
# Céim 2: Glaoch ar an LLM sruthúcháin
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:
# Céim 3: Gach 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
# Seol abairtí iomlána
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Seol aon rud atá fágtha sa mhaolán
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Céim 4: Bailigh an fhuaim
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)
Straitéis mhaolánaithe
Níl sé idéalach gach token a sheoladh chuig an TTS go haonair: bíonn torthaí níos fearr ag an inneall sintéise nuair a bhíonn comhthéacs aige. Tá trí straitéis mhaolánaithe ann.
De réir abairte
Fan go mbíonn teorainneoir abairte (. ! ?, briseadh líne) ann sula seolann tú:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Is é seo an chothromaíocht is fearr idir cáilíocht agus moill.
De réir méide
Seol nuair a shroicheann an maolán méid áirithe (200 carachtar, mar shampla):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Tá sé níos simplí ach d’fhéadfadh sé focal a ghearradh ina dhá leath.
De réir teorainn ama
Seol tar éis moille gan aon token nua (úsáideach agus an LLM ag smaoineamh):
last_token_time = time.time()
# Má théann níos mó ná 500 ms thart gan token, seol an maolán
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Seinm fuaime fíor-ama
Chun an fhuaim a sheinm de réir mar a thagann sí (seachas í a bhailiú amháin), úsáid ciú async:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Faigheann sé píosaí fuaime agus cuireann sa chiú iad."""
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) # Seantainéal deiridh
break
async def play_audio():
"""Seinneann sé píosaí fuaime ón gciú."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Seinm an phíosa (pyaudio, sounddevice, etc.)
play_chunk(chunk)
Trí receive_audio agus play_audio a rith i gcomhthreomhar, tosaíonn an tseinm leis an gcéad phíosa a fhaightear.
Láimhseáil earráidí sa phíblíne
Is féidir leis an bpíblíne teip a dhéanamh in áit ar bith de na trí áit seo: an LLM, an TTS, nó an líonra. Déileáil le gach ceann acu:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("Earráid LLM: seiceáil do nasc")
except websockets.ConnectionClosed:
print("Nasc TTS caillte: athnascadh ag teastáil")
except json.JSONDecodeError:
print("Freagra neamhbhailí: formáid gan choinne")
except Exception as e:
print(f"Earráid gan choinne: {e}")
return None
Príomhphointí
- Soláthraíonn LLM sruthúcháin a bheathaíonn TTS WebSocket an mhoill is ísle
- Maoláin de réir abairte don chothromaíocht is fearr idir cáilíocht agus moill
- Úsáid ciú async do sheinm fuaime fíor-ama
- Déileáil le hearráidí ag gach céim den phíblíne
- Níl aon teorainn leis an téacs iomlán thar WebSocket (deltas suas le 60,000 carachtar)
- Baineann an teorainn 50 seisiún comhthreomhar le do fhoireann ar fad