Vollständige Sprachpipeline
Auf dieser Seite
Kurs aktualisiert am 3. November 2026 für Voxtral TTS 3, basierend auf dem Leitfaden Migrate from Voxtral 2 und den Seiten von Mistral zu Text to Speech:
voxtral-mini-tts-2603, am 31. Oktober 2026 abgelehnt und am 30. April 2027 eingestellt, wird in den Beispielen durchvoxtral-mini-tts-3-0ersetzt. Die vordefinierten Stimmen von Voxtral 2 (gb_jane_neutral…) bleiben unterstützt; Voxtral 3 fügt die Tags[emotion=…]und[pace=…]im Text, die Einstellungexpressiveness, die Anpassung der Aussprache (phoneme_hints) und 35 Sprachen hinzu. Mistral empfiehlt, die Latenz nach der Migration erneut zu messen. Quellen: Migrate from Voxtral 2 · Speech generation.
Lektion korrigiert am 2. November 2026 basierend auf der Audio-Dokumentation von Mistral: Die Transkriptionsmethode ist
client.audio.transcriptions.complete(nichtcreate), wobei die Datei als{"file_name": ..., "content": ...}übergeben wird, und das aktuelle Modell istvoxtral-mini-transcribe-3. Quelle: Transcribe a file.
Vom Sprechen zum Sprechen: Die STT → LLM → TTS-Pipeline
Sie wissen bereits, wie man Stimmen erstellt, Sprache generiert und Latenz verwaltet. Diese letzte Lektion setzt diese Bausteine zu einem vollständigen System zusammen: Der Nutzer spricht, die Maschine hört zu, versteht, denkt nach und antwortet in einer natürlichen Stimme.
Die Architektur besteht aus drei Verbindungen. Erst wandelt die Spracherkennung Sprache in Text um; Mistral bietet sein eigenes Modell an, doch OpenAI Whisper oder eine andere Lösung funktionieren ebenso gut. Dieser Text gelangt dann an ein großes Sprachmodell, das die Anfrage interpretiert und eine Antwort entwirft – Mistral Large 3, Claude, GPT-5.6 oder Llama; die Pipeline macht keine Annahmen bezüglich des Anbieters. Schließlich kehrt die Antwort zu Voxtral TTS zurück, das sie als über Streaming gesendete Sprache rendert.
Eine funktionierende Pipeline
Der folgende Code verknüpft die drei Schritte. Jeder ist in einer eigenen Funktion isoliert, sodass Sie das STT- oder LLM-Modell austauschen können, ohne den Rest zu berühren. Beachten Sie, dass die Gesprächshistorie an generer_reponse() übergeben und durch diese bereichert wird: Dies ist der Faktor, der der aufeinanderfolgenden Kommunikation Kohärenz verleiht.
import base64
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# Konfiguration
VOICE_ID = "your-voice-id"
LLM_MODEL = "mistral-large-latest"
TTS_MODEL = "voxtral-mini-tts-3-0"
def transcribe_audio(audio_path: str) -> str:
"""Schritt 1: Audio in Text umwandeln (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:
"""Schritt 2: Antwort mit dem LLM generieren."""
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):
"""Schritt 3: Text in Sprache umwandeln (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):
"""Vollständige Pipeline: STT → LLM → TTS."""
history = [
{
"role": "system",
"content": (
"Sie sind ein professioneller Sprachassistent. "
"Antworten Sie knapp und natürlich, "
"wie in einem mündlichen Gespräch."
),
}
]
# Schritt 1: Transkribieren
print("Transkribiere...")
question = transcribe_audio(audio_path)
print(f"Frage: {question}")
# Schritt 2: Nachdenken
print("Erstelle Antwort...")
answer = generate_response(question, history)
print(f"Antwort: {answer}")
# Schritt 3: Synthesieren
print("Synthesisiere Sprache...")
synthesize_speech(answer, "answer.pcm")
print("Pipeline abgeschlossen — Datei answer.pcm generiert")
# Pipeline ausführen
pipeline_vocal("question_utilisateur.wav")
Der Systemprompt verdient ein Wort: Die explizite Bitte um knappe, gesprochene Antworten ist nicht nur eine Höflichkeit. Ein ungebundenes LLM neigt gerne zu strukturierten Absätzen mit Überschriften, die beim Vorlesen katastrophal sind und die Synthesezeit zusätzlich verlängern.
Warten Sie nicht, bis das Nachdenken abgeschlossen ist
Die vorherige Pipeline ist sequentiell: Die Synthese beginnt erst, wenn das LLM die Antwort vollständig geschrieben hat. Bei einer 30-Wörter-Antwort fügt dies mehrere Sekunden Stille hinzu, die der Nutzer nicht erklären kann. Die Lösung besteht darin, die Schritte 2 und 3 zu überlappen: Das LLM generiert über Streaming, und sobald ein vollständiger Satz verfügbar ist – das heißt, sobald ein Token mit einem Punkt, Ausrufezeichen oder Fragezeichen endet – wird er zur Synthese weitergeleitet, während das Modell den Rest entwirft.
def streaming_pipeline(question_text: str):
"""Optimierte Pipeline: TTS beginnt, sobald die ersten
LLM-Token eintreffen."""
# LLM generiert über Streaming
partial_response = ""
phrases_to_synthesize = []
llm_stream = client.chat.stream(
model=LLM_MODEL,
messages=[
{"role": "system", "content": "Antworten Sie kurz."},
{"role": "user", "content": question_text},
],
)
for chunk in llm_stream:
token = chunk.data.choices[0].delta.content or ""
partial_response += token
# Sobald ein vollständiger Satz verfügbar ist
if token.endswith((".", "!", "?")):
phrases_to_synthesize.append(partial_response)
partial_response = ""
# Synthesiere jeden Satz über 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)
Der Gesprächsloop
Ein wahrer Assistent behandelt keine isolierte Frage: Er verknüpft Sprechrunden und hält den Faden aufrecht. Der folgende Loop zeichnet auf, transkribiert, prüft, ob der Nutzer aufhören möchte, und antwortet – dabei wird derselbe historique bei jeder Runde neu eingespeist, der sich während des Gesprächs erweitert.
def voice_assistant():
"""Vollständiger Gesprächsloop."""
history = [
{
"role": "system",
"content": "Sie sind ein knapper Sprachassistent.",
}
]
print("Sprachassistent bereit. Sprechen Sie!")
while True:
# Frage aufzeichnen (über Mikrofon)
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")
Was unterscheidet diesen Prototypen von der Produktion
Das duree=10 bei der Aufzeichnung illustriert den Weg nach vorne: Eine feste Verzögerung zwingt einen redseligen Nutzer, sich selbst abzuschneiden, und lässt jemanden, der „ja” antwortet, zehn Sekunden warten. Ein Sprachaktivitätserkennungssystem (VAD) löst dies, indem es das Ende der Sprache tatsächlich erkennt. Anschließend müssen Unterbrechungen behandelt werden, da ein Nutzer bereit ist, einen Assistenten abzuschneiden, der zu lange spricht: Ihr Code muss die Synthese unterbrechen können, was Streaming ermöglicht, den dieser Prototyp jedoch nicht tut.
Drei weitere Punkte bedingen den Einsatz. Die Gesprächshistorie, die hier bereits vorhanden ist, muss begrenzt und bei längeren Sitzungen persistiert werden. Ein Fallback ist unerlässlich – falls STT oder TTS fehlschlägt, sollte der Text angezeigt werden, statt eine unerklärliche Stille zu lassen. Schließlich muss jeder Schritt in der Produktion instrumentiert werden: Nur so lässt sich erkennen, ob diese zusätzliche Sekunde von der Transkription, dem LLM oder der Synthese stammt.
Nächste Schritte
Sie verfügen nun über alles, was Sie benötigen, um Voxtral TTS in Ihren Projekten zu nutzen. Je nach Ihren Randbedingungen eröffnen sich verschiedene Richtungen: Hosten Sie Voxtral lokal, wenn Latenz oder Datenkontrolle im Vordergrund stehen; integrieren Sie es in einen bestehenden Rahmen wie LangChain, LlamaIndex oder Haystack; oder erstellen Sie eine vollständige Webanwendung mit WebRTC für bidirektionales Audio. Sie können auch die multimodalen Modelle von Mistral erkunden, die Text, Bild und Audio kombinieren, und treten Sie der Mistral-Community auf Discord bei, um Ihre Builds mit anderen zu vergleichen.
Kernaussagen
- Ein vollständiger Sprachassistent verknüpft drei Schritte: STT → LLM → TTS
- Das Parallelisieren der Schritte (TTS-Generierung, während das LLM weiterarbeitet) reduziert die Latenz drastisch
- Das PCM-Format im Streaming liefert die Reaktionsfähigkeit, die für ein natürliches Gespräch benötigt wird
- In der Produktion müssen das Ende der Spracherkennung, Unterbrechungen und Text-Fallbacks behandelt werden
- Voxtral TTS integriert sich dank des Mistral Python SDK in jede Sprachpipeline
Wissen prüfen
Synthese, Stimme, Latenz: letzter Check vor der vollständigen Pipeline.
1. Was ermöglicht die Voices-API?
Antwort: Verwalten verfügbarer Stimmen und Erstellen benutzerdefinierter Stimmen – die Stimme wird zu einem konfigurierten Asset, das über alle Generierungen hinweg wiederverwendet werden kann.
2. Welche ethischen Regeln regeln das Stimmenklonen?
Antwort: Explizite Zustimmung der geklonten Person und transparente, legitime Nutzung – das Klonen einer Stimme ohne Genehmigung ist tabu; technisch möglich bedeutet nicht erlaubt.
3. Wie steuern Sie die Aussprache von Text?
Antwort: Durch Vorbereitung des Textes: phonetische Schreibweise mehrdeutiger Begriffe, Umgang mit Abkürzungen und Zahlen, Zeichensetzung für den Rhythmus – das TTS liest, was Sie schreiben.
4. Welche Hebel reduzieren die Latenz?
Antwort: Echtzeit-Streaming (Audio wird produziert, während Text eintreffen), angepasste Audioformate und segmentierter Text – die Stimme beginnt, bevor die Generierung endet.
5. Wie sieht eine vollständige Sprachpipeline aus?
Antwort: Nutzer-Transkription (Voxtral) → Modellverarbeitung → Antwort-Synthese (TTS), Streaming von Endpunkt zu Endpunkt: der Loop eines Sprachassistenten.
Der Loop ist geschlossen: von eingehender zu ausgehender Stimme – die letzte Pipeline des Kurses setzt alles zusammen, was Sie gerade validiert haben.