Ροή μετάδοσης από LLM σε TTS
Σε αυτήν τη σελίδα
Ενημερώθηκε στις 3 Νοεμβρίου 2026, με βάση τη σελίδα Text to Speech της xAI: κάθε
text.deltaμπορεί να περιέχει έως και 60.000 χαρακτήρες. Πηγή: Text to Speech.
Σύνδεση ενός LLM με σύνθεση ομιλίας σε πραγματικό χρόνο
Η πιο ισχυρή χρήση του TTS WebSocket είναι η αλυσίδωσή του με ένα LLM ροής (streaming). Το LLM παράγει κείμενο token προς token, κάθε token μεταφέρεται στο TTS μέσω WebSocket και ο ήχος αναπαράγεται μόλις φτάνει. Ο χρήστης ακούει την απάντηση ενώ το LLM σκέφτεται ακόμα.
Αρχιτεκτονική ροής δεδομένων
Τα δεδομένα ρέουν μέσω τριών σταδίων:
User -> LLM (streaming) -> TTS WebSocket -> Audio (playback)
question text tokens audio.delta speaker
Κάθε στάδιο λειτουργεί ως ροή, ελαχιστοποιώντας την αντιληπτή καθυστέρηση. Ο χρήστης δεν περιμένει να ολοκληρώσει το LLM τη δημιουργία ολόκληρης της απάντησής του πριν αρχίσει να την ακούει.
Υλοποίηση σε Python
Ακολουθεί μια πλήρης ροή που συνδέει το API Grok Chat Completions με το 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: Κλήση Streaming 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: Κάθε 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
# Αποστολή ολοκληρωμένων προτάσεων
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta",
"delta": buffer
}))
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)
Στρατηγική buffering
Η αποστολή κάθε token στο TTS ξεχωριστά δεν είναι ιδανική: η μηχανή σύνθεσης παράγει καλύτερα αποτελέσματα όταν διαθέτει συμφραζόμενα. Υπάρχουν τρεις στρατηγικές buffering.
Ανά πρόταση
Περιμένετε έναν οριοθέτη πρότασης (., !, ?, αλλαγή γραμμής) πριν την αποστολή:
if any(c in token for c in ".!?\n"):
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Αυτή είναι η καλύτερη ισορροπία μεταξύ ποιότητας και καθυστέρησης.
Ανά μέγεθος
Αποστολή όταν το buffer φτάσει σε ένα συγκεκριμένο μέγεθος (π.χ. 200 χαρακτήρες):
if len(buffer) >= 200:
await tts_ws.send(json.dumps({
"type": "text.delta", "delta": buffer
}))
buffer = ""
Είναι απλούστερο, αλλά μπορεί να κόψει μια λέξη στη μέση.
Ανά χρονικό όριο (Timeout)
Αποστολή μετά από μια καθυστέρηση χωρίς νέο token (χρήσιμο ενώ το LLM σκέφτεται):
last_token_time = time.time()
# Αν περάσουν περισσότερα από 500 ms χωρίς token, αποστολή του buffer
if time.time() - last_token_time > 0.5 and buffer:
await tts_ws.send(...)
buffer = ""
Αναπαραγωγή ήχου σε πραγματικό χρόνο
Για να αναπαράγετε τον ήχο καθώς φτάνει (και όχι απλώς να τον συλλέγετε), χρησιμοποιήστε μια async ουρά:
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
Βασικά σημεία
- Ένα streaming LLM που τροφοδοτεί το TTS WebSocket προσφέρει τη χαμηλότερη καθυστέρηση
- Χρησιμοποιήστε buffering ανά πρόταση για την καλύτερη ισορροπία μεταξύ ποιότητας και καθυστέρησης
- Χρησιμοποιήστε μια async ουρά για αναπαραγωγή ήχου σε πραγματικό χρόνο
- Διαχειριστείτε τα σφάλματα σε κάθε στάδιο της ροής
- Το συνολικό κείμενο μέσω WebSocket είναι απεριόριστο (deltas έως 60.000 χαρακτήρες)
- Το όριο των 50 ταυτόχρονων συνεδριών ισχύει για ολόκληρη την ομάδα σας