Transmisijos vamzdynas iš DDK į KT
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 3 d., remiantis xAI Text to Speech puslapiu: kiekviename
text.deltagali būti iki 60 000 simbolių. Šaltinis: Text to Speech.
Prijunk DDK prie kalbos sintezės realiuoju laiku
Galingiausias KT (kalbos į tekstą) WebSocket panaudojimas – sujungti jį su srautiniu DDK (didžiuoju kalbos modeliu). DDK generuoja tekstą žymenimis po vieną, kiekvienas žymuo per WebSocket siunčiamas į KT, o garsas grojamas jam atkeliaujant. Naudotojas girdi atsakymą dar DDK mąstant.
Vamzdyno architektūra
Duomenys teka trimis etapais:
Naudotojas -> DDK (srautas) -> KT WebSocket -> Garso atkūrimas
klausimas teksto žymenys audio.delta garsiakalbis
Kiekvienas etapas veikia srautiniu režimu, todėl sumažinama suvokiama delsos trukmė. Naudotojas nelaukia, kol DDK sugeneruos visą atsakymą, kad pradėtų jį girdėti.
Įgyvendinimas naudojant „Python“
Štai pilnas vamzdynas, sujungiantis „Grok Chat Completions“ API su KT WebSocket:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# 1 žingsnis: KT WebSocket ryšys
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 žingsnis: Srautinis DDK užklausimas
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 žingsnis: Kiekvienas DDK žymuo -> KT 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
# Siųsti pilnus sakinius
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Siųsti tai, kas liko buferyje
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# 4 žingsnis: Surinkti garso duomenis
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)
Buferizavimo strategija
Siųsti kiekvieną žymenį į KT atskirai nėra idealu: sintezės variklis veikia geriau, kai turi kontekstą. Yra trys buferizavimo strategijos.
Pagal sakinį
Palauk sakinio skyrybos ženklo (., !, ?, eilutės lūžis) prieš siųsdamas:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Tai geriausias balansas tarp kokybės ir delsos.
Pagal dydį
Siųsk, kai buferis pasiekia tam tikrą dydį (pvz., 200 simbolių):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Tai paprasčiau, tačiau gali nutraukti žodį per pusę.
Pagal laiko limitą
Siųsk po uždelsto laiko be naujo žymens (naudinga, kai DDK mąsto):
last_token_time = time.time()
# Jei praėjo daugiau nei 500 ms be žymens, siųsk buferį
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Garso atkūrimas realiuoju laiku
Norint atkurti garsą jam atkeliaujant (o ne tik jį surinkti), naudok asinchroninę eilę:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Gauna garso fragmentus ir deda juos į eilę."""
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) # Pabaigos žymeklis
break
async def play_audio():
"""Groja garso fragmentus iš eilės."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Grok fragmentą (pyaudio, sounddevice ir kt.)
play_chunk(chunk)
Paleidus receive_audio ir play_audio lygiagrečiai, atkūrimas prasideda gavus pirmąjį fragmentą.
Klaidų apdorojimas vamzdyne
Vamzdynas gali sugesti trijose vietose: DDK, KT arba tinkle. Apdorok kiekvieną atvejį:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("DDK klaida: patikrink ryšį")
except websockets.ConnectionClosed:
print("KT ryšys nutrūko: reikia prisijungti iš naujo")
except json.JSONDecodeError:
print("Neteisingas atsakymas: netikėtas formatas")
except Exception as e:
print(f"Netikėta klaida: {e}")
return None
Svarbiausi punktai
- Srautinis DDK, maitinantis KT WebSocket, užtikrina mažiausią delsą
- Buferizuok pagal sakinius, kad pasiektum geriausią kokybės ir delsos balansą
- Naudok asinchroninę eilę garso atkūrimui realiuoju laiku
- Apdorok klaidas kiekviename vamzdyno etape
- Bendras tekstas per WebSocket neribojamas (delta iki 60 000 simbolių)
- 50 vienu metu vykdomų sesijų riba taikoma visai tavo komandai