Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Ροή μετάδοσης από LLM σε TTS

Μάθημα 12 / 14 Ενημερώθηκε 3 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Σύνδεση ενός LLM με σύνθεση ομιλίας σε πραγματικό χρόνο
  2. Αρχιτεκτονική ροής δεδομένων
  3. Υλοποίηση σε Python
  4. Στρατηγική buffering
  5. Αναπαραγωγή ήχου σε πραγματικό χρόνο
  6. Διαχείριση σφαλμάτων στη ροή
  7. Βασικά σημεία

Ενημερώθηκε στις 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 ταυτόχρονων συνεδριών ισχύει για ολόκληρη την ομάδα σας