Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Streamování v reálném čase

Lekce 10 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Proč streamování mění vše
  2. Protokol událostí
  3. Přehrávání zvuku, jak přichází
  4. Předávání streamu do prohlížeče
  5. Nastavení, které dělá rozdíl: vyrovnávací paměť
  6. Klíčové poznatky

Kurz aktualizován 3. listopadu 2026 pro Voxtral TTS 3, na základě průvodce Migrace z Voxtral 2 a stránek Mistralu Text to Speech: voxtral-mini-tts-2603, zastaralý k 31. říjnu 2026 a vyřazený k 30. dubnu 2027, je v příkladech nahrazen modelem voxtral-mini-tts-3-0. Předdefinované hlasy Voxtral 2 (gb_jane_neutral…) zůstávají podporovány; Voxtral 3 přidává tagy [emotion=…] a [pace=…] přímo do textu, nastavení expressiveness, vlastní výslovnost (phoneme_hints) a podporu 35 jazyků. Mistral doporučuje po migraci znovu změřit latenci. Zdroje: Migrace z Voxtral 2 · Generování řeči.

Proč streamování mění vše

Doposud jsi pracoval v synchronním režimu: odeslal jsi text, počkal jsi, až se syntéza zcela dokončí, a teprve poté jsi obdržel celý zvukový soubor. U předpřipraveného pozdravu vytvořeného den předem toto čekání nevadí. U hlasového asistenta, který odpovídá zákazníkovi po telefonu, je to však nepřijatelné – dvě vteřiny ticha po otázce a uživatel si myslí, že hovor spadl.

Streamování toto čekání eliminuje. Zvuk je odesílán průběžně, fragment po fragmentu, takže uživatel slyší první slova, zatímco model stále generuje konec věty. Celkový čas generování se nemění; co se však drasticky snižuje, je prodleva před zazněním prvního zvuku.

Protokol událostí

Stream spoléhá na Server-Sent Events (SSE). Každá přijatá zpráva je typizovaná událost a zajímají tě dva typy:

  • speech.audio.delta: obsahuje zvukový fragment v kódování base64. Toto je hlavní událost, kterou budeš zpracovávat.
  • speech.audio.done: signál konce – generování je dokončeno.

Na straně kódu přechod na streamování znamená přidat stream=True a zpracovávat odpověď v bloku with. Následující příklad akumuluje fragmenty v paměti, aby na konci zapsal soubor: ještě nejde o skutečný reálný čas, ale je to struktura smyčky, na které bude zbytek lekce stavět.

import base64
from pathlib import Path
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

audio_chunks = []

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="Streaming makes voice agents responsive and natural.",
    voice_id="your-voice-id",
    response_format="opus",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            chunk = base64.b64decode(event.data.audio_data)
            audio_chunks.append(chunk)
            print(f"Chunk received: {len(chunk)} bytes")

# Sestavení všech chunků
audio_complet = b"".join(audio_chunks)
Path("streaming-output.opus").write_bytes(audio_complet)
print(f"Final audio: {len(audio_complet)} bytes")

Přehrávání zvuku, jak přichází

Abys dosáhl slibované odezvy, přestaň fragmenty akumulovat a každý z nich zapisuj přímo na zvukovou kartu. S knihovnou pyaudio stačí změnit jeden řádek: místo přidávání dekódovaného fragmentu do seznamu jej odešleš do výstupního streamu, který jsi předem otevřel a nakonfiguroval pro mono Float32 při 24 000 Hz.

import base64
import pyaudio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Konfigurace PCM audia (nejrychlejší formát)
p = pyaudio.PyAudio()
stream_audio = p.open(
    format=pyaudio.paFloat32,
    channels=1,
    rate=24000,
    output=True,
)

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="You're hearing this sentence while I generate it.",
    voice_id="your-voice-id",
    response_format="pcm",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            audio_data = base64.b64decode(event.data.audio_data)
            stream_audio.write(audio_data)

stream_audio.stop_stream()
stream_audio.close()
p.terminate()

Požadovaný formát se změnil z opus na pcm, na čemž záleží. PCM nevyžaduje žádné dekódování: přijaté bajty jsou připraveny k okamžitému přehrání, což z něj činí doporučený formát pro použití v reálném čase.

Předávání streamu do prohlížeče

Webová aplikace sama zvuk nepřehrává, ale pouze jej předává dál. Klasický vzor využívá WebSocket, který přijme text z prohlížeče, otevře stream Voxtral a každý dekódovaný fragment posílá zpět klientovi. Na straně prohlížeče se pak ujme Web Audio API a přehraje přijaté PCM fragmenty.

# Strana serveru (příklad FastAPI)
from fastapi import FastAPI, WebSocket
import base64
from mistralai.client import Mistral

app = FastAPI()
client = Mistral(api_key="your-api-key")

@app.websocket("/ws/tts")
async def tts_websocket(websocket: WebSocket):
    await websocket.accept()
    texte = await websocket.receive_text()

    with client.audio.speech.complete(
        model="voxtral-mini-tts-3-0",
        input=texte,
        voice_id="your-voice-id",
        response_format="pcm",
        stream=True,
    ) as stream:
        for event in stream:
            if event.event == "speech.audio.delta":
                await websocket.send_bytes(
                    base64.b64decode(event.data.audio_data)
                )

    await websocket.close()

Nastavení, které dělá rozdíl: vyrovnávací paměť

Velikosti fragmentů se liší a obvykle představují několik milisekund zvuku. Pokud přehraješ první fragment v okamžiku jeho příchodu, jakákoli nepravidelnost v síti způsobí slyšitelný mikrovýpadek – zakoktání hlasu, které okamžitě prozradí stroj. Řešením je načíst do vyrovnávací paměti dva nebo tři fragmenty před zahájením přehrávání. Stojí to několik desítek milisekund, ale vyhladí to zbytek streamu.

Dále je tu volba formátu, která představuje kompromis mezi latencí a šířkou pásma. PCM doručí první zvuk nejrychleji – při měřeních s Voxtral 2 to bylo kolem 0,7 sekundy (tato hodnota je třeba znovu ověřit s Voxtral TTS 3) – za cenu vysokého datového toku. Opus mírně ztrácí na latenci, ale silně komprimuje data, což z něj činí správnou volbu, pokud jsou tvoji uživatelé na mobilních sítích.

Klíčové poznatky

  • Streamování odesílá zvuk po částech během generování.
  • Aktivuješ jej pomocí stream=True ve volání audio.speech.complete().
  • Události speech.audio.delta obsahují zvukové fragmenty v base64.
  • Formát PCM nabízí nejnižší latenci pro streamování (~0,7 s oproti ~2 s u MP3).
  • Pro přehrávání v reálném čase použij pyaudio nebo kombinaci WebSocketů a Web Audio API.