Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Andmevoogude torustik LLM-ist kõnesünteesi

Õppetund 12 / 14 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Ühenda LLM reaalajas kõnesünteesiga
  2. Torustiku arhitektuur
  3. Teostus Pythonis
  4. Puhverdamise strateegia
  5. Reaalajas heliesitus
  6. Veakäsitlus torustikus
  7. Peamised punktid

Uuendatud 3. novembril 2026, tuginedes xAI Text to Speech lehele: iga text.delta võib sisaldada kuni 60 000 tähemärki. Allikas: Text to Speech.

Ühenda LLM reaalajas kõnesünteesiga

TTS WebSocketi võimsaim kasutusviis on selle aheldamine voogedastava LLM-iga. LLM genereerib teksti tokenite kaupa, iga token saadetakse TTS-ile üle WebSocketi ja heli esitatakse saabumise hetkel. Kasutaja kuuleb vastust juba siis, kui LLM veel mõtleb.

Torustiku arhitektuur

Andmed läbivad kolm etappi:

Kasutaja -> LLM (voogedastus) -> TTS WebSocket -> Heli (esitus)
küsimus   teksti tokenid        audio.delta       kõlar

Iga etapp toimib voogedastusena, mis minimeerib tajutavat latentsust. Kasutaja ei pea ootama, kuni LLM on kogu vastuse genereerinud, enne kui ta seda kuulma hakkab.

Teostus Pythonis

Siin on täielik torustik, mis ühendab Grok Chat Completions API TTS WebSocketiga:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # 1. samm: TTS WebSocketi ühendus
    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. samm: Voogedastav LLM-i päring
        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. samm: Iga LLM-i 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
                        # Saada terved laused
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Saada puhvrisse jäänud ülejääk
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # 4. samm: Heli kogumine
        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)

Puhverdamise strateegia

Iga tokeni eraldi saatmine TTS-ile pole ideaalne: sünteesimootor annab paremaid tulemusi, kui tal on konteksti. On olemas kolm puhverdamise strateegiat.

Lauseti

Oota lause eraldusmärki (., !, ?, reavahetus) enne saatmist:

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

See on parim tasakaal kvaliteedi ja latentsuse vahel.

Mahuti

Saada, kui puhver jõuab teatud suurusele (näiteks 200 tähemärki):

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

See on lihtsam, kuid võib sõna pooleli jätta.

Ajapiirangu järgi

Saada pärast viivitust ilma uue tokenita (kasulik, kui LLM mõtleb):

last_token_time = time.time()

# Kui möödub rohkem kui 500 ms ilma tokenita, saada puhver
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Reaalajas heliesitus

Heli esitamiseks saabumise hetkel (mitte ainult selle kogumiseks) kasuta asünkroonset järjekorda:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Võtab vastu helilõike ja paneb need järjekorda."""
    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)  # Lõpumarker
            break

async def play_audio():
    """Esitab helilõike järjekorrast."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Esita lõik (pyaudio, sounddevice jne)
        play_chunk(chunk)

Käivitades receive_audio ja play_audio paralleelselt, algab esitus esimese saabunud lõiguga.

Veakäsitlus torustikus

Torustik võib nurjuda kolmes kohas: LLM, TTS või võrk. Käitle igaüks neist:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("LLM-i viga: kontrolli ühendust")
    except websockets.ConnectionClosed:
        print("TTS-i ühendus katkes: vaja uuesti ühenduda")
    except json.JSONDecodeError:
        print("Vigane vastus: ootamatu vorming")
    except Exception as e:
        print(f"Ootamatu viga: {e}")
    return None

Peamised punktid

  • Voogedastav LLM, mis toidab TTS WebSocketit, annab väikseima latentsuse
  • Puhverda lauseti parima kvaliteedi ja latentsuse tasakaalu saavutamiseks
  • Kasuta reaalajas heliesituseks asünkroonset järjekorda
  • Käitle vigu torustiku igas etapis
  • Teksti üldmaht üle WebSocketi on piiramatu (deltasid kuni 60 000 tähemärki)
  • Piirang 50 samaaegsele seansile kehtib kogu meeskonna kohta