Przejdź do głównej treści
Polski— Wybierz język
Menu

Potok strumieniowy od LLM do TTS

Lekcja 12 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Podłącz LLM do syntezy mowy w czasie rzeczywistym
  2. Architektura potoku
  3. Implementacja w Pythonie
  4. Strategia buforowania
  5. Odtwarzanie audio w czasie rzeczywistym
  6. Obsługa błędów w potoku
  7. Kluczowe wnioski

Zaktualizowano 3 listopada 2026 r. na podstawie strony xAI Text to Speech: każde text.delta może zawierać do 60 000 znaków. Źródło: Text to Speech.

Podłącz LLM do syntezy mowy w czasie rzeczywistym

Najpotężniejszym zastosowaniem WebSocket TTS jest połączenie go ze strumieniowym modelem LLM. LLM generuje tekst token po tokenie, każdy token trafia do TTS przez WebSocket, a dźwięk jest odtwarzany w miarę jego otrzymywania. Użytkownik słyszy odpowiedź, gdy LLM wciąż jeszcze „myśli“.

Architektura potoku

Dane przepływają przez trzy etapy:

Użytkownik -> LLM (strumieniowo) -> TTS WebSocket -> Audio (odtwarzanie)
pytanie      tokeny tekstu           audio.delta       głośnik

Każdy etap działa w trybie strumieniowym, co minimalizuje postrzegane opóźnienia. Użytkownik nie czeka, aż LLM zakończy generowanie całej odpowiedzi, zanim zacznie jej słuchać.

Implementacja w Pythonie

Oto kompletny potok łączący API Grok Chat Completions z TTS WebSocket:

import asyncio
import websockets
import json
import base64
import aiohttp

async def llm_to_speech(api_key, prompt, voice="rex", language="en"):
    # Krok 1: Połączenie 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:

        # Krok 2: Strumieniowe wywołanie 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:

                # Krok 3: Każdy 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
                        # Wysyłaj kompletne zdania
                        if any(c in token for c in ".!?\n"):
                            await tts_ws.send(json.dumps({
                                "type": "text.delta",
                                "delta": buffer
                            }))
                            buffer = ""

                # Wyślij wszystko, co pozostało w buforze
                if buffer:
                    await tts_ws.send(json.dumps({
                        "type": "text.delta",
                        "delta": buffer
                    }))

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

        # Krok 4: Zbieranie audio
        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)

Strategia buforowania

Wysyłanie każdego tokena do TTS z osobna nie jest idealne: silnik syntezy osiąga lepsze rezultaty, gdy ma dostęp do kontekstu. Istnieją trzy strategie buforowania.

Według zdania

Poczekaj na znak kończący zdanie (., !, ?, znak nowej linii) przed wysłaniem:

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

To najlepszy kompromis między jakością a opóźnieniem.

Według rozmiaru

Wyślij dane, gdy bufor osiągnie określony rozmiar (np. 200 znaków):

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

Jest to prostsze, ale może przeciąć słowo w połowie.

Według limitu czasu

Wyślij dane po upływie określonego czasu bez nowego tokena (przydatne, gdy LLM „myśli“):

last_token_time = time.time()

# Jeśli minie więcej niż 500 ms bez tokena, wyślij bufor
if time.time() - last_token_time > 0.5 and buffer:
    await tts_ws.send(...)
    buffer = ""

Odtwarzanie audio w czasie rzeczywistym

Aby odtwarzać audio w miarę jego otrzymywania (a nie tylko je zbierać), użyj asynchronicznej kolejki:

import asyncio

audio_queue = asyncio.Queue()

async def receive_audio(tts_ws):
    """Odbiera fragmenty audio i umieszcza je w kolejce."""
    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)  # Sentinel końca
            break

async def play_audio():
    """Odtwarza fragmenty audio z kolejki."""
    while True:
        chunk = await audio_queue.get()
        if chunk is None:
            break
        # Odtwórz fragment (pyaudio, sounddevice itp.)
        play_chunk(chunk)

Uruchamiając receive_audio i play_audio równolegle, odtwarzanie rozpoczyna się wraz z otrzymaniem pierwszego fragmentu.

Obsługa błędów w potoku

Potok może ulec awarii w trzech miejscach: w LLM, w TTS lub w sieci. Obsłuż każdy z tych przypadków:

async def robust_pipeline(api_key, prompt):
    try:
        audio = await llm_to_speech(api_key, prompt)
        return audio
    except aiohttp.ClientError:
        print("Błąd LLM: sprawdź połączenie")
    except websockets.ConnectionClosed:
        print("Utracono połączenie TTS: wymagane ponowne połączenie")
    except json.JSONDecodeError:
        print("Nieprawidłowa odpowiedź: nieoczekiwany format")
    except Exception as e:
        print(f"Nieoczekiwany błąd: {e}")
    return None

Kluczowe wnioski

  • Strumieniowy LLM zasilający TTS przez WebSocket zapewnia najniższe opóźnienia
  • Buforuj według zdań, aby uzyskać najlepszy kompromis między jakością a opóźnieniem
  • Używaj asynchronicznej kolejki do odtwarzania audio w czasie rzeczywistym
  • Obsługuj błędy na każdym etapie potoku
  • Całkowita ilość tekstu przesyłanego przez WebSocket jest nieograniczona (delty do 60 000 znaków)
  • Limit 50 równoczesnych sesji dotyczy całego zespołu