Controlo da Latência
Nesta página
Curso atualizado a 3 de novembro de 2026 para o Voxtral 3, com base no guia Migrate from Voxtral 2 da Mistral: os modelos Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), descontinuados a 31 de outubro de 2026 e retirados a 30 de abril de 2027, são substituídos nos exemplos porvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3evoxtral-mini-tts-3-0. Alterações principais: carimbos de tempo apenas por segmento (worddevolve um erro 400), a diarização em tempo real é possível, as definições de sessão em tempo real ficam bloqueadas após o primeiro bloco de áudio e as entradascontext_biassão de formato livre (frases com espaços). Fontes: Migrate from Voxtral 2 · Speech to Text.
O compromisso entre latência e precisão
A transcrição em tempo real assenta num compromisso inevitável: a velocidade de resposta faz-se à custa da precisão. Quanto mais tempo o modelo esperar antes de emitir uma palavra, mais contexto terá para distinguir entre hipóteses acústicas semelhantes — e mais tempo o seu utilizador terá de esperar. Uma frase como «ele levou o mar» versus «ele levou o amargo» só pode tornar-se clara pelo que se segue; um modelo apressado escolherá por vezes a opção errada.
O Voxtral Realtime não esconde este compromisso atrás de uma definição automática: entrega-lho explicitamente através do parâmetro target_streaming_delay_ms. É o utilizador que decide o ponto de equilíbrio, caso a caso.
O parâmetro target_streaming_delay_ms
Este valor expressa em milissegundos o atraso alvo entre a receção do áudio e a emissão do texto correspondente. Com o Voxtral 3, aceita qualquer inteiro entre 80 e 1.200, ou 2.400; qualquer outro valor desencadeia um evento de erro. Passa-o diretamente para a chamada de streaming, tal como o modelo e o formato de áudio e, como todas as definições de sessão, fica bloqueado após o primeiro bloco de áudio:
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
# Baixa latência: resposta rápida, menos precisa
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=240, # 240 ms
):
if isinstance(event, TranscriptionStreamTextDelta):
print(event.text, end="", flush=True)
Três intervalos de valores cobrem quase todos os casos de uso. Entre 200 e 300 milissegundos, a transcrição é ultra-responsiva: esta é a definição para assistentes de voz, onde a imediatez é primordial e o texto pode conter mais correções. Entre 500 e 1.000 milissegundos, obtém-se um bom equilíbrio, adequado para legendagem em direto e ditado. Para além disso, entre 2.000 e 3.000 milissegundos, o modelo trabalha com muito mais contexto e produz um texto significativamente mais limpo, à custa de um atraso que o utilizador percebe claramente.
O padrão Dual Delay
Tem mesmo de escolher? O Voxtral Realtime oferece uma solução alternativa: lance dois fluxos em paralelo no mesmo áudio, com latências diferentes, e recuse assim o compromisso. O fluxo rápido, definido por exemplo para 240 milissegundos, fornece um feedback visual imediato que tranquiliza o utilizador e mostra que o sistema está a ouvir. O fluxo lento, definido para 2.400 milissegundos, produz uma transcrição mais precisa que substitui gradualmente o texto provisório.
Conhece este comportamento mesmo que não lhe tenha dado um nome: é assim que funcionam as legendas em direto no YouTube ou no Google Meet, onde o texto aparece quase instantaneamente e se corrige alguns momentos depois. A implementação envolve definir duas corrotinas idênticas exceto pelo atraso e executá-las em conjunto com asyncio.gather.
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
async def dual_latency_stream(source_audio_fast, source_audio_slow):
"""Executa duas transcrições em paralelo com latências diferentes."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
results = {"fast": [], "slow": []}
async def fast_stream():
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio_fast,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=240,
):
if isinstance(event, TranscriptionStreamTextDelta):
results["fast"].append(event.text)
# Apresentar imediatamente (será substituído pelo fluxo lento)
print(f"\r[FAST] {''.join(results['fast'][-10:])}",
end="", flush=True)
async def slow_stream():
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio_slow,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=2400,
):
if isinstance(event, TranscriptionStreamTextDelta):
results["slow"].append(event.text)
# Apresentar versão corrigida
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Executar ambos os fluxos em paralelo
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Note que a função recebe duas fontes de áudio separadas, não uma: um gerador assíncrono só pode ser consumido uma vez, pelo que deve duplicar o fluxo a montante para alimentar ambas as transcrições.
Gestão da substituição no ecrã
Num terminal, o duplo output do código acima é suficiente para compreender o mecanismo, mas uma interface real deve fundir os dois fluxos num único texto legível. A convenção estabelecida consiste em apresentar o texto provisório numa tonalidade subtil — cinzento — e o texto confirmado a branco, avançando a fronteira entre eles à medida que o fluxo lento alcança o rápido. A classe abaixo implementa esta fronteira com final_position: tudo o que vem antes provém do fluxo lento e não mudará; tudo o que vem depois provém do fluxo rápido e permanece sujeito a correção.
class DualLatencyDisplay:
"""Gere a apresentação com dupla latência."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Novo texto do fluxo rápido (provisório)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Novo texto do fluxo lento (final)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Apresenta o texto final + texto rápido ainda não confirmado."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Este conforto tem um custo que seria desonesto ignorar: dois fluxos significam duas ligações e o dobro do volume de áudio processado. Reserve o Dual Delay para interfaces onde o utilizador lê o texto à medida que este surge; para processamento em segundo plano, um único fluxo bem afinado é mais do que suficiente.
Escolher a latência adequada ao seu caso de uso
| Caso de uso | Latência recomendada | Motivo |
|---|---|---|
| Assistente de voz | 200-300 ms | O utilizador espera uma reação imediata |
| Ditado por voz | 500-800 ms | Equilíbrio entre responsividade e precisão |
| Legendagem em direto | 800-1.200 ms | Precisão importante, ligeiro atraso aceitável |
| Transcrição de conferências | 1.200 ou 2.400 ms | Máxima precisão, atraso não crítico |
Medir a latência real alcançada
O valor que solicita é um alvo, não uma garantia: a distância de rede, a carga do serviço e o tamanho dos seus blocos acrescentam-se a ele. Antes de indicar um número aos seus utilizadores, meça-o a partir do local onde a sua aplicação será realmente executada. A função abaixo cronometra o atraso até à chegada do primeiro fragmento e compara-o com o alvo solicitado.
import time
async def measure_latency(source_audio, delay_ms):
"""Mede a latência efetiva da transcrição."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
start = time.time()
first_text = None
async for event in client.audio.realtime.transcribe_stream(
audio_stream=source_audio,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=delay_ms,
):
if isinstance(event, TranscriptionStreamTextDelta):
if first_text is None:
first_text = time.time()
latency = (first_text - start) * 1000
print(f"Primeiro texto após {latency:.0f} ms "
f"(alvo: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nDuração total: {time.time() - start:.1f}s")
Execute esta medição com 240, depois 800 e finalmente 2.400 milissegundos no mesmo excerto e leia as três transcrições lado a lado. A diferença de qualidade entre a primeira e a última dir-lhe-á, melhor do que qualquer recomendação geral, qual a latência que a sua aplicação pode suportar.
Pontos-chave
target_streaming_delay_mscontrola o compromisso entre latência e precisão- Valores baixos (80 a 300 ms): responsivos mas menos precisos
- Valores altos (1.200 ms ou 2.400 ms): precisos mas com atraso percetível; apenas são aceites valores de 80 a 1.200 e 2.400
- O padrão Dual Delay combina dois fluxos para obter simultaneamente responsividade E precisão
- O fluxo rápido fornece feedback imediato, o fluxo lento corrige o texto
- Escolha a latência com base no seu caso de uso (assistente de voz vs. legendagem)