Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Anwendungsfälle für Echtzeit-Transkription

Lektion 13 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Vier konkrete Streaming-Anwendungen
  2. Live-Untertitelung
  3. Interaktiver Sprachassistent
  4. Sprachdiktatur mit automatischer Speicherung
  5. Konferenztranskription mit Metadaten
  6. Kernaussagen

Kurs aktualisiert am 3. November 2026 für Voxtral 3, basierend auf Mistral’s Migrate from Voxtral 2-Guide: Voxtral 2-Modelle (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), am 31. Oktober 2026 abgelehnt und am 30. April 2027 zurückgezogen, werden in den Beispielen durch voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 und voxtral-mini-tts-3-0 ersetzt. Wesentliche Änderungen: Zeitstempel beziehen sich nur auf Segmente (word gibt einen Fehler 400 zurück), Echtzeit-Diarisierung wird unterstützt, Echtzeit-Sitzungseinstellungen werden nach dem ersten Audio-Chunk gesperrt, und context_bias-Eingaben sind frei formatiert (Phrasen mit Leerzeichen). Quellen: Migrate from Voxtral 2 · Speech to Text.

Vier konkrete Streaming-Anwendungen

Sie verfügen nun über alle Bausteine: den Stream, das Mikrofon und die Latenzanpassung. Diese Lektion montiert sie zu vier vollständigen Anwendungen – Live-Untertitelung, Sprachassistent, Diktierfunktion und Konferenztranskription –, die Sie als Ausgangspunkt so verwenden können, wie sie sind. Jede illustriert ein Problem, das im Offline-Modus nicht lösbar ist, und jede nutzt eine andere Latenzeinstellung, sodass Sie einen konkreten Eindruck von der zuvor diskutierten Abstimmung erhalten.

Live-Untertitelung

Untertitelung ist der sichtbarste Echtzeit-Anwendungsfall und stellt auch die höchsten Anforderungen an die Darstellung. Eine reine Transkription reicht nicht aus: Sie müssen den Text in kurze Zeilen aufteilen, jeweils nur zwei anzeigen und das Ganze scrollen lassen, ohne dabei jemals ein Wort zu halbieren. Genau das tut die folgende Klasse. Wenn die aktuelle Zeile die maximale Länge erreicht, sucht sie den letzten Leerzeichen vor diesem Limit und bricht dort; wenn kein Leerzeichen gefunden wird – ein sehr langes Wort, eine diktierte URL – wird an der maximalen Länge abgeschnitten, anstatt dass die Zeile überläuft. Die 800-Millisekunden-Einstellung spiegelt die Priorität dieses Anwendungsfalls wider: lesbare Texte sind besser als sofortige, aber zerhackte Texte, und das Publikum wird diese geringe Verzögerung nicht bemerken.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

class LiveCaptioning:
    """Live-Untertitelungssystem mit Zeilenverwaltung."""

    def __init__(self, max_chars_per_line=50, max_lines=2):
        self.max_chars = max_chars_per_line
        self.max_lines = max_lines
        self.current_line = ""
        self.lines = []

    async def run(self, audio_source):
        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=audio_source,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=800,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self._add_text(event.text)
            elif isinstance(event, TranscriptionStreamDone):
                self._afficher_final()

    def _add_text(self, texte):
        self.current_line += texte

        if len(self.current_line) >= self.max_chars:
            pos = self.current_line.rfind(" ", 0, self.max_chars)
            if pos > 0:
                self.lines.append(self.current_line[:pos])
                self.current_line = self.current_line[pos + 1:]
            else:
                self.lines.append(self.current_line[:self.max_chars])
                self.current_line = self.current_line[self.max_chars:]

            if len(self.lines) > self.max_lines:
                self.lines = self.lines[-self.max_lines:]

        self._afficher()

    def _afficher(self):
        for ligne in self.lines:
            print(f"  {ligne}")
        print(f"  {self.current_line}", end="", flush=True)

    def _afficher_final(self):
        print("\n\n[Untertitelung beendet]")

Interaktiver Sprachassistent

Ein Sprachassistent kann keine Stille vertragen. Er muss den Nutzer während des Sprechens verstehen, sonst entsteht nach jeder Frage eine Lücke, die die Maschine sofort verrät. Echtzeit-Transkription ist der erste Glied einer dreistufigen Kette: Speech-to-Text, dann LLM, dann Text-to-Speech. Hier sinkt die Latenz auf 300 Millisekunden, den aggressivsten Wert in dieser gesamten Lektion, und der Text wird durch Überschreiben der aktuellen Zeile mit einem Zeilenumbruch angezeigt, was den Eindruck erweckt, als würde sich der Satz vor Ihren Augen vervollständigen.

Die zweite Hälfte der Funktion schaltet auf das LLM um. Die Antwort wird ebenfalls als Stream angefordert, sodass die ersten Wörter eintreffen, bevor das Modell seinen Satz beendet: Die im Transkriptionsschritt gewonnene Reaktionsfähigkeit wird im nächsten Schritt nicht verschwendet. Der System-Prompt erzwingt Kürze, ein entscheidendes Detail in der mündlichen Interaktion, bei der eine zehnzeilige Antwort unhörbar wird.

async def assistant_vocal(audio_source):
    """Transkribiert und antwortet über ein LLM."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    # Schritt 1: Die Frage transkribieren
    question_parts = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=audio_source,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=300,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            question_parts.append(event.text)
            texte_en_cours = "".join(question_parts)
            print(f"\rSie: {texte_en_cours}", end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    question = "".join(question_parts).strip()
    print()

    if not question:
        print("Keine Frage erkannt.")
        return

    # Schritt 2: An LLM senden, um eine Antwort zu erhalten
    print("Assistent: ", end="", flush=True)

    reponse_stream = client.chat.stream(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": "Sie sind ein präziser Sprachassistent. "
                           "Antworten Sie maximal in 2-3 Sätzen."
            },
            {"role": "user", "content": question}
        ]
    )

    for chunk in reponse_stream:
        texte = chunk.data.choices[0].delta.content
        if texte:
            print(texte, end="", flush=True)

    print("\n")

Sprachdiktatur mit automatischer Speicherung

Diktation stellt ein Problem dar, das die beiden vorherigen Fälle ignorieren: die Dauer. Eine Sitzung kann sich über eine Stunde erstrecken, und der Verlust des Textes aufgrund eines Absturzes oder eines Ausfalls wäre inakzeptabel. Daher erfolgt eine automatische Speicherung, die etwa alle hundert Wörter ausgelöst wird und die Ausgabedatei auf dem Laufenden neu schreibt. Der Zähler nb_mots dient auch als Benutzer-Feedback: Er teilt Ihnen mit, wie viel Sie produziert haben, eine Information, die jeder, der einen Bericht diktiert, erwartet. Die 600-Millisekunden-Latenz platziert den Cursor auf der Seite der Präzision, da jemand, der diktiert, seinen Text zurückliest und ein genaues Wort einem sofortigen vorzieht.

class DicteeVocale:
    """Sprachdiktatur mit automatischer Speicherung."""

    def __init__(self, fichier_sortie="dictee.txt"):
        self.fichier_sortie = fichier_sortie
        self.texte = []
        self.nb_mots = 0

    async def run(self, audio_source):
        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        print("Diktieren... (Strg+C zum Beenden)\n")

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=audio_source,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=600,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self.texte.append(event.text)
                self.nb_mots += len(event.text.split())
                print(event.text, end="", flush=True)

                # Automatische Speicherung alle 100 Wörter
                if self.nb_mots % 100 < 5:
                    self._sauvegarder()

            elif isinstance(event, TranscriptionStreamDone):
                break

        self._sauvegarder()
        print(f"\n\nDiktatur beendet: {self.nb_mots} Wörter")
        print(f"Datei: {self.fichier_sortie}")

    def _sauvegarder(self):
        contenu = "".join(self.texte)
        with open(self.fichier_sortie, "w", encoding="utf-8") as f:
            f.write(contenu)

Konferenztranskription mit Metadaten

Bei einer langen Konferenz ist roher Text nicht viel wert, wenn er nicht identifizierbar ist. Sechs Monate später weiß niemand, von welcher Sitzung oder welchem Sprecher eine Datei namens transcription.txt stammt. Die folgende Funktion umhüllt die Transkription daher in eine dokumentierte Struktur – Konferenzname, Sprecher, Start- und Endzeitstempel, Wortanzahl – und exportiert sie als JSON unter einem zeitgestempelten Namen, der sofort von einem internen Suchmotor oder einem Archivierungs-Pipeline verwendet werden kann. Die 1.200-Millisekunden-Latenz ist hier völlig komfortabel: Das Publikum hört dem Sprecher zu, die Anzeige ist nur eine Ergänzung, und die Präzision hat Vorrang.

import json
from datetime import datetime

async def transcribe_conference(
    audio_source,
    conference_name: str,
    speaker: str = "Inconnu"
):
    """Transkribiert eine Konferenzsession mit Metadaten."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    session = {
        "conference": conference_name,
        "speaker": speaker,
        "debut": datetime.now().isoformat(),
        "texte": [],
    }

    print(f"Transkription: {conference_name}")
    print(f"Sprecher: {speaker}")
    print("-" * 50)

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=audio_source,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=1200,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            session["texte"].append(event.text)
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    session["fin"] = datetime.now().isoformat()
    session["texte"] = "".join(session["texte"])
    session["nb_mots"] = len(session["texte"].split())

    filename = f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(session, f, ensure_ascii=False, indent=2)

    print(f"\n\nSession gespeichert: {filename}")
    return session

Überprüfen Sie die vier Latenzen in der Reihenfolge – 300, 600, 800 und dann 1.200 Millisekunden – und beachten Sie, dass sie einer einzigen Logik folgen: Je mehr der Nutzer eine Reaktion von der Maschine erwartet, desto kürzer muss die Verzögerung sein; je mehr er ein nutzbares Dokument erwartet, desto länger kann sie sein. Nehmen Sie eine dieser Anwendungen und stecken Sie sie in den Mikrofon-Generator aus der vorherigen Lektion: Sie haben in wenigen Minuten ein wirklich nutzbares Werkzeug.

Kernaussagen

  • Live-Untertitelung verwendet eine Latenz von 800 ms und verwaltet die Anzeige Zeile für Zeile
  • Der Sprachassistent verknüpft Echtzeit-Transkription und ein LLM, um Fragen zu beantworten
  • Sprachdiktatur speichert Text automatisch auf dem Laufenden
  • Konferenztranskription fügt Metadaten hinzu und exportiert nach JSON
  • Jeder Anwendungsfall hat seine optimale Latenz: 300 ms (Assistent) bis 1.200 ms (Konferenz), innerhalb des akzeptierten Bereichs von 80 bis 1.200 ms oder 2.400 ms