Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Vollständige Sprachpipeline

Lektion 14 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Vom Sprechen zum Sprechen: Die STT → LLM → TTS-Pipeline
  2. Eine funktionierende Pipeline
  3. Warten Sie nicht, bis das Nachdenken abgeschlossen ist
  4. Der Gesprächsloop
  5. Was unterscheidet diesen Prototypen von der Produktion
  6. Nächste Schritte
  7. Kernaussagen
  8. Wissen prüfen

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 durch voxtral-mini-tts-3-0 ersetzt. Die vordefinierten Stimmen von Voxtral 2 (gb_jane_neutral …) bleiben unterstützt; Voxtral 3 fügt die Tags [emotion=…] und [pace=…] im Text, die Einstellung expressiveness, 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 (nicht create), wobei die Datei als {"file_name": ..., "content": ...} übergeben wird, und das aktuelle Modell ist voxtral-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.