Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Streaming-putki LLM:stä puheeksi

Oppitunti 12 / 14 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Yhdistä LLM reaaliaikaiseen puhesynteesiin
  2. Putkiarkkitehtuuri
  3. Toteutus Pythonilla
  4. Puskurointistrategia
  5. Reaaliaikainen äänen toisto
  6. Virheenkäsittely putkessa
  7. Keskeiset asiat

Päivitetty 3. marraskuuta 2026 xAI:n Text to Speech -sivun perusteella: jokainen text.delta voi sisältää jopa 60 000 merkkiä. Lähde: Text to Speech.

Yhdistä LLM reaaliaikaiseen puhesynteesiin

Tehokkain tapa hyödyntää TTS WebSocketia on ketjuttaa se suoratoistavaan LLM-malliin. LLM tuottaa tekstiä merkki merkiltä, jokainen merkki lähetetään TTS:lle WebSocketin yli, ja ääni toistetaan saapumisjärjestyksessä. Käyttäjä kuulee vastauksen jo mientras LLM vielä “ajattelee”.

Putkiarkkitehtuuri

Tieto virtaa kolmen vaiheen kautta:

Käyttäjä -> LLM (suoratoisto) -> TTS WebSocket -> Ääni (toisto)
kysymys   tekstimerkit        audio.delta       kaiutin

Jokainen vaihe on suoratoistava, mikä minimoi koetun viiveen. Käyttäjän ei tarvitse odottaa LLM:n valmistavan koko vastausta ennen kuin hän alkaa kuulla sitä.

Toteutus Pythonilla

Tässä on täydellinen putki, joka yhdistää Grok Chat Completions -rajapinnan TTS WebSocketiin:

import asyncio
import websockets
import json
import base64
import aiohttp

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

        # Vaihe 2: Suoratoistava LLM-kutsu
        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:

                # Vaihe 3: Jokainen LLM-merkki -> 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
                        # Lähetä kokonaiset lauseet
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Lähetä puskurissa oleva jäljellä oleva teksti
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # Vaihe 4: Kerää ääni
        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)

Puskurointistrategia

Jokaisen merkin lähettäminen erikseen TTS:lle ei ole ihanteellista: synteesimoottori tuottaa parempia tuloksia, kun sillä on kontekstia. Käytössä on kolme puskurointistrategiaa.

Lausetta kohden

Odota lauseen erotinmerkkiä (. ! ? tai rivinvaihtoa) ennen lähettämistä:

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

Tämä tarjoaa parhaan tasapainon laadun ja viiveen välillä.

Kokoa kohden

Lähetä, kun puskuri saavuttaa tietyn koon (esimerkiksi 200 merkkiä):

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

Tämä on yksinkertaisempaa, mutta voi katkaista sanan keskeltä.

Aikakatkaisua kohden

Lähetä viiveen jälkeen, jos uusia merkkejä ei ole saapunut (hyödyllinen, kun LLM “ajattelee”):

last_token_time = time.time()

# Jos yli 500 ms kuluu ilman merkkiä, lähetä puskuri
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Reaaliaikainen äänen toisto

Toista ääni saapumisjärjestyksessä (älä vain kerää sitä) käyttämällä asynkronista jonoa:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Vastaanottaa äänipaloja ja laittaa ne jonoon."""
    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)  # Lopetusmerkki
            break

async def play_audio():
    """Toistaa äänipaloja jonosta."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Toista pala (pyaudio, sounddevice jne.)
        play_chunk(chunk)

Kun suoritat receive_audio- ja play_audio-funktiot rinnakkain, toisto alkaa ensimmäisen vastaanotetun palan myötä.

Virheenkäsittely putkessa

Putki voi epäonnistua kolmessa paikassa: LLM, TTS tai verkko. Käsittele jokainen niistä:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("LLM-virhe: tarkista yhteys")
    except websockets.ConnectionClosed:
        print("TTS-yhteys katkesi: uudelleenyhdistys tarvitaan")
    except json.JSONDecodeError:
        print("Virheellinen vastaus: odottamaton muoto")
    except Exception as e:
        print(f"Odottamaton virhe: {e}")
    return None

Keskeiset asiat

  • Suoratoistava LLM, joka syöttää TTS WebSocketia, tarjoaa pienimmän viiveen
  • Puskuroi lausetta kohden saavuttaaksesi parhaan tasapainon laadun ja viiveen välillä
  • Käytä asynkronista jonoa reaaliaikaiseen äänen toistoon
  • Käsittele virheet putken jokaisessa vaiheessa
  • WebSocketin yli lähetettävän tekstin kokonaismäärä on rajoittamaton (deltat jopa 60 000 merkkiä)
  • 50 samanaikaisen istunnon raja koskee koko tiimiäsi