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

Kompletní hlasový pipeline

Lekce 14 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Od hlasu k hlasu: Pipeline STT → LLM → TTS
  2. Funkční pipeline
  3. Nečekej, až uvažování skončí
  4. Konverzační smyčka
  5. Co dělí tento prototyp od produkčního nasazení
  6. Další kroky
  7. Klíčové poznatky
  8. Ověř si své znalosti

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: model 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á značky [emotion=…] a [pace=…] v textu, nastavení expressiveness, vlastní výslovnost (phoneme_hints) a 35 jazyků. Mistral doporučuje po migraci znovu změřit latenci. Zdroje: Migrace z Voxtral 2 · Generování řeči.

Lekce opravena 2. listopadu 2026 na základě audio dokumentace Mistralu: metoda pro přepis je client.audio.transcriptions.complete (nikoliv create), přičemž soubor se předává jako {"file_name": ..., "content": ...} a aktuálním modelem je voxtral-mini-transcribe-3. Zdroj: Přepis souboru.

Od hlasu k hlasu: Pipeline STT → LLM → TTS

Umíš vytvářet hlasy, generovat řeč a spravovat latenci. Tato závěrečná lekce spojuje tyto stavební kameny do kompletního systému: uživatel mluví, stroj poslouchá, chápe, uvažuje a odpovídá přirozeným hlasem.

Architektura se skládá ze tří článků. Nejprve rozpoznávání řeči převede zvuk na text; Mistral nabízí vlastní model, ale stejně dobře funguje Whisper od OpenAI nebo jiné řešení. Tento text putuje do velkého jazykového modelu (LLM), který interpretuje požadavek a vytvoří odpověď – ať už jde o Mistral Large 3, Claude, GPT-5.6 nebo Llama; pipeline neklade žádné předpoklady ohledně poskytovatele. Nakonec se odpověď vrací do Voxtral TTS, který ji převede na řeč odesílanou prostřednictvím streamingu.

Funkční pipeline

Níže uvedený kód spojuje tyto tři kroky dohromady. Každý je izolován ve vlastní funkci, což ti umožňuje vyměnit model STT nebo LLM, aniž bys musel sahat na zbytek kódu. Všimni si, že historie konverzace je předávána funkci generer_reponse() a obohacována jí: právě to dodává soudržnost postupným výměnám.

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

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

# Konfigurace
VOICE_ID = "your-voice-id"
LLM_MODEL = "mistral-large-latest"
TTS_MODEL = "voxtral-mini-tts-3-0"

def transcribe_audio(audio_path: str) -> str:
    """Krok 1: Převod zvuku na text (STT)."""
    path = Path(audio_path)
    with path.open("rb") as audio:
        response = client.audio.transcriptions.complete(
            model="voxtral-mini-transcribe-3",
            file={"file_name": path.name, "content": audio},
        )
    return response.text

def generate_response(question: str, history: list) -> str:
    """Krok 2: Generování odpovědi pomocí LLM."""
    history.append({"role": "user", "content": question})

    response = client.chat.complete(
        model=LLM_MODEL,
        messages=history,
    )

    answer = response.choices[0].message.content
    history.append({"role": "assistant", "content": answer})
    return answer

def synthesize_speech(output_file: str, fichier_sortie: str):
    """Krok 3: Převod textu na řeč (TTS)."""
    audio_chunks = []

    with client.audio.speech.complete(
        model=TTS_MODEL,
        input=output_file,
        voice_id=VOICE_ID,
        response_format="pcm",
        stream=True,
    ) as stream:
        for event in stream:
            if event.event == "speech.audio.delta":
                audio_chunks.append(
                    base64.b64decode(event.data.audio_data)
                )

    Path(fichier_sortie).write_bytes(b"".join(audio_chunks))

def pipeline_vocal(audio_path: str):
    """Kompletní pipeline: STT → LLM → TTS."""
    history = [
        {
            "role": "system",
            "content": (
                "Jsi profesionální hlasový asistent. "
                "Odpovídej stručně a přirozeně, "
                "jako v ústní konverzaci."
            ),
        }
    ]

    # Krok 1: Přepis
    print("Probíhá přepis...")
    question = transcribe_audio(audio_path)
    print(f"Otázka: {question}")

    # Krok 2: Uvažování
    print("Generování odpovědi...")
    answer = generate_response(question, history)
    print(f"Odpověď: {answer}")

    # Krok 3: Syntéza
    print("Syntéza řeči...")
    synthesize_speech(answer, "answer.pcm")
    print("Pipeline dokončena — vygenerován soubor answer.pcm")

# Spuštění pipeline
pipeline_vocal("question_utilisateur.wav")

Systémový prompt si zaslouží zmínku: explicitní požadavek na stručné, mluvené odpovědi není jen zdvořilost. Neomezený LLM ochotně produkuje strukturované odstavce s nadpisy, což je při čtení nahlas katastrofální – a jejich syntéza trvá ještě déle.

Nečekej, až uvažování skončí

Předchozí pipeline je sekvenční: syntéza nezačne, dokud LLM zcela nedopíše odpověď. U třicetislovné odpovědi to přidává několik sekund ticha, kterému uživatel nerozumí. Řešením je překrytí kroků 2 a 3: LLM generuje streamovaně a jakmile je k dispozici celá věta – tedy jakmile token končí tečkou, vykřičníkem nebo otazníkem – putuje do syntézy, zatímco model pokračuje v psaní zbytku.

