Otimização da Latência
Nesta página
Curso atualizado a 3 de novembro de 2026 para o Voxtral TTS 3, com base no guia Migrate from Voxtral 2 e nas páginas Text to Speech da Mistral:
voxtral-mini-tts-2603, descontinuado a 31 de outubro de 2026 e retirado a 30 de abril de 2027, é substituído nos exemplos porvoxtral-mini-tts-3-0. As vozes predefinidas do Voxtral 2 (gb_jane_neutral…) continuam suportadas; o Voxtral 3 adiciona as tags[emotion=…]e[pace=…]no texto, a definiçãoexpressiveness, a pronúncia personalizada (phoneme_hints) e 35 idiomas. A Mistral recomenda voltar a medir a latência após a migração. Fontes: Migrate from Voxtral 2 · Speech generation.
Latência: O Inimigo da Conversação Natural
Numa conversa humana, o tempo médio de resposta ronda os 200 milissegundos. Acima de 500 ms, o interlocutor percebe um atraso; além de um segundo, assume que não o ouviu e repete a pergunta. Para que um assistente de voz pareça natural, o tempo entre o fim da pergunta e o início da resposta deve manter-se abaixo de um segundo.
O Voxtral anuncia uma latência do modelo de aproximadamente 90 ms, e é aqui que muitas equipas falham: esse valor descreve apenas um elo numa cadeia muito mais longa. O que o utilizador experiencia é a soma de todos os elos. A otimização exige, portanto, conhecer o custo de cada componente.
Anatomia da Latência Total
A jornada começa com a rede de saída: o tempo necessário para encaminhar o seu pedido para os servidores da Mistral. Isto depende da sua localização e da qualidade da ligação; a partir da Europa, espere entre 20 e 80 ms. Segue-se a latência do modelo, os famosos 90 ms de processamento antes do primeiro fragmento de áudio — a única parte sobre a qual não tem controlo, pois pertence à infraestrutura da Mistral.
O passo seguinte é a codificação, e é aqui que se escondem as piores surpresas. O PCM não custa nada, ou quase nada, porque não há nada para codificar. O Opus adiciona 5 a 10 ms, o que permanece negligenciável. O MP3, no entanto, exige 200 a 500 ms: o seu codec deve acumular dados suficientes antes de produzir o primeiro quadro. Por outras palavras, um programador que deixe response_format="mp3" por hábito adiciona mais atraso por conta própria do que todo o modelo.
Finalmente, a rede de retorno pesa pouco em streaming, uma vez que os fragmentos são pequenos. O que resta é o buffer do lado do cliente: a sua aplicação geralmente acumula dois ou três fragmentos antes de iniciar a reprodução para evitar microcortes. Adicione 50 a 150 ms — um custo deliberado que compra fluidez.
Streaming vs. Batch: Os Números
| Métrica | Batch (sem streaming) | Streaming PCM | Streaming MP3 |
|---|---|---|---|
| Primeiro som | 1-3 segundos | ~0,7 segundos | ~2 segundos |
| Latência percebida | Alta | Muito baixa | Média |
| Largura de banda | Pico único | Distribuída | Distribuída |
Estas ordens de grandeza foram registadas com o Voxtral 2. A Mistral anuncia aproximadamente 90 ms antes do primeiro som para o Voxtral TTS 3 no lado do modelo e recomenda voltar a medir a latência a partir da sua aplicação após a migração: refaça estas medições com a sua rede e o seu formato.
Mudar do batch para o streaming PCM reduz a latência percebida por um fator de três a quatro. Nenhuma outra otimização nesta lição terá um efeito comparável: esta é a primeira coisa a alterar, mesmo antes de medir.
Três Alavancas do Lado do Servidor
A primeira alavanca é o formato. Para qualquer aplicação conversacional, o streaming PCM é a definição de referência, e a alteração ocorre sem reescrever a sua lógica.
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=text,
voice_id=voice_id,
response_format="pcm", # Latência mínima
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
play_audio(base64.b64decode(event.data.audio_data))
A segunda alavanca reside na escolha entre uma voz guardada e a clonagem em tempo real. Um voice_id designa uma voz já processada no lado do servidor, enquanto ref_audio força o reprocessamento da amostra em cada pedido. Para um agente que responde cem vezes por hora com a mesma voz, este detalhe poupa 50 a 100 ms por turno de fala.
A terceira alavanca é encurtar o que solicita. Quanto mais curto for o texto, mais rápido chega o primeiro fragmento: gerar uma resposta de cinco frases num único bloco significa fazer o utilizador esperar por conteúdo que não ouvirá antes de mais quinze segundos. O gerador seguinte divide a resposta por frase e produz áudio para a primeira enquanto as outras aguardam.
def generate_by_sentence(full_text, voice_id):
"""Gera áudio frase a frase para minimizar a latência."""
sentences = full_text.split(". ")
for sentence in sentences:
sentence = sentence.strip()
if not sentence:
continue
if not sentence.endswith("."):
sentence += "."
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input=sentence,
voice_id=voice_id,
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
yield base64.b64decode(event.data.audio_data)
Duas Alavancas do Lado do Cliente
Um buffer fixo é sempre um compromisso mal colocado: demasiado pequeno, deixa passar microcortes numa rede carregada; demasiado grande, adiciona um atraso desnecessário numa boa ligação. A classe abaixo inicia a reprodução assim que dois fragmentos estiverem disponíveis, deixando depois passar os subsequentes à medida que chegam, nunca acumulando mais de cinco.
class AdaptiveBuffer:
def __init__(self):
self.buffer = []
self.min_threshold = 2 # Mínimo de blocos antes da reprodução
self.max_threshold = 5 # Não acumular mais
self.playback_started = False
def add_chunk(self, chunk):
self.buffer.append(chunk)
if not self.playback_started:
if len(self.buffer) >= self.min_threshold:
self.playback_started = True
return self.empty_buffer()
else:
return chunk
return None
def empty_buffer(self):
data = b"".join(self.buffer)
self.buffer = []
return data
A segunda alavanca custa apenas algumas linhas: envie um pedido de teste quando a sua aplicação iniciar. Isto estabelece a ligação TCP e o handshake TLS de uma vez por todas, e o keep-alive HTTP permite que todos os pedidos subsequentes beneficiem deste trabalho prévio. Sem este aquecimento, o seu primeiro utilizador do dia paga o preço.
Meça Antes de Otimizar
Todas estas estimativas devem ser validadas face à sua configuração real. A medição mínima consiste em cronometrar o atraso até à receção do primeiro fragmento e, em seguida, sair do ciclo: é este valor, e não a duração total, que corresponde ao que o utilizador experiencia.
import time
t0 = time.perf_counter()
with client.audio.speech.complete(
model="voxtral-mini-tts-3-0",
input="Latency test.",
voice_id=voice_id,
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
t1 = time.perf_counter()
print(f"First chunk received in {(t1 - t0)*1000:.0f} ms")
break
Execute esta medição a partir do seu servidor de produção, não da sua estação de trabalho: a diferença de rede é frequentemente suficiente para explicar o fosso entre uma demonstração convincente e uma implementação dececionante.
Pontos-chave
- A latência total inclui rede, modelo (~90 ms), codificação e buffer do cliente
- O formato PCM oferece a menor latência porque não há codificação
- O streaming reduz a latência percebida por um fator de 3 a 4 em comparação com o batch
- Utilize um
voice_idem vez deref_audiopara poupar 50-100 ms - Gere frase a frase para minimizar o tempo até ao primeiro som