Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Strömningspipeline från LLM till TTS

Lektion 12 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Koppla en LLM till talgenerering i realtid
  2. Pipeline-arkitektur
  3. Implementering i Python
  4. Buffringsstrategi
  5. Ljuduppspelning i realtid
  6. Felhantering i pipelinen
  7. Viktiga punkter

Uppdaterat den 3 november 2026, baserat på xAI:s sida Text to Speech: varje text.delta kan 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