Премини към основното съдържание
Български— Изберете език
Меню

Поток от LLM към TTS в реално време

Урок 12 от 14 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Свързване на LLM със синтез на реч в реално време
  2. Архитектура на потока
  3. Имплементация на Python
  4. Стратегия за буфериране
  5. Възпроизвеждане на аудио в реално време
  6. Обработка на грешки в потока
  7. Ключови изводи

Обновено на 3 ноември 2026 г., въз основа на страницата Text to Speech на xAI: всяко text.delta може да съдържа до 60 000 знака. Източник: Text to Speech.

Свързване на LLM със синтез на реч в реално време

Най-мощното приложение на TTS WebSocket е верижното му свързване със стрийминг LLM. LLM генерира текст токен по токен, всеки токен се изпраща към TTS през WebSocket, а аудиото се възпроизвежда веднага щом пристигне. Потребителят чува отговора, докато LLM все още мисли.

Архитектура на потока

Данните преминават през три етапа:

Потребител -> LLM (стрийминг) -> TTS WebSocket -> Аудио (възпроизвеждане)
въпрос     текстови токени      audio.delta       говорител

Всеки етап работи в режим на поток, което минимизира възприеманото забавяне. Потребителят не чака LLM да завърши генерирането на целия отговор, преди да започне да го чува.

Имплементация на Python

Ето цялостен поток, който свързва Grok Chat Completions API с 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: 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: Стрийминг обаждане към 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: Всеки LLM токен -> 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
                        # Изпращане на завършени изречения
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Изпращане на останалото в буфера
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # Стъпка 4: Събиране на аудиото
        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)

Стратегия за буфериране

Изпращането на всеки токен към TTS поотделно не е идеално: двигателът за синтез произвежда по-добри резултати, когато разполага с контекст. Съществуват три стратегии за буфериране.

По изречения

Изчакайте разделител на изречение (., !, ?, нов ред), преди да изпратите:

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

Това е най-добрият баланс между качество и забавяне.

По размер

Изпращайте, когато буферът достигне определен размер (например 200 знака):

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

По-просто е, но може да разреже дума по средата.

По таймаут

Изпращайте след забавяне без нов токен (полезно, докато LLM мисли):

last_token_time = time.time()

# Ако минат повече от 500 ms без токен, изпратете буфера
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Възпроизвеждане на аудио в реално време

За да възпроизвеждате аудиото, докато пристига (а не просто да го събирате), използвайте асинхронна опашка:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Получава аудио чънкове и ги поставя в опашката."""
    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)  # Маркер за край
            break

async def play_audio():
    """Възпроизвежда аудио чънкове от опашката."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Възпроизвеждане на чънка (pyaudio, sounddevice и др.)
        play_chunk(chunk)

Като стартирате receive_audio и play_audio паралелно, възпроизвеждането започва с първия получен чънк.

Обработка на грешки в потока

Потокът може да се провали на три места: LLM, TTS или мрежата. Обработете всяко от тях:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("Грешка в LLM: проверете връзката си")
    except websockets.ConnectionClosed:
        print("TTS връзката е прекъсната: необходимо е повторно свързване")
    except json.JSONDecodeError:
        print("Невалиден отговор: неочакван формат")
    except Exception as e:
        print(f"Неочаквана грешка: {e}")
    return None

Ключови изводи

  • Стрийминг LLM, захранващ TTS WebSocket, осигурява най-ниското забавяне
  • Буферирайте по изречения за най-добър баланс между качество и забавяне
  • Използвайте асинхронна опашка за възпроизвеждане на аудио в реално време
  • Обработвайте грешките на всеки етап от потока
  • Общият текст през WebSocket е неограничен (делти до 60 000 знака)
  • Лимитът от 50 едновременни сесии важи за целия Ви екип