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

Latencia y optimización en tiempo real

Lección 17 de 18 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Latencia y optimización en tiempo real
  2. Anatomía de la latencia
  3. Optimización de la detección VAD
  4. Optimización de las instrucciones del sistema
  5. Reducción de la latencia de red
  6. Optimización de la llamada a funciones
  7. Monitorización de la latencia
  8. Puntos clave

Actualizado el 2 de noviembre de 2026 — Modelos de audio. Varios modelos de este curso están obsoletos: tts-1, tts-1-hd y gpt-4o-mini-tts dejarán de funcionar el 6 de enero de 2027 (sucesor: gpt-realtime-2.1-mini, que la guía de TTS de OpenAI indica que no es compatible con /v1/audio/speech: la migración de la síntesis de voz se traslada a la API en tiempo real); gpt-realtime, gpt-4o-realtime y los modelos de audio herederos el 20 de enero de 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe y /v1/audio/translations el 26 de febrero de 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Para la comunicación full-duplex de voz, GPT-Live 1 está disponible en la API desde el 10 de septiembre de 2026.

Corregido el 3 de noviembre de 2026. Las duraciones asignadas a cada paso («VAD 300-700 ms», «red 20-100 ms», «modelo 200-800 ms») y los umbrales de percepción («más allá de 500 ms») carecían de fuentes: OpenAI no publica estas cifras, y esta lección te enseña ahora cómo medirlas. Se ha eliminado la instrucción de colocar tu servidor «en la misma región que los servidores de OpenAI (US East)» por falta de fuentes. Adiciones documentadas: semantic_vad, WARP para acelerar el establecimiento de sesiones WebRTC. Fuentes: Detección de actividad de voz · WebRTC con WARP · Optimización de costes.

Latencia y optimización en tiempo real

La latencia es el enemigo número uno de un agente de voz: el silencio que sigue al final de una pregunta se nota inmediatamente en una llamada telefónica o en una aplicación. Esta lección detalla las fuentes de latencia, cómo medirlas y las técnicas para reducirlas.

Anatomía de la latencia

La latencia total de un agente de voz es la suma de varios componentes:

VAD
Espera del silencio que finaliza el turno (`silence_duration_ms`)
Red
Viajes de ida y vuelta entre el usuario, tu servidor y la API
Modelo
Procesamiento del contexto y, después, primer fragmento de audio

Dependiendo de tu arquitectura, suma también las herramientas que llama el agente y el tiempo de configuración de la sesión. Ninguna de estas duraciones es fija: dependen de tu configuración, la longitud de la conversación y la ruta de red. La única forma de saber dónde se pierde el tiempo es cronometrar cada paso, tal y como hace el monitor que se presenta a continuación.

Optimización de la detección VAD

Con server_vad, la respuesta no puede comenzar antes de que termine el silencio definido por silence_duration_ms: por tanto, este es un ajuste directo para la latencia percibida, que debe equilibrarse con el riesgo de interrumpir al usuario. Los valores siguientes son puntos de partida para probar, no recomendaciones de OpenAI:

# Configuración agresiva (respuesta rápida, riesgo de cortar al usuario)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Umbral más alto = menos falsos positivos
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Reacción rápida
}

# Configuración paciente (menos interrupciones, más latencia)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternativa: VAD semántico, que juzga el final de la frase basándose en las palabras;
# eagerness "high" responde lo antes posible, "low" deja que el usuario termine
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Configuración adaptativa según el contexto
def get_vad_config(context: str) -> dict:
    configs = {
        "menu_ivr": {"threshold": 0.6, "silence_duration_ms": 400},
        "conversation": {"threshold": 0.5, "silence_duration_ms": 600},
        "dictation": {"threshold": 0.3, "silence_duration_ms": 1200},
    }
    config = configs.get(context, configs["conversation"])
    return {
        "type": "server_vad",
        "prefix_padding_ms": 300,
        **config
    }

Optimización de las instrucciones del sistema

Las instrucciones concisas reducen el contexto a procesar. Recuerda también que la API en tiempo real aplica el almacenamiento en caché de prompts automáticamente: las instrucciones y herramientas estables, colocadas al principio y nunca modificadas durante una sesión, se reutilizan de turno en turno.

# Instrucciones verbosas (más tokens que procesar)
bad_instructions = """
Eres un asistente de voz inteligente y competente que trabaja
para Corsen AI, una empresa francesa especializada en
inteligencia artificial. Debes responder a las preguntas del usuario
de forma profesional, concisa y en francés.
Tienes acceso a varias herramientas para consultar citas,
comprobar disponibilidad y hacer reservas.
No dudes en pedir aclaraciones si la solicitud no está clara.
"""

# Instrucciones optimizadas (mismo efecto, menos tokens)
good_instructions = """
Asistente de voz de Corsen AI. Francés, conciso, profesional.
Usa herramientas para citas y reservas.
Pide aclaraciones si es necesario.
"""

