Latencia y optimización en tiempo real
En esta página
Actualizado el 2 de noviembre de 2026 — Modelos de audio. Varios modelos de este curso están obsoletos:
tts-1,tts-1-hdygpt-4o-mini-ttsdejará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-realtimey 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-transcribey/v1/audio/translationsel 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:
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_mscontrola directamente la espera antes de la respuesta;semantic_vady sueagernessson 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