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

Transmissão em tempo real

Aula 10 de 14 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Por que a transmissão muda tudo
  2. O protocolo de eventos
  3. Reproduzir o som à medida que chega
  4. Retransmitir o fluxo para um navegador
  5. A definição que faz a diferença: o buffer
  6. 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: o modelo voxtral-mini-tts-2603, preterido a 31 de outubro de 2026 e desativado 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 etiquetas [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.

Por que a transmissão muda tudo

Até agora, trabalhou no modo síncrono: envia o texto, aguarda que a síntese termine completamente e só então recebe o ficheiro de áudio completo. Para uma saudação pré-gerada no dia anterior, esta espera é irrelevante. Para um assistente de voz que responde a um cliente por telefone, é um impeditivo — dois segundos de silêncio após uma pergunta e o utilizador pensa que a chamada caiu.

A transmissão elimina esta espera. O áudio é enviado à medida que é gerado, fragmento por fragmento, pelo que o utilizador ouve as primeiras palavras enquanto o modelo ainda está a produzir o final da frase. O tempo total de geração não se altera; o que colapsa é o atraso antes do primeiro som.

O protocolo de eventos

A transmissão baseia-se em Server-Sent Events. Cada mensagem recebida é um evento tipado, e dois tipos interessam-lhe:

  • speech.audio.delta: contém um fragmento de áudio em base64. Este é o evento principal que irá tratar.
  • speech.audio.done: sinal de fim — a geração está completa.

Do lado do código, mudar para a transmissão significa adicionar stream=True e consumir a resposta num bloco with. O exemplo seguinte acumula fragmentos na memória para escrever um ficheiro no final: isto ainda não é tempo real, mas é a estrutura de ciclo sobre a qual o resto da lição será construída.

import base64
from pathlib import Path
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

audio_chunks = []

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="Streaming makes voice agents responsive and natural.",
    voice_id="your-voice-id",
    response_format="opus",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            chunk = base64.b64decode(event.data.audio_data)
            audio_chunks.append(chunk)
            print(f"Chunk received: {len(chunk)} bytes")

# Assemble all chunks
audio_complet = b"".join(audio_chunks)
Path("streaming-output.opus").write_bytes(audio_complet)
print(f"Final audio: {len(audio_complet)} bytes")

Reproduzir o som à medida que chega

Para obter a capacidade de resposta prometida, pare de acumular e escreva cada fragmento diretamente na placa de som. Com o pyaudio, a alteração resume-se a uma linha: em vez de adicionar o fragmento descodificado a uma lista, envia-o para um fluxo de saída aberto antecipadamente, configurado para mono Float32 a 24.000 Hz.

import base64
import pyaudio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# PCM audio configuration (fastest format)
p = pyaudio.PyAudio()
stream_audio = p.open(
    format=pyaudio.paFloat32,
    channels=1,
    rate=24000,
    output=True,
)

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="You're hearing this sentence while I generate it.",
    voice_id="your-voice-id",
    response_format="pcm",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            audio_data = base64.b64decode(event.data.audio_data)
            stream_audio.write(audio_data)

stream_audio.stop_stream()
stream_audio.close()
p.terminate()

O formato solicitado mudou de opus para pcm, e isso é importante. O PCM não necessita de descodificação: os bytes recebidos estão prontos para reprodução imediata, tornando-o o formato recomendado para uso em tempo real.

Retransmitir o fluxo para um navegador

Numa aplicação web, o servidor não reproduz o som: ele retransmite-o. O padrão clássico utiliza um WebSocket que recebe texto do navegador, abre o fluxo Voxtral e empurra cada fragmento descodificado de volta para o cliente. Do lado do navegador, a Web Audio API assume o controlo para reproduzir os fragmentos PCM recebidos.

# Server side (FastAPI example)
from fastapi import FastAPI, WebSocket
import base64
from mistralai.client import Mistral

app = FastAPI()
client = Mistral(api_key="your-api-key")

@app.websocket("/ws/tts")
async def tts_websocket(websocket: WebSocket):
    await websocket.accept()
    texte = await websocket.receive_text()

    with client.audio.speech.complete(
        model="voxtral-mini-tts-3-0",
        input=texte,
        voice_id="your-voice-id",
        response_format="pcm",
        stream=True,
    ) as stream:
        for event in stream:
            if event.event == "speech.audio.delta":
                await websocket.send_bytes(
                    base64.b64decode(event.data.audio_data)
                )

    await websocket.close()

A definição que faz a diferença: o buffer

Os tamanhos dos fragmentos variam e representam tipicamente alguns milissegundos de áudio cada um. Se reproduzir o primeiro fragmento no momento em que chega, qualquer irregularidade na rede causa uma microqueda audível — uma falha na voz que denuncia imediatamente a máquina. A solução é colocar em buffer dois ou três fragmentos antes de iniciar a reprodução, o que custa algumas dezenas de milissegundos e suaviza o restante fluxo.

Depois, há a escolha do formato, que equilibra latência e largura de banda. O PCM entrega o primeiro som mais rapidamente — cerca de 0,7 segundos nas medições feitas com o Voxtral 2, a refazer com o Voxtral TTS 3 — ao custo de um throughput elevado. O Opus perde um pouco em latência, mas comprime fortemente, tornando-se o compromisso certo quando os seus utilizadores estão em dispositivos móveis.

Pontos-chave

  • A transmissão envia áudio fragmento por fragmento durante a geração
  • Ative-a com stream=True na chamada audio.speech.complete()
  • Os eventos speech.audio.delta contêm fragmentos de áudio em base64
  • O formato PCM oferece a menor latência para transmissão (~0,7s contra ~2s para MP3)
  • Para reprodução em tempo real, utilize pyaudio ou WebSockets + Web Audio API