Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Streaming adatfolyam LLM-től a TTS-ig

12. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. LLM csatlakoztatása valós idejű beszédszintézishez
  2. A rendszerarchitektúra
  3. Megvalósítás Pythonban
  4. Pufferelési stratégiák
  5. Valós idejű hanglejátszás
  6. Hibakezelés az adatfolyamban
  7. Főbb megállapítások

Frissítve: 2026. november 3., az xAI Text to Speech oldala alapján: minden text.delta legfeljebb 60 000 karaktert tartalmazhat. Forrás: Text to Speech.

LLM csatlakoztatása valós idejű beszédszintézishez

A TTS WebSocket leghatékonyabb alkalmazása egy streaming LLM-mel való láncolás. Az LLM tokenről tokenre generálja a szöveget, minden egyes token a WebSocketen keresztül a TTS-hez kerül, és a hanganyag már érkezés közben lejátszásra kerül. A felhasználó már akkor hallja a választ, amikor az LLM még mindig a gondolkodási fázisban van.

A rendszerarchitektúra

Az adatfolyam három szakaszon halad át:

Felhasználó -> LLM (streaming) -> TTS WebSocket -> Hang (lejátszás)
kérdés   szöveg tokenek        audio.delta       hangszóró

Minden szakasz streaming módban működik, ami minimalizálja az észlelt késleltetést. A felhasználónak nem kell megvárnia, amíg az LLM befejezi a teljes válasz generálását, mielőtt elkezdené hallani azt.

Megvalósítás Pythonban

Íme egy teljes körű adatfolyam, amely összeköti a Grok Chat Completions API-t a TTS WebSockettel:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # 1. lépés: TTS WebSocket kapcsolat
    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. lépés: Streaming LLM hívás
        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. lépés: Minden 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
                        # Teljes mondatok küldése
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # A pufferben maradt tartalom elküldése
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # 4. lépés: Hanganyag összegyűjtése
        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)

Pufferelési stratégiák

Az egyes tokenek egyenkénti elküldése a TTS-nek nem ideális: a szintetizáló motor jobb eredményeket produkál, ha rendelkezik kontextussal. Három fő pufferelési stratégia létezik.

Mondatonként

Várj egy mondatlezáró karakterre (., !, ?, sorvége) a küldés előtt:

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

Ez biztosítja a legjobb egyensúlyt a minőség és a késleltetés között.

Méret alapján

Küldj, amikor a puffer elér egy bizonyos méretet (például 200 karaktert):

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

Ez egyszerűbb, de előfordulhat, hogy félbevág egy szót.

Időtúllépés alapján

Küldj egy késleltetés után, ha nem érkezik új token (hasznos, amíg az LLM gondolkodik):

last_token_time = time.time()

# Ha több mint 500 ms telik el token nélkül, küldd el a puffert
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Valós idejű hanglejátszás

Ahhoz, hogy a hanganyagot érkezés közben lejátszd (ne csak összegyűjtsd), használj egy aszinkron queue-t:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Fogadja a hangrészeket, és beteszi őket a queue-ba."""
    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)  # Lezáró jelző
            break

async def play_audio():
    """Lejátssza a hangrészeket a queue-ból."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # A rész lejátszása (pyaudio, sounddevice, stb.)
        play_chunk(chunk)

A receive_audio és a play_audio párhuzamos futtatásával a lejátszás már az első beérkező résszel elindul.

Hibakezelés az adatfolyamban

Az adatfolyam három helyen is meghibásodhat: az LLM-nél, a TTS-nél vagy a hálózaton. Kezeld le mindegyiket:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("LLM hiba: ellenőrizd a kapcsolatot")
    except websockets.ConnectionClosed:
        print("TTS kapcsolat megszakadt: újracsatlakozás szükséges")
    except json.JSONDecodeError:
        print("Érvénytelen válasz: váratlan formátum")
    except Exception as e:
        print(f"Váratlan hiba: {e}")
    return None

Főbb megállapítások

  • Egy streaming LLM, amely táplálja a TTS WebSocketet, biztosítja a legalacsonyabb késleltetést
  • Pufferelj mondatonként a minőség és a késleltetés legjobb egyensúlya érdekében
  • Használj aszinkron queue-t a valós idejű hanglejátszáshoz
  • Kezeld a hibákat az adatfolyam minden szakaszában
  • A WebSocketen keresztül küldött teljes szöveg mennyisége korlátlan (legfeljebb 60 000 karakteres delták)
  • Az egyszerre 50 munkamenetre vonatkozó korlát az egész csapatodra érvényes