Streaming-Pipeline von LLM zu TTS
Auf dieser Seite
Aktualisiert am 3. November 2026, basierend auf der xAI-Seite Text to Speech: Jedes
text.deltakann bis zu 60.000 Zeichen halten. Quelle: Text to Speech.
LLM mit Echtzeit-Sprachsynthese verbinden
Die leistungsfähigste Anwendung des TTS-WebSockets besteht darin, ihn mit einem strömenden LLM zu verketten. Das LLM generiert Text-Token für Token; jedes Token wird über WebSocket an die TTS weitergeleitet, und das Audio wird abgerufen, sobald es eintrifft. Der Nutzer hört die Antwort, während das LLM noch nachdenkt.
Architektur der Pipeline
Die Daten fließen durch drei Stufen:
User -> LLM (streaming) -> TTS WebSocket -> Audio (Wiedergabe)
question text tokens audio.delta speaker
Jede Stufe strömt, was die wahrgenommene Latenz minimiert. Der Nutzer wartet nicht darauf, dass das LLM seine gesamte Antwort generiert, bevor er hören kann.
Implementierung in Python
Hier ist eine vollständige Pipeline, die die Grok Chat Completions API mit dem TTS-WebSocket verbindet:
import asyncio
import websockets
import json
import base64
import aiohttp
async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
# Schritt 1: TTS-WebSocket-Verbindung
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:
# Schritt 2: Strömender LLM-Aufruf
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:
# Schritt 3: Jedes 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
# Senden vollständiger Sätze
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
buffer = ""
# Senden des verbleibenden Inhalts im Puffer
if buffer:
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
await tts_ws.send(json.dumps({"type": "text.done"}))
# Schritt 4: Audio sammeln
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)
Pufferstrategie
Das Senden jedes Tokens einzeln an die TTS ist nicht ideal: Die Synthese-Engine liefert bessere Ergebnisse, wenn sie Kontext hat. Es gibt drei Pufferstrategien.
Nach Satz
Warten Sie auf einen Satz-Trennzeichen (., !, ?, Zeilenumbruch), bevor Sie senden:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Dies ist das beste Gleichgewicht zwischen Qualität und Latenz.
Nach Größe
Senden Sie, wenn der Puffer eine bestimmte Größe erreicht (z. B. 200 Zeichen):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Es ist einfacher, kann aber ein Wort in der Mitte abschneiden.
Nach Zeitüberschreitung
Senden Sie nach einer Verzögerung ohne neues Token (nützlich, während das LLM nachdenkt):
last_token_time = time.time()
# Wenn mehr als 500 ms vergehen, ohne ein Token, senden Sie den Puffer
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Echtzeit-Audiowiedergabe
Um das Audio abzuspielen, sobald es eintrifft (nicht nur zu sammeln), verwenden Sie eine asynchrone Warteschlange:
import asyncio
audio_queue = asyncio.Queue()
async def receive_audio(tts_ws):
"""Empfängt Audio-Blöcke und legt sie in die Warteschlange ab."""
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) # Ende-Sentinel
break
async def play_audio():
"""Spielt Audio-Blöcke aus der Warteschlange ab."""
while True:
chunk = await audio_queue.get()
if chunk is None:
break
# Abspielen des Blocks (pyaudio, sounddevice, etc.)
play_chunk(chunk)
Indem Sie receive_audio und play_audio parallel ausführen, beginnt die Wiedergabe mit dem ersten empfangenen Block.
Fehlerbehandlung in der Pipeline
Die Pipeline kann an drei Stellen versagen: beim LLM, bei der TTS oder im Netzwerk. Behandeln Sie jeden Fall:
async def robust_pipeline(api_key, prompt):
try:
audio = await llm_to_speech(api_key, prompt)
return audio
except aiohttp.ClientError:
print("LLM-Fehler: überprüfen Sie Ihre Verbindung")
except websockets.ConnectionClosed:
print("TTS-Verbindung verloren: Neuanbindung erforderlich")
except json.JSONDecodeError:
print("Ungültige Antwort: unerwartetes Format")
except Exception as e:
print(f"Unerwarteter Fehler: {e}")
return None
Kernaussagen
- Ein strömendes LLM, das die TTS-WebSocket speist, bietet die niedrigste Latenz.
- Buffern Sie nach Sätzen für das beste Gleichgewicht zwischen Qualität und Latenz.
- Verwenden Sie eine asynchrone Warteschlange für die Echtzeit-Audiowiedergabe.
- Behandeln Sie Fehler an jeder Stufe der Pipeline.
- Die Gesamttextmenge über WebSocket ist unbegrenzt (Deltas von bis zu 60.000 Zeichen).
- Das Limit von 50 gleichzeitigen Sitzungen gilt für Ihr gesamtes Team.