Streaming-pipeline fra LLM til TTS
På denne side
Opdateret 3. november 2026 baseret på xAI-siden Text to Speech: Hver
text.deltakan indeholde op til 60.000 tegn. Kilde: Text to Speech.
Forbind en LLM med talesyntese i realtid
Den mest kraftfulde anvendelse af TTS WebSocket er at kæde den sammen med en streamende LLM. LLM’en genererer tekst token for token, hvert token sendes til TTS via WebSocket, og lyden afspilles, efterhånden som den ankommer. Brugeren hører svaret, mens LLM’en stadig er i gang med at tænke.
Pipeline-arkitektur
Dataene strømmer gennem tre faser:
User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question text tokens audio.delta speaker
Hver fase streamer, hvilket minimerer den oplevede ventetid. Brugeren behøver ikke vente på, at LLM’en bliver færdig med at generere hele sit svar, før begyndelsen af svaret kan høres.
Implementering i Python
Her er en komplet pipeline, der forbinder Grok Chat Completions API med TTS WebSocket:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Trin 1: TTS WebSocket-forbindelse
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:
# Trin 2: Streamende LLM-kald
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:
# Trin 3: Hvert 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
# Send komplette sætninger
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Send whatever is left in the buffer
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Trin 4: Indsaml lyden
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)
Bufferstrategi
Det er ikke ideelt at sende hvert token til TTS individuelt: Syntesemotoren producerer bedre resultater, når den har kontekst. Der findes tre bufferstrategier.
Efter sætning
Vent på et sætningsafgrænsningstegn (., !, ?, linjeskift) før afsendelse:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Dette giver den bedste balance mellem kvalitet og ventetid.
Efter størrelse
Send, når bufferen når en bestemt størrelse (f.eks. 200 tegn):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Det er enklere, men kan risikere at klippe et ord midt over.
Efter timeout
Send efter en forsinkelse uden nye tokens (nyttigt, mens LLM’en tænker):
last_token_time = time.time()
# Hvis der går mere end 500 ms uden et token, sendes bufferen
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Afspilning af lyd i realtid
For at afspille lyden, efterhånden som den ankommer (i stedet for blot at indsamle den), skal du bruge en asynkron kø:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Modtager lydbidder og lægger dem i køen."""
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) # Slut-markør
break
async def play_audio():
"""Afspiller lydbidder fra køen."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Afspil bidden (pyaudio, sounddevice osv.)
play_chunk(chunk)
Ved at køre receive_audio og play_audio parallelt, starter afspilningen med det første modtagne bid.
Håndtering af fejl i pipeline
Pipeline’en kan fejle tre steder: hos LLM’en, hos TTS eller i netværket. Håndter hver enkelt:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM-fejl: tjek din forbindelse")
except websockets.ConnectionClosed:
print("TTS-forbindelse tabt: genoprettelse nødvendig")
except json.JSONDecodeError:
print("Ugyldigt svar: uventet format")
except Exception as e:
print(f"Uventet fejl: {e}")
return None
Vigtige pointer
- En streamende LLM, der fodrer TTS WebSocket, giver den laveste ventetid
- Buffer efter sætning for den bedste balance mellem kvalitet og ventetid
- Brug en asynkron kø til afspilning af lyd i realtid
- Håndter fejl i hvert led af pipeline’en
- Den samlede mængde tekst over WebSocket er ubegrænset (deltas på op til 60.000 tegn)
- Grænsen på 50 samtidige sessioner gælder for hele dit team