Kompletny potok głosowy
Na tej stronie
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 przezvoxtral-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, ustawienieexpressiveness, 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 niecreate), plik przekazywany jest jako{"file_name": ..., "content": ...}, a aktualny model tovoxtral-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ś.