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

Optimización de la latencia

Lección 13 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Latencia: la enemiga de la conversación natural
  2. Anatomía de la latencia total
  3. Streaming frente a lotes: las cifras
  4. Tres palancas del lado del servidor
  5. Dos palancas del lado del cliente
  6. Mide antes de optimizar
  7. Puntos clave

Curso actualizado el 3 de noviembre de 2026 para Voxtral TTS 3, basado en la guía Migrate from Voxtral 2 y las páginas de Text to Speech de Mistral: voxtral-mini-tts-2603, obsoleto desde el 31 de octubre de 2026 y retirado el 30 de abril de 2027, se sustituye en los ejemplos por voxtral-mini-tts-3-0. Las voces predefinidas de Voxtral 2 (gb_jane_neutral…) siguen siendo compatibles; Voxtral 3 añade las etiquetas [emotion=…] y [pace=…] en el texto, el parámetro expressiveness, la pronunciación personalizada (phoneme_hints) y 35 idiomas. Mistral recomienda volver a medir la latencia tras la migración. Fuentes: Migrate from Voxtral 2 · Speech generation.

Latencia: la enemiga de la conversación natural

En una conversación humana, el tiempo medio de respuesta ronda los 200 milisegundos. Por encima de 500 ms, el interlocutor percibe un retraso; superado el segundo, asume que no le has oído y repite la pregunta. Para que un asistente de voz resulte natural, el intervalo entre el final de la pregunta y el inicio de la respuesta debe mantenerse por debajo de un segundo.

Voxtral anuncia una latencia del modelo de aproximadamente 90 ms, y aquí es donde muchos equipos se equivocan: esa cifra describe solo un eslabón de una cadena mucho más larga. Lo que experimenta el usuario es la suma de todos los eslabones. Por tanto, optimizar exige conocer el coste de cada componente.

Anatomía de la latencia total

El trayecto comienza con la red de salida: el tiempo que tarda tu solicitud en llegar a los servidores de Mistral. Depende de tu ubicación y de la calidad de la conexión; desde Europa, calcula entre 20 y 80 ms. A continuación llega la latencia del modelo, esos famosos 90 ms de procesamiento antes del primer fragmento de audio; es la única parte sobre la que no tienes control, pues pertenece a la infraestructura de Mistral.

El siguiente paso es la codificación, y aquí es donde acechan las sorpresas más desagradables. PCM no cuesta nada, o casi nada, porque no hay nada que codificar. Opus añade entre 5 y 10 ms, lo cual sigue siendo despreciable. MP3, en cambio, exige entre 200 y 500 ms: su códec debe acumular suficientes datos antes de producir el primer fotograma. En otras palabras, un desarrollador que deja response_format="mp3" por inercia añade más retraso por su cuenta que todo el modelo junto.

Por último, la red de retorno apenas pesa en modo streaming, ya que los fragmentos son pequeños. Queda el búfer del lado del cliente: tu aplicación suele acumular dos o tres fragmentos antes de iniciar la reproducción para evitar microcortes. Suma entre 50 y 150 ms: un coste deliberado que compra fluidez.

Streaming frente a lotes: las cifras

MétricaLote (sin streaming)Streaming PCMStreaming MP3
Primer sonido1-3 segundos~0,7 segundos~2 segundos
Latencia percibidaAltaMuy bajaMedia
Ancho de bandaPico únicoDistribuidoDistribuido

Estos órdenes de magnitud se registraron con Voxtral 2. Mistral anuncia aproximadamente 90 ms antes del primer sonido para Voxtral TTS 3 en el lado del modelo, y recomienda volver a medir la latencia desde tu aplicación tras la migración: repite estas mediciones con tu red y tu formato.

Cambiar de lote a streaming PCM reduce la latencia percibida entre tres y cuatro veces. Ninguna otra optimización de esta lección tendrá un efecto comparable: esto es lo primero que debes cambiar, incluso antes de medir.

