Latência e Otimização em Tempo Real
Nesta página
Atualizado a 2 de novembro de 2026 — Modelos de áudio. Vários modelos neste curso estão obsoletos:
tts-1,tts-1-hdegpt-4o-mini-ttsdeixarão de funcionar a 6 de janeiro de 2027 (sucessor:gpt-realtime-2.1-mini, que o guia TTS da OpenAI indica não ser suportado por/v1/audio/speech: a migração da síntese de voz passa para a Realtime API);gpt-realtime,gpt-4o-realtimee modelos de áudio legados a 20 de janeiro de 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribee/v1/audio/translationsa 26 de fevereiro de 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Para voz full-duplex, o GPT-Live 1 está disponível na API desde 10 de setembro de 2026.
Corrigido a 3 de novembro de 2026. As durações atribuídas a cada etapa («VAD 300-700 ms», «rede 20-100 ms», «modelo 200-800 ms») e os limiares de perceção («além de 500 ms») careciam de fontes: a OpenAI não publica tais valores, e esta lição ensina agora como medi-los. A instrução para colocar o seu servidor «na mesma região que os servidores da OpenAI (US East)» foi removida por falta de fundamentação. Adições documentadas:
semantic_vad, WARP para acelerar o estabelecimento de sessões WebRTC. Fontes: Detecção de atividade de voz · WebRTC com WARP · Otimização de custos.
Latência e Otimização em Tempo Real
A latência é o inimigo número um de um agente de voz: o silêncio que se segue ao fim de uma pergunta é imediatamente percetível ao telefone ou numa aplicação. Esta lição detalha as fontes de latência, como as medir e as técnicas para as reduzir.
Anatomia da Latência
A latência total de um agente de voz é a soma de vários componentes:
Consoante a sua arquitetura, acrescente o tempo das ferramentas que o agente invoca e o tempo de configuração da sessão. Nenhuma destas durações é fixa: dependem das suas definições, da duração da conversa e do trajeto de rede. A única forma de saber onde o tempo é gasto é cronometrar cada etapa, tal como faz o monitor apresentado abaixo.
Otimização da Deteção VAD
Com server_vad, a resposta não pode começar antes de terminar o silêncio definido por silence_duration_ms: esta é, portanto, uma definição direta para a latência percecionada, a equilibrar com o risco de interromper o utilizador. Os valores abaixo são pontos de partida para teste, não recomendações da OpenAI:
# Configuração agressiva (resposta rápida, risco de cortar o utilizador)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Limiar mais alto = menos falsos positivos
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Reação rápida
}
# Configuração paciente (menos interrupções, mais latência)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternativa: VAD semântico, que julga o fim da frase com base nas palavras;
# eagerness "high" responde o mais rápido possível, "low" deixa o utilizador terminar
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Configuração adaptativa baseada no 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
}
Otimização das Instruções do Sistema
Instruções concisas reduzem o contexto a processar. Lembre-se também de que a Realtime API aplica automaticamente a cache de prompts: instruções e ferramentas estáveis, colocadas no topo e nunca modificadas durante uma sessão, são reutilizadas de turno para turno.
# Instruções verbosas (mais tokens a processar)
bad_instructions = """
Você é um assistente de voz inteligente e competente que trabalha
para a Corsen AI, uma empresa francesa especializada em
inteligência artificial. Deve responder às perguntas do utilizador
de forma profissional, concisa e em francês.
Tem acesso a várias ferramentas para consultar marcações,
verificar disponibilidade e fazer reservas.
Não hesite em pedir esclarecimentos se o pedido não for claro.
"""
# Instruções otimizadas (mesmo efeito, menos tokens)
good_instructions = """
Assistente de voz Corsen AI. Francês, conciso, profissional.
Use ferramentas para marcações e reservas.
Peça esclarecimentos se necessário.
"""
Redução da Latência de Rede
Medição da Ida e Volta (Round Trip)
Coloque o seu retransmissor WebSocket o mais próximo possível dos seus utilizadores e meça o trajeto em vez de o assumir. Um evento simples, como limpar o buffer de entrada, basta para cronometrar uma ida e volta:
import time
async def measure_roundtrip(ws):
"""Mede a latência de rede para a Realtime API."""
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 outros eventos que cheguem entretanto
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Latência de rede: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Keepalive e Reconexão
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Conexão robusta com reconexão 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 a cada 20s
ping_timeout=10, # Timeout do ping 10s
close_timeout=5 # Timeout de fecho 5s
) as ws:
retry_count = 0 # Reiniciar em caso de conexão bem-sucedida
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"A reconectar em {wait}s...")
await asyncio.sleep(wait)
Uma reconexão abre uma nova sessão: a conversa anterior deixa de existir e, de qualquer forma, uma sessão dura no máximo 60 minutos. Mantenha, portanto, o seu próprio registo das trocas (transcrições, resultados de ferramentas) e reinjete o essencial com conversation.item.create após uma reconexão.
Aceleração da Configuração WebRTC: WARP
No lado do navegador ou da aplicação nativa, a OpenAI documenta o WARP (WebRTC Abridged Roundtrip Protocol), que reduz o tempo de estabelecimento da sessão WebRTC combinando três otimizações de transporte: DTLS 1.3, SPED e SNAP. Trata-se de rascunhos da IETF, suportados por versões recentes da libwebrtc; pode ativar aqueles que o seu cliente suporta, um a um. O guia WebRTC com WARP detalha a configuração.
Otimização da Chamada de Funções
As chamadas de função adicionam latência. Otimize a sua execução:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Executa chamadas de função em 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
# Cache para funções frequentes
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Coloca em cache os resultados de pedidos frequentes."""
# Consulta à base de dados ou à API
return {"data": "..."}
Monitorização da Latência
Integre um sistema de medição para identificar gargalos:
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)
Pontos-chave
- A latência total soma VAD, rede, modelo e ferramentas: meça cada etapa, a OpenAI não publica durações típicas
silence_duration_mscontrola diretamente a espera antes da resposta;semantic_vade o seueagernesssão a outra alavanca- Instruções de sistema concisas reduzem o tempo de processamento do modelo
- A execução paralela de chamadas de função e a cache reduzem a latência da aplicação
- Um sistema de monitorização com TTFA (Time-to-First-Audio) é essencial para uma otimização contínua