Transmissão em tempo real
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: 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 porvoxtral-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çã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.
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=Truena chamadaaudio.speech.complete() - Os eventos
speech.audio.deltacontê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
pyaudioou WebSockets + Web Audio API