Potok strumieniowy od LLM do TTS
Na tej stronie
Zaktualizowano 3 listopada 2026 r. na podstawie strony xAI Text to Speech: każde
text.deltamoż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