Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Cevovod za pretakanje od LLM do TTS

Lekcija 12 od 14 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Poveži LLM s sintezo govora v realnem času
  2. Arhitektura cevovoda
  3. Implementacija v Pythonu
  4. Strategija medpomnjenja
  5. Predvajanje zvoka v realnem času
  6. Obravnava napak v cevovodu
  7. Ključne ugotovitve

Posodobljeno 3. novembra 2026, na podlagi strani xAI Text to Speech: vsak text.delta lahko vsebuje do 60.000 znakov. Vir: Text to Speech.

Poveži LLM s sintezo govora v realnem času

Najzmogljivejša uporaba TTS WebSocket je njegovo zaporedno povezovanje s pretakajočim se LLM. LLM generira besedilo žeton za žetonom, vsak žeton potuje do TTS prek WebSocket, zvok pa se predvaja, ko prispe. Uporabnik sliši odgovor, medtem ko LLM še vedno razmišlja.

Arhitektura cevovoda

Podatki tečejo skozi tri faze:

Uporabnik -> LLM (pretakanje) -> TTS WebSocket -> Zvok (predvajanje)
vprašanje   besedilni žetoni        audio.delta       zvočnik

Vsaka faza deluje s pretakanjem, kar minimizira zaznavno zakasnitev. Uporabniku ni treba čakati, da LLM konča z generiranjem celotnega odgovora, preden ga začne slišati.

Implementacija v Pythonu

Tukaj je celovit cevovod, ki povezuje Grok Chat Completions API s TTS WebSocket:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # 1. korak: Povezava TTS WebSocket
    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:

        # 2. korak: Klic pretakajočega se LLM
        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:

                # 3. korak: Vsak žeton LLM -> delta TTS
                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
                        # Pošlji kompletne stavke
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Pošlji vse, kar je ostalo v medpomnilniku
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

                await tts_ws.send(json.dumps({"type": "text.done"}))

        # 4. korak: Zberi zvok
        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)

Strategija medpomnjenja

Pošiljanje vsakega žetona v TTS posebej ni idealno: sintezni motor daje boljše rezultate, ko ima kontekst. Obstajajo tri strategije medpomnjenja.

Po stavkih

Počakaj na ločilo stavka (., !, ?, prelom vrstice), preden pošlješ:

if any(c in token for c in ".!?\n"):
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

To je najboljše ravnovesje med kakovostjo in zakasnitvijo.

Po velikosti

Pošlji, ko medpomnilnik doseže določeno velikost (npr. 200 znakov):

if len(buffer) >= 200:
    await tts_ws.send(json.dumps({
        "type": "text.delta", "delta": buffer
    }))
    buffer = ""

To je preprosteje, vendar lahko prereže besedo na pol.

Po časovni omejitvi

Pošlji po zamiku brez novega žetona (uporabno, medtem ko LLM razmišlja):

last_token_time = time.time()

# Če mine več kot 500 ms brez žetona, pošlji medpomnilnik
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Predvajanje zvoka v realnem času

Če želiš predvajati zvok, ko prispe (namesto da ga le zbiraš), uporabi asinhrono vrsto:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Prejme zvočne dele in jih doda v vrsto."""
    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)  # Končni sentinel
            break

async def play_audio():
    """Predvaja zvočne dele iz vrste."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Predvajaj del (pyaudio, sounddevice itd.)
        play_chunk(chunk)

S sočasnim zagonom receive_audio in play_audio se predvajanje začne s prvim prejetim delom.

Obravnava napak v cevovodu

Cevovod lahko odpove na treh mestih: pri LLM, TTS ali v omrežju. Obravnavaj vsakega posebej:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("Napaka LLM: preveri svojo povezavo")
    except websockets.ConnectionClosed:
        print("Povezava TTS prekinjena: potrebna je ponovna vzpostavitev")
    except json.JSONDecodeError:
        print("Neveljaven odgovor: nepričakovana oblika")
    except Exception as e:
        print(f"Nepričakovana napaka: {e}")
    return None

Ključne ugotovitve

  • Pretakajoč se LLM, ki napaja TTS WebSocket, zagotavlja najnižjo zakasnitev
  • Medpomni po stavkih za najboljše ravnovesje med kakovostjo in zakasnitvijo
  • Uporabi asinhrono vrsto za predvajanje zvoka v realnem času
  • Obravnavaj napake na vsaki stopnji cevovoda
  • Skupno besedilo prek WebSocket je neomejeno (delti do 60.000 znakov)
  • Omejitev 50 sočasnih sej velja za celo tvojo ekipo