def streaming_pipeline(question_text: str):
    """Optimalizovaná pipeline: TTS začíná, jakmile dorazí první
    tokeny z LLM."""

    # LLM generuje streamovaně
    partial_response = ""
    phrases_to_synthesize = []

    llm_stream = client.chat.stream(
        model=LLM_MODEL,
        messages=[
            {"role": "system", "content": "Odpovídej stručně."},
            {"role": "user", "content": question_text},
        ],
    )

    for chunk in llm_stream:
        token = chunk.data.choices[0].delta.content or ""
        partial_response += token

        # Jakmile je k dispozici celá věta
        if token.endswith((".", "!", "?")):
            phrases_to_synthesize.append(partial_response)
            partial_response = ""

    # Syntéza každé věty streamovaně
    for phrase in phrases_to_synthesize:
        with client.audio.speech.complete(
            model=TTS_MODEL,
            input=phrase,
            voice_id=VOICE_ID,
            response_format="pcm",
            stream=True,
        ) as stream:
            for event in stream:
                if event.event == "speech.audio.delta":
                    yield base64.b64decode(event.data.audio_data)

Konverzační smyčka

Skutečný asistent nezpracovává izolované otázky: řetězí jednotlivá kola řeči při zachování kontextu. Níže uvedená smyčka nahrává, přepisuje, kontroluje, zda uživatel nechce skončit, a poté odpovídá – přičemž v každém kole znovu vkládá stejnou proměnnou historique, která se během výměny rozrůstá.

def voice_assistant():
    """Kompletní konverzační smyčka."""
    history = [
        {
            "role": "system",
            "content": "Jsi stručný hlasový asistent.",
        }
    ]

    print("Hlasový asistent připraven. Mluv!")

    while True:
        # Nahrání otázky (přes mikrofon)
        audio_question = record_microphone(duration=10)

        # Pipeline STT → LLM → TTS
        question = transcribe_audio(audio_question)
        if question.lower() in ("stop", "arrête", "au revoir"):
            synthesize_speech("Goodbye!", "sortie.pcm")
            break

        answer = generate_response(question, history)
        synthesize_speech(answer, "sortie.pcm")
        play_audio("sortie.pcm")

Co dělí tento prototyp od produkčního nasazení

Parametr duree=10 v nahrávání ilustruje cestu, která nás čeká: pevné zpoždění nutí upovídaného uživatele, aby se přerušil, a někdo, kdo odpoví „ano“, musí čekat deset sekund. Detektor hlasové aktivity (VAD) to řeší skutečným rozpoznáním konce řeči. Poté je třeba řešit přerušení, protože uživatel readily přeruší asistenta, který mluví příliš dlouho: tvůj kód musí být schopen zastavit probíhající syntézu, což streaming umožňuje, ale tento prototyp to nedělá.

Další tři body jsou podmínkou nasazení. Historie konverzace, která je zde již přítomna, musí být ohraničena a perzistentně uložena, pokud relace trvají dlouho. Záložní řešení je nezbytné – pokud selže STT nebo TTS, zobraz text, místo abys nechal uživatele v nevysvětlitelném tichu. Nakonec instrumentuj každý krok v produkci: je to jediný způsob, jak zjistit, zda ta extra vteřina pochází z přepisu, LLM nebo syntézy.

Další kroky

Nyní máš vše potřebné k využití Voxtral TTS ve svých projektech. Otevírá se několik směrů v závislosti na tvých omezeních: hostuj Voxtral lokálně, pokud je prioritou latence nebo kontrola dat, integruj jej do existujícího frameworku jako LangChain, LlamaIndex nebo Haystack, nebo vytvoř kompletní webovou aplikaci s WebRTC pro obousměrný zvuk. Můžeš také prozkoumat multimodální modely Mistralu, které kombinují text, obrázek a zvuk, a připojit se ke komunitě Mistral na Discordu, abys porovnal své výtvory s ostatními.

Klíčové poznatky

  • Kompletní hlasový asistent řetězí tři kroky: STT → LLM → TTS
  • Paralelizace kroků (generování TTS, zatímco LLM pokračuje) drasticky snižuje latenci
  • Formát PCM ve streamingu poskytuje odezvu potřebnou pro přirozenou konverzaci
  • V produkci řeš detekci konce řeči, přerušení a textové záložní řešení
  • Voxtral TTS se integruje do jakéhokoli hlasového pipeline díky Python SDK od Mistralu

Ověř si své znalosti

Syntéza, hlas, latence: závěrečná kontrola před kompletním pipeline.

1. Co umožňuje Voices API?

Odpověď: Spravovat dostupné hlasy a vytvářet vlastní – hlas se stává nakonfigurovaným aktivem, znovu použitelným ve všech tvých generováních.

2. Jaká etická pravidla upravují klonování hlasu?

Odpověď: Explicitní souhlas klonované osoby a transparentní, legitimní použití – klonování hlasu bez autorizace nepřipadá v úvahu; technická možnost neznamená povolení.

3. Jak ovládáš výslovnost textu?

Odpověď: Přípravou textu: foneticky hláskuj nejednoznačné termíny, zpracovávej zkratky a čísla, interpunkcí určuj rytmus – TTS čte to, co napíšeš.

4. Jaké páky snižují latenci?

Odpověď: Streaming v reálném čase (zvuk produkovaný, jak přichází text), přizpůsobené audio formáty a segmentovaný text – hlas začíná dříve, než generování skončí.

5. Jak vypadá kompletní hlasový pipeline?

Odpověď: Přepis uživatele (Voxtral) → zpracování modelem → syntéza odpovědi (TTS), end-to-end streaming: smyčka hlasového asistenta.

Smyčka je uzavřena: od příchozího hlasu k odchozímu hlasu – závěrečné pipeline kurzu spojuje vše, co jsi právě ověřil.