Reducción de la latencia de red

Medición del viaje de ida y vuelta

Coloca tu repetidor WebSocket lo más cerca posible de tus usuarios y mide la ruta en lugar de asumirla. Un evento simple, como limpiar el búfer de entrada, basta para cronometrar un viaje de ida y vuelta:

import time

async def measure_roundtrip(ws):
    """Mide la latencia de red hacia la API en tiempo real."""
    start = time.monotonic()
    await ws.send(json.dumps({"type": "input_audio_buffer.clear"}))
    while json.loads(await ws.recv())["type"] != "input_audio_buffer.cleared":
        pass  # ignora otros eventos que lleguen entretanto
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Latencia de red: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive y reconexión

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Conexión robusta con reconexión automática."""
    retry_count = 0

    while retry_count < max_retries:
        try:
            async with websockets.connect(
                REALTIME_URL,
                additional_headers={
                    "Authorization": f"Bearer {api_key}"
                },
                ping_interval=20,     # Ping cada 20 s
                ping_timeout=10,       # Tiempo de espera del ping 10 s
                close_timeout=5        # Tiempo de espera de cierre 5 s
            ) as ws:
                retry_count = 0  # Reiniciar en caso de conexión exitosa
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Reconectando en {wait} s...")
            await asyncio.sleep(wait)

Una reconexión abre una nueva sesión: la conversación anterior ya no está ahí y, de todos modos, una sesión dura como máximo 60 minutos. Por tanto, mantén tu propio registro de los intercambios (transcripciones, resultados de herramientas) y reinyecta lo esencial con conversation.item.create después de una reconexión.

Aceleración de la configuración de WebRTC: WARP

En el lado del navegador o de la aplicación nativa, OpenAI documenta WARP (WebRTC Abridged Roundtrip Protocol), que reduce el tiempo de establecimiento de la sesión WebRTC combinando tres optimizaciones de transporte: DTLS 1.3, SPED y SNAP. Se trata de borradores de la IETF, compatibles con versiones recientes de libwebrtc; puedes habilitar aquellas que tu cliente soporte, una por una. La guía WebRTC con WARP detalla la configuración.

Optimización de la llamada a funciones

Las llamadas a funciones añaden latencia. Optimiza su ejecución:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Ejecuta llamadas a funciones en paralelo."""
    tasks = []
    for call in function_calls:
        task = execute_single_function(call["name"], call["arguments"])
        tasks.append(task)

    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Caché para funciones frecuentes
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Almacena en caché los resultados de solicitudes frecuentes."""
    # Consulta a base de datos o API
    return {"data": "..."}

Monitorización de la latencia

Integra un sistema de medición para identificar cuellos de botella:

import time
from dataclasses import dataclass, field

@dataclass
class LatencyMetrics:
    speech_end_time: float = 0
    response_start_time: float = 0
    first_audio_time: float = 0
    response_complete_time: float = 0
    function_call_times: list = field(default_factory=list)

    @property
    def time_to_first_audio(self) -> float:
        if self.speech_end_time and self.first_audio_time:
            return (self.first_audio_time - self.speech_end_time) * 1000
        return 0

    @property
    def total_response_time(self) -> float:
        if self.speech_end_time and self.response_complete_time:
            return (self.response_complete_time - self.speech_end_time) * 1000
        return 0

    def report(self) -> dict:
        return {
            "ttfa_ms": round(self.time_to_first_audio),
            "total_ms": round(self.total_response_time),
            "function_calls_ms": [round(t * 1000) for t in self.function_call_times]
        }

class LatencyTracker:
    def __init__(self):
        self.current = LatencyMetrics()
        self.history = []

    def on_event(self, event_type: str):
        now = time.time()

        if event_type == "input_audio_buffer.speech_stopped":
            self.current.speech_end_time = now

        elif event_type == "response.output_audio.delta":
            if not self.current.first_audio_time:
                self.current.first_audio_time = now

        elif event_type == "response.done":
            self.current.response_complete_time = now
            self.history.append(self.current.report())
            self.current = LatencyMetrics()

    def average_ttfa(self) -> float:
        if not self.history:
            return 0
        return sum(h["ttfa_ms"] for h in self.history) / len(self.history)

Puntos clave

  • La latencia total suma VAD, red, modelo y herramientas: mide cada paso, OpenAI no publica duraciones típicas
  • silence_duration_ms controla directamente la espera antes de la respuesta; semantic_vad y su eagerness son la otra palanca
  • Las instrucciones del sistema concisas reducen el tiempo de procesamiento del modelo
  • La ejecución paralela de llamadas a funciones y el almacenamiento en caché reducen la latencia de la aplicación
  • Un sistema de monitorización con TTFA (Time-to-First-Audio) es esencial para la optimización continua