Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Píblíne sruthú ó LLM go TTS

Ceacht 12 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. LLM a nascadh le sintéis cainte fíor-ama
  2. Ailtireacht na píblíne
  3. Cur chun feidhme i bPython
  4. Straitéis mhaolánaithe
  5. Seinm fuaime fíor-ama
  6. Láimhseáil earráidí sa phíblíne
  7. Príomhphointí

Nuashonraithe an 3 Samhain 2026, bunaithe ar an leathanach Text to Speech ó xAI: is féidir le gach text.delta suas le 60,000 carachtar a shealbhú. Foinse: Text to Speech.

LLM a nascadh le sintéis cainte fíor-ama

Is é an úsáid is cumhachtaí a bhaintear as TTS WebSocket ná é a shlabhrú le LLM sruthúcháin. Gineann an LLM téacs token ar thoken, téann gach token chuig an TTS thar WebSocket, agus seinntear an fuaime de réir mar a thagann sí. Cloiseann an t-úsáideoir an freagra agus an LLM fós ag smaoineamh.

Ailtireacht na píblíne

Sreabhann na sonraí trí thrí chéim:

User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question   text tokens        audio.delta       speaker

Déanann gach céim sruthú, rud a íoslaghdaíonn an mhoill mheasta. Ní gá don úsáideoir fanacht go gcríochnóidh an LLM a fhreagra iomlán sula dtosaíonn sé/sí ag éisteacht leis.

Cur chun feidhme i bPython

Seo píblíne iomlán a nascann API Críochnuithe Comhrá Grok le TTS WebSocket:

import asyncio
import websockets
import json
import base64
import aiohttp

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

        # Céim 2: Glaoch ar an LLM sruthúcháin
        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:

                # Céim 3: Gach token 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
                        # Seol abairtí iomlána
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Seol aon rud atá fágtha sa mhaolán
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # Céim 4: Bailigh an fhuaim
        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)

Straitéis mhaolánaithe

Níl sé idéalach gach token a sheoladh chuig an TTS go haonair: bíonn torthaí níos fearr ag an inneall sintéise nuair a bhíonn comhthéacs aige. Tá trí straitéis mhaolánaithe ann.

De réir abairte

Fan go mbíonn teorainneoir abairte (. ! ?, briseadh líne) ann sula seolann tú:

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

Is é seo an chothromaíocht is fearr idir cáilíocht agus moill.

De réir méide

Seol nuair a shroicheann an maolán méid áirithe (200 carachtar, mar shampla):

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

Tá sé níos simplí ach d’fhéadfadh sé focal a ghearradh ina dhá leath.

De réir teorainn ama

Seol tar éis moille gan aon token nua (úsáideach agus an LLM ag smaoineamh):

last_token_time = time.time()

# Má théann níos mó ná 500 ms thart gan token, seol an maolán
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Seinm fuaime fíor-ama

Chun an fhuaim a sheinm de réir mar a thagann sí (seachas í a bhailiú amháin), úsáid ciú async:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Faigheann sé píosaí fuaime agus cuireann sa chiú iad."""
    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)  # Seantainéal deiridh
            break

async def play_audio():
    """Seinneann sé píosaí fuaime ón gciú."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Seinm an phíosa (pyaudio, sounddevice, etc.)
        play_chunk(chunk)

Trí receive_audio agus play_audio a rith i gcomhthreomhar, tosaíonn an tseinm leis an gcéad phíosa a fhaightear.

Láimhseáil earráidí sa phíblíne

Is féidir leis an bpíblíne teip a dhéanamh in áit ar bith de na trí áit seo: an LLM, an TTS, nó an líonra. Déileáil le gach ceann acu:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("Earráid LLM: seiceáil do nasc")
    except websockets.ConnectionClosed:
        print("Nasc TTS caillte: athnascadh ag teastáil")
    except json.JSONDecodeError:
        print("Freagra neamhbhailí: formáid gan choinne")
    except Exception as e:
        print(f"Earráid gan choinne: {e}")
    return None

Príomhphointí

  • Soláthraíonn LLM sruthúcháin a bheathaíonn TTS WebSocket an mhoill is ísle
  • Maoláin de réir abairte don chothromaíocht is fearr idir cáilíocht agus moill
  • Úsáid ciú async do sheinm fuaime fíor-ama
  • Déileáil le hearráidí ag gach céim den phíblíne
  • Níl aon teorainn leis an téacs iomlán thar WebSocket (deltas suas le 60,000 carachtar)
  • Baineann an teorainn 50 seisiún comhthreomhar le do fhoireann ar fad