Tres palancas del lado del servidor

La primera palanca es el formato. Para cualquier aplicación conversacional, streaming PCM es la configuración de referencia, y el cambio se realiza sin reescribir tu lógica.

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input=text,
    voice_id=voice_id,
    response_format="pcm",  # Mínima latencia
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            play_audio(base64.b64decode(event.data.audio_data))

La segunda palanca reside en la elección entre una voz guardada y la clonación al vuelo. Un voice_id designa una voz ya procesada en el servidor, mientras que ref_audio obliga a reprocesar la muestra en cada solicitud. Para un agente que responde cien veces por hora con la misma voz, este detalle ahorra entre 50 y 100 ms por turno de palabra.

La tercera palanca es acortar lo que solicitas. Cuanto más breve sea el texto, antes llegará el primer fragmento: generar una respuesta de cinco frases en un solo bloque significa hacer esperar al usuario a contenido que no oirá hasta dentro de otros quince segundos. El siguiente generador divide la respuesta por frases y produce audio para la primera mientras las demás esperan.

def generate_by_sentence(full_text, voice_id):
    """Genera audio frase a frase para minimizar la latencia."""
    sentences = full_text.split(". ")

    for sentence in sentences:
        sentence = sentence.strip()
        if not sentence:
            continue
        if not sentence.endswith("."):
            sentence += "."

        with client.audio.speech.complete(
            model="voxtral-mini-tts-3-0",
            input=sentence,
            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)

Dos palancas del lado del cliente

Un búfer fijo es siempre un compromiso mal situado: si es demasiado pequeño, deja pasar microcortes en una red cargada; si es demasiado grande, añade retraso innecesario en una buena conexión. La clase siguiente inicia la reproducción en cuanto hay dos fragmentos disponibles y deja pasar los siguientes a medida que llegan, sin acumular nunca más de cinco.

class AdaptiveBuffer:
    def __init__(self):
        self.buffer = []
        self.min_threshold = 2   # Fragmentos mínimos antes de reproducir
        self.max_threshold = 5   # No acumular más de esto
        self.playback_started = False

    def add_chunk(self, chunk):
        self.buffer.append(chunk)

        if not self.playback_started:
            if len(self.buffer) >= self.min_threshold:
                self.playback_started = True
                return self.empty_buffer()
        else:
            return chunk
        return None

    def empty_buffer(self):
        data = b"".join(self.buffer)
        self.buffer = []
        return data

La segunda palanca cuesta solo unas líneas: envía una solicitud de prueba cuando tu aplicación arranca. Esto establece la conexión TCP y el handshake TLS de una vez por todas, y HTTP keep-alive permite que todas las solicitudes posteriores se beneficien de esta preparación. Sin este calentamiento, tu primer usuario del día paga el precio.

Mide antes de optimizar

Todas estas estimaciones deben validarse con tu configuración real. La medición mínima consiste en cronometrar el retraso hasta recibir el primer fragmento y salir del bucle: es esta cifra, no la duración total, la que corresponde a lo que experimenta el usuario.

import time

t0 = time.perf_counter()

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="Latency test.",
    voice_id=voice_id,
    response_format="pcm",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            t1 = time.perf_counter()
            print(f"Primer fragmento recibido en {(t1 - t0)*1000:.0f} ms")
            break

Ejecuta esta medición desde tu servidor de producción, no desde tu estación de trabajo: la diferencia de red suele bastar para explicar la brecha entre una demostración convincente y un despliegue decepcionante.

Puntos clave

  • La latencia total incluye red, modelo (~90 ms), codificación y búfer del cliente
  • El formato PCM ofrece la menor latencia porque no requiere codificación
  • El streaming reduce la latencia percibida entre 3 y 4 veces frente a los lotes
  • Usa un voice_id en lugar de ref_audio para ahorrar 50-100 ms
  • Genera frase a frase para minimizar el tiempo hasta el primer sonido