Ir al contenido principal
Español— Elegir un idioma
Menú

Casos de uso de la transcripción en tiempo real

Lección 13 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Cuatro aplicaciones de streaming concretas
  2. Subtitulado en directo
  3. Asistente de voz interactivo
  4. Dictado por voz con guardado automático
  5. Transcripción de conferencias con metadatos
  6. Puntos clave

Curso actualizado el 3 de noviembre de 2026 para Voxtral 3, basado en la guía Migrate from Voxtral 2 de Mistral: los modelos de Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), obsoletos desde el 31 de octubre de 2026 y retirados el 30 de abril de 2027, se sustituyen en los ejemplos por voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 y voxtral-mini-tts-3-0. Cambios clave: las marcas de tiempo son solo por segmento (word devuelve un error 400), se admite la diarización en tiempo real, la configuración de la sesión en tiempo real se bloquea tras el primer fragmento de audio y las entradas de context_bias son de formato libre (frases con espacios). Fuentes: Migrate from Voxtral 2 · Speech to Text.

Cuatro aplicaciones de streaming concretas

Ya dispones de todos los componentes básicos: el flujo de datos, el micrófono y el ajuste de latencia. Esta lección ensambla estos elementos en cuatro aplicaciones completas: subtitulado en directo, asistente de voz, dictado y transcripción de conferencias, que puedes utilizar tal cual como punto de partida. Cada una ilustra un problema que el modo sin conexión no puede resolver y utiliza un ajuste de latencia diferente, lo que te ofrece una sensación concreta del ajuste tratado anteriormente.

Subtitulado en directo

El subtitulado es el caso de uso en tiempo real más visible y, a la vez, el más exigente en cuanto a presentación. No basta con transcribir: debes dividir el texto en líneas cortas, mostrar solo dos a la vez y desplazar el conjunto sin partir nunca una palabra por la mitad. Eso es exactamente lo que hace la siguiente clase. Cuando la línea actual alcanza la longitud máxima, busca el último espacio antes de ese límite y corta ahí; si no encuentra ningún espacio —una palabra muy larga, una URL dictada—, corta en la longitud máxima en lugar de permitir que la línea se desborde. La configuración de 800 milisegundos refleja la prioridad de este caso de uso: es preferible un texto legible a uno instantáneo pero roto, y la audiencia no notará este ligero retraso.

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

class LiveCaptioning:
    """Sistema de subtitulado en directo con gestión de líneas."""

    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[Subtitulado finalizado]")

Asistente de voz interactivo

Un asistente de voz no puede permitirse silencios. Debe entender al usuario mientras habla, o dejará un hueco tras cada pregunta que delatará inmediatamente a la máquina. La transcripción en tiempo real es el primer eslabón de una cadena de tres pasos: reconocimiento de voz (Speech-to-Text), seguido del LLM y, finalmente, síntesis de voz (Text-to-Speech). Aquí, la latencia desciende a 300 milisegundos, el valor más agresivo de toda la lección, y el texto se muestra sobrescribiendo la línea actual mediante un retorno de carro, creando la impresión de que la frase se completa ante tus ojos.

La segunda mitad de la función cambia al LLM. La respuesta se solicita también como un flujo, de modo que las primeras palabras llegan antes de que el modelo haya terminado su frase: la capacidad de respuesta ganada en la fase de transcripción no se desperdicia en el siguiente paso. El prompt del sistema impone concisión, un detalle decisivo en la interacción hablada donde una respuesta de diez líneas se vuelve inaudible.

async def assistant_vocal(audio_source):
    """Transcribe y luego responde mediante un LLM."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    # Paso 1: Transcribir la pregunta
    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"\rTú: {texte_en_cours}", end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

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

    if not question:
        print("No se ha detectado ninguna pregunta.")
        return

    # Paso 2: Enviar al LLM para obtener una respuesta
    print("Asistente: ", end="", flush=True)

    reponse_stream = client.chat.stream(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": "Eres un asistente de voz conciso. "
                           "Responde en un máximo de 2-3 frases."
            },
            {"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")

Dictado por voz con guardado automático

El dictado plantea un problema que los dos casos anteriores ignoran: la duración. Una sesión puede extenderse durante una hora, y perder el texto debido a un fallo o una desconexión sería inaceptable. De ahí el guardado automático, activado aproximadamente cada cien palabras, que reescribe el archivo de salida sobre la marcha. El contador nb_mots sirve también como retroalimentación para el usuario: te indica cuánto has producido, información que cualquiera que dicte un informe espera recibir. La latencia de 600 milisegundos sitúa el cursor del lado de la precisión, ya que quien dicta releé su texto y prefiere una palabra exacta a una instantánea.

class DicteeVocale:
    """Dictado por voz con guardado automático."""

    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("Dictando... (Ctrl+C para detener)\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)

                # Guardado automático cada 100 palabras
                if self.nb_mots % 100 < 5:
                    self._sauvegarder()

            elif isinstance(event, TranscriptionStreamDone):
                break

        self._sauvegarder()
        print(f"\n\nDictado finalizado: {self.nb_mots} palabras")
        print(f"Archivo: {self.fichier_sortie}")

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

Transcripción de conferencias con metadatos

Para una conferencia larga, el texto en bruto no sirve de mucho si no es identificable. Seis meses después, nadie sabrá de qué sesión o ponente procede un archivo llamado transcription.txt. La siguiente función envuelve, por tanto, la transcripción en una estructura documentada —nombre de la conferencia, ponente, marcas de tiempo de inicio y fin, recuento de palabras— y la exporta como JSON bajo un nombre con marca de tiempo, listo para ser utilizado inmediatamente por un motor de búsqueda interno o una tubería de archivado. La latencia de 1.200 milisegundos es perfectamente cómoda aquí: la audiencia escucha al ponente, la pantalla es solo un complemento y la precisión tiene prioridad.

import json
from datetime import datetime

async def transcribe_conference(
    audio_source,
    conference_name: str,
    speaker: str = "Inconnu"
):
    """Transcribe una sesión de conferencia con metadatos."""
    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"Transcripción: {conference_name}")
    print(f"Ponente: {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\nSesión guardada: {filename}")
    return session

Revisa las cuatro latencias en orden —300, 600, 800 y, finalmente, 1.200 milisegundos— y observa que siguen una única lógica: cuanto más espera el usuario una reacción de la máquina, menor debe ser el retraso; cuanto más espera un documento utilizable, mayor puede ser. Toma una de estas aplicaciones y conéctala al generador de micrófono de la lección anterior: tendrás una herramienta realmente usable en solo unos minutos.

Puntos clave

  • El subtitulado en directo utiliza una latencia de 800 ms y gestiona la visualización línea por línea
  • El asistente de voz encadena la transcripción en tiempo real y un LLM para responder preguntas
  • El dictado por voz guarda automáticamente el texto sobre la marcha
  • La transcripción de conferencias añade metadatos y exporta a JSON
  • Cada caso de uso tiene su latencia óptima: desde 300 ms (asistente) hasta 1.200 ms (conferencia), dentro del rango aceptado de 80 a 1.200 ms o 2.400 ms