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

Otimização da Latência

Aula 13 de 14 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Latência: O Inimigo da Conversação Natural
  2. Anatomia da Latência Total
  3. Streaming vs. Batch: Os Números
  4. Três Alavancas do Lado do Servidor
  5. Duas Alavancas do Lado do Cliente
  6. Meça Antes de Otimizar
  7. Pontos-chave

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 por voxtral-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ção expressiveness, 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étricaBatch (sem streaming)Streaming PCMStreaming MP3
Primeiro som1-3 segundos~0,7 segundos~2 segundos
Latência percebidaAltaMuito baixaMédia
Largura de bandaPico únicoDistribuídaDistribuí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_id em vez de ref_audio para poupar 50-100 ms
  • Gere frase a frase para minimizar o tempo até ao primeiro som