Przejdź do głównej treści
Polski— Wybierz język
Menu

Kompletny potok głosowy

Lekcja 14 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Od głosu do głosu: Potok STT → LLM → TTS
  2. Funkcjonalny potok
  3. Nie czekaj, aż rozumowanie się zakończy
  4. Pętla konwersacyjna
  5. Co dzieli ten prototyp od środowiska produkcyjnego
  6. Kolejne kroki
  7. Kluczowe wnioski
  8. Sprawdź swoją wiedzę

Kurs zaktualizowany 3 listopada 2026 r. dla Voxtral TTS 3, na podstawie przewodnika Migrate from Voxtral 2 oraz dokumentacji Mistral Text to Speech: model voxtral-mini-tts-2603, wycofany 31 października 2026 r. i całkowicie usunięty 30 kwietnia 2027 r., został zastąpiony w przykładach przez voxtral-mini-tts-3-0. Predefiniowane głosy Voxtral 2 (gb_jane_neutral…) są nadal obsługiwane; Voxtral 3 dodaje tagi [emotion=…] i [pace=…] w tekście, ustawienie expressiveness, niestandardową wymowę (phoneme_hints) oraz obsługę 35 języków. Mistral zaleca ponowne zmierzenie opóźnień po migracji. Źródła: Migrate from Voxtral 2 · Speech generation.

Lekcja poprawiona 2 listopada 2026 r. na podstawie dokumentacji audio Mistral: metoda transkrypcji to client.audio.transcriptions.complete (a nie create), plik przekazywany jest jako {"file_name": ..., "content": ...}, a aktualny model to voxtral-mini-transcribe-3. Źródło: Transcribe a file.

Od głosu do głosu: Potok STT → LLM → TTS

Wiesz już, jak tworzyć głosy, generować mowę i zarządzać opóźnieniami. Ta ostatnia lekcja scala te elementy w kompletny system: użytkownik mówi, maszyna słucha, rozumie, przetwarza i odpowiada naturalnym głosem.

Architektura składa się z trzech ogniw. Po pierwsze, rozpoznawanie mowy zamienia dźwięk na tekst; Mistral oferuje własny model, ale równie dobrze sprawdzi się Whisper od OpenAI lub inne rozwiązanie. Ten tekst trafia następnie do dużego modelu językowego (LLM), który interpretuje zapytanie i przygotowuje odpowiedź – może to być Mistral Large 3, Claude, GPT-5.6 lub Llama; potok nie zakłada żadnego konkretnego dostawcy. Na koniec odpowiedź wraca do Voxtral TTS, który renderuje ją jako mowę przesyłaną strumieniowo.

Funkcjonalny potok

Poniższy kod łączy trzy kroki w całość. Każdy z nich jest wydzielony do osobnej funkcji, co pozwala wymieniać model STT lub LLM bez dotykania reszty kodu. Zwróć uwagę, że historia konwersacji jest przekazywana do funkcji generer_reponse() i przez nią wzbogacana: to właśnie nadaje spójność kolejnym wymianom zdań.

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

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

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

def transcribe_audio(audio_path: str) -> str:
    """Step 1: Convert audio to 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:
    """Step 2: Generate a response with the 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):
    """Step 3: Convert text to speech (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):
    """Complete pipeline: STT → LLM → TTS."""
    history = [
        {
            "role": "system",
            "content": (
                "You are a professional voice assistant. "
                "Respond concisely and naturally, "
                "as in an oral conversation."
            ),
        }
    ]

    # Step 1: Transcribe
    print("Transcribing...")
    question = transcribe_audio(audio_path)
    print(f"Question: {question}")

    # Step 2: Reason
    print("Generating response...")
    answer = generate_response(question, history)
    print(f"Response: {answer}")

    # Step 3: Synthesize
    print("Synthesizing speech...")
    synthesize_speech(answer, "answer.pcm")
    print("Pipeline complete — file answer.pcm generated")

# Run the pipeline
pipeline_vocal("question_utilisateur.wav")

Prompt systemowy zasługuje na uwagę: wyraźne żądanie zwięzłych, mówionych odpowiedzi to nie tylko grzeczność. Nieograniczony LLM chętnie produkuje ustrukturyzowane akapity z nagłówkami, co brzmi fatalnie przy czytaniu na głos – a do tego zajmuje jeszcze więcej czasu przy syntezie.

Nie czekaj, aż rozumowanie się zakończy

Poprzedni potok działa sekwencyjnie: synteza nie rusza, dopóki LLM nie dopisze całej odpowiedzi. Przy trzydziestosłowowej odpowiedzi dodaje to kilka sekund ciszy, której użytkownik nie potrafi sobie wytłumaczyć. Rozwiązaniem jest nakładanie się kroków 2 i 3: LLM generuje treść strumieniowo, a gdy tylko dostępne będzie pełne zdanie – czyli gdy token kończy się kropką, wykrzyknikiem lub znakiem zapytania – trafia ono do syntezy, podczas gdy model wciąż pracuje nad resztą.

def streaming_pipeline(question_text: str):
    """Optimized pipeline: TTS starts as soon as the first
    LLM tokens arrive."""

    # LLM generates in streaming
    partial_response = ""
    phrases_to_synthesize = []

    llm_stream = client.chat.stream(
        model=LLM_MODEL,
        messages=[
            {"role": "system", "content": "Respond briefly."},
            {"role": "user", "content": question_text},
        ],
    )

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

        # As soon as a complete sentence is available
        if token.endswith((".", "!", "?")):
            phrases_to_synthesize.append(partial_response)
            partial_response = ""

    # Synthesize each sentence in streaming
    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)

Pętla konwersacyjna

Prawdziwy asystent nie obsługuje pojedynczego pytania: łączy tury rozmowy, zachowując wątek. Poniższa pętla nagrywa, transkrybuje, sprawdza, czy użytkownik chce zakończyć, a następnie odpowiada – za każdym razem wstrzykując tę samą zmienną historique, która rośnie w trakcie wymiany.

def voice_assistant():
    """Complete conversational loop."""
    history = [
        {
            "role": "system",
            "content": "You are a concise voice assistant.",
        }
    ]

    print("Voice assistant ready. Speak!")

    while True:
        # Record the question (via microphone)
        audio_question = record_microphone(duration=10)

        # STT → LLM → TTS pipeline
        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 dzieli ten prototyp od środowiska produkcyjnego

Parametr duree=10 w nagrywaniu ilustruje drogę, która przed Tobą: sztywne opóźnienie zmusza gadatliwego użytkownika do przerywania w pół słowa, a osobę odpowiadającą „tak“ każe czekać dziesięć sekund. Detektor aktywności głosowej (VAD) rozwiązuje ten problem, faktycznie wykrywając koniec wypowiedzi. Następnie trzeba obsłużyć przerwanie, ponieważ użytkownik chętnie przerywa asystenta, który mówi zbyt długo: Twój kod musi być w stanie zatrzymać trwającą syntezę, co umożliwia strumieniowanie, choć ten prototyp tego nie robi.

Trzy inne kwestie warunkują wdrożenie. Historia rozmowy, już tutaj obecna, musi mieć ograniczoną długość i być utrwalana, jeśli sesje są długie. Mechanizm awaryjny (fallback) jest niezbędny – jeśli STT lub TTS zawiedzie, wyświetl tekst, zamiast pozostawiać niewytłumaczalną ciszę. Na koniec zinstrumentuj każdy krok w środowisku produkcyjnym: to jedyny sposób, by wiedzieć, czy ta dodatkowa sekunda pochodzi z transkrypcji, LLM, czy syntezy.

Kolejne kroki

Masz już wszystko, czego potrzebujesz, by wykorzystać Voxtral TTS w swoich projektach. Otwierają się przed Tobą różne ścieżki w zależności od ograniczeń: hostuj Voxtral lokalnie, jeśli priorytetem jest niskie opóźnienie lub kontrola danych, zintegruj go z istniejącym frameworkiem takim jak LangChain, LlamaIndex lub Haystack, albo zbuduj kompletną aplikację webową z wykorzystaniem WebRTC do dwukierunkowego audio. Możesz też zgłębić modele multimodalne Mistral, łączące tekst, obraz i dźwięk, oraz dołączyć do społeczności Mistral na Discordzie, by porównać swoje realizacje z innymi.

Kluczowe wnioski

  • Kompletny asystent głosowy łączy trzy kroki: STT → LLM → TTS
  • Równoleglenie kroków (generowanie TTS, gdy LLM wciąż pracuje) drastycznie redukuje opóźnienia
  • Format PCM w trybie strumieniowym zapewnia responsywność niezbędną do naturalnej rozmowy
  • W środowisku produkcyjnym obsłuż wykrywanie końca wypowiedzi, przerywanie i fallback na tekst
  • Voxtral TTS integruje się z dowolnym potokiem głosowym dzięki Python SDK od Mistral

Sprawdź swoją wiedzę

Synteza, głos, opóźnienia: ostatni sprawdzian przed kompletnym potokiem.

1. Co umożliwia Voices API?

Odpowiedź: Zarządzanie dostępnymi głosami i tworzenie własnych – głos staje się skonfigurowanym zasobem, wielokrotnego użytku we wszystkich generacjach.

2. Jakie zasady etyczne regulują klonowanie głosu?

Odpowiedź: Wyraźna zgoda osoby, której głos jest klonowany, oraz przejrzyste, legalne użycie – klonowanie głosu bez autoryzacji odpada; to, że coś jest technicznie możliwe, nie oznacza, że jest dozwolone.

3. Jak kontrolujesz wymowę tekstu?

Odpowiedź: Przygotowując tekst: fonetycznie zapisuj niejednoznaczne terminy, obsługuj akronimy i liczby, stosuj interpunkcję dla rytmu – TTS czyta to, co napiszesz.

4. Jakie dźwignie redukują opóźnienia?

Odpowiedź: Strumieniowanie w czasie rzeczywistym (audio powstaje w miarę napływania tekstu), dopasowane formaty audio i segmentacja tekstu – głos startuje przed zakończeniem generowania.

5. Jak wygląda kompletny potok głosowy?

Odpowiedź: Transkrypcja użytkownika (Voxtral) → przetwarzanie przez model → synteza odpowiedzi (TTS), strumieniowanie end-to-end: pętla asystenta głosowego.

Pętla się zamyka: od głosu przychodzącego do głosu wychodzącego – finałowy potok tego kursu scala wszystko, co właśnie zweryfikowałeś.