Strömningspipeline från LLM till TTS
På denna sida
Uppdaterat den 3 november 2026, baserat på xAI:s sida Text to Speech: varje
text.deltakan innehålla upp till 60 000 tecken. Källa: Text to Speech.
Koppla en LLM till talgenerering i realtid
Den kraftfullaste användningen av TTS WebSocket är att kedja ihop den med en strömmande LLM. LLM:n genererar text token för token, varje token skickas till TTS via WebSocket och ljudet spelas upp i takt med att det anländer. Användaren hör svaret medan LLM:n fortfarande tänker.
Pipeline-arkitektur
Data flödar genom tre steg:
Användare -> LLM (strömmande) -> TTS WebSocket -> Ljud (uppspelning)
fråga text-token audio.delta högtalare
Varje steg strömmar, vilket minimerar den upplevda latensen. Användaren behöver inte vänta på att LLM:n ska bli klar med hela sitt svar innan ljudet börjar spelas.
Implementering i Python
Här är en komplett pipeline som kopplar Grok Chat Completions API till TTS WebSocket:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Steg 1: TTS WebSocket-anslutning
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:
# Steg 2: Strömmande LLM-anrop
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:
# Steg 3: Varje LLM-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
# Skicka kompletta meningar
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Skicka allt som finns kvar i bufferten
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Steg 4: Samla ljudet
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)
Buffringsstrategi
Att skicka varje token individuellt till TTS är inte optimalt: syntesmotorn ger bättre resultat när den har kontext. Det finns tre buffringsstrategier.
Efter mening
Vänta på ett meningsavgränsare (., !, ?, radbrytning) innan du skickar:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Detta är den bästa balansen mellan kvalitet och latens.
Efter storlek
Skicka när bufferten når en viss storlek (till exempel 200 tecken):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Det är enklare men kan klippa mitt i ett ord.
Efter tidsgräns
Skicka efter en fördröjning utan nya token (användbart medan LLM:n tänker):
last_token_time = time.time()
# Om mer än 500 ms passerar utan token, skicka bufferten
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Ljuduppspelning i realtid
För att spela upp ljudet i takt med att det anländer (inte bara samla det), använd en asynkron kö:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Tar emot ljudbitar och lägger dem i kön."""
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) # Slutmarkör
break
async def play_audio():
"""Spelar upp ljudbitar från kön."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Spela biten (pyaudio, sounddevice, etc.)
play_chunk(chunk)
Genom att köra receive_audio och play_audio parallellt startar uppspelningen så snart den första biten tas emot.
Felhantering i pipelinen
Pipelinen kan misslyckas på tre ställen: LLM:n, TTS eller nätverket. Hantera varje fall:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM-fel: kontrollera din anslutning")
except websockets.ConnectionClosed:
print("TTS-anslutningen förlorad: återanslutning krävs")
except json.JSONDecodeError:
print("Ogiltigt svar: oväntat format")
except Exception as e:
print(f"Oväntat fel: {e}")
return None
Viktiga punkter
- En strömmande LLM som matar TTS WebSocket ger lägst latens
- Buffra efter mening för bästa balans mellan kvalitet och latens
- Använd en asynkron kö för ljuduppspelning i realtid
- Hantera fel i varje steg av pipelinen
- Total textmängd över WebSocket är obegränsad (deltan på upp till 60 000 tecken)
- Gränsen på 50 samtidiga sessioner gäller för hela ditt team