Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Streaming-Pipeline von LLM zu TTS

Lektion 12 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. LLM mit Echtzeit-Sprachsynthese verbinden
  2. Architektur der Pipeline
  3. Implementierung in Python
  4. Pufferstrategie
  5. Echtzeit-Audiowiedergabe
  6. Fehlerbehandlung in der Pipeline
  7. Kernaussagen

Aktualisiert am 3. November 2026, basierend auf der xAI-Seite Text to Speech: Jedes text.delta kann 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.