Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Latência e Otimização em Tempo Real

Aula 17 de 18 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Latência e Otimização em Tempo Real
  2. Anatomia da Latência
  3. Otimização da Deteção VAD
  4. Otimização das Instruções do Sistema
  5. Redução da Latência de Rede
  6. Otimização da Chamada de Funções
  7. Monitorização da Latência
  8. Pontos-chave

Atualizado a 2 de novembro de 2026 — Modelos de áudio. Vários modelos neste curso estão obsoletos: tts-1, tts-1-hd e gpt-4o-mini-tts deixarã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-realtime e 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-transcribe e /v1/audio/translations a 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:

VAD
Espera pelo silêncio que termina o turno (`silence_duration_ms`)
Rede
Idas e voltas entre o utilizador, o seu servidor e a API
Modelo
Processamento do contexto e, depois, primeiro fragmento de áudio

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_ms controla diretamente a espera antes da resposta; semantic_vad e o seu eagerness sã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