Gemma 4 com voz em tempo real: configurando o pipeline Cerebras + Hugging Face

A Hugging Face e a Cerebras anunciaram integração para rodar o Gemma 4 em pipelines de voz com latência baixa o suficiente para conversas em tempo real. Isso muda a equação de quem quer montar um assistente de voz sem depender de APIs fechadas de nuvem tradicional. Aqui vai o passo a passo para configurar esse pipeline do zero.

Por que Cerebras muda o jogo pra voz

Voz em tempo real exige que o modelo responda em poucos milissegundos, senão a conversa fica com aquele delay artificial que quebra a naturalidade. Os chips wafer scale da Cerebras entregam throughput de inferência muito acima de GPU convencional, o que permite gerar tokens rápido o bastante pra alimentar um pipeline de texto pra fala sem gargalo. O Gemma 4, sendo um modelo aberto, pode rodar direto nessa infraestrutura via Hugging Face, sem precisar montar servidor próprio.

Pré requisitos

Conta no Hugging Face com acesso a Inference Endpoints ou Inference Providers.
Chave de API do Hugging Face (token com permissão de leitura e inferência).
Python 3.10 ou superior.
Microfone e alto falante configurados na máquina, se for testar localmente.

Passo 1: instalar as dependências

Comece criando um ambiente isolado e instalando os pacotes necessários. Você vai precisar do SDK do Hugging Face Hub, de um cliente de áudio e de uma lib de streaming.

python -m venv venv
source venv/bin/activate
pip install huggingface_hub requests sounddevice numpy soundfile

Passo 2: autenticar com o Hugging Face

Gere um token em huggingface.co/settings/tokens e exporte como variável de ambiente. Isso evita deixar a chave hardcoded no código.

export HF_TOKEN="seu_token_aqui"

Teste a autenticação:

from huggingface_hub import InferenceClient
import os

client = InferenceClient(token=os.environ["HF_TOKEN"])
print("Autenticado com sucesso")

Passo 3: apontar para o provider Cerebras

O Hugging Face Inference Providers permite escolher qual backend vai rodar o modelo. Para usar a infraestrutura Cerebras, você especifica o provider na hora de instanciar o cliente.

client = InferenceClient(
    provider="cerebras",
    model="google/gemma-4-instruct",
    token=os.environ["HF_TOKEN"]
)

Se o provider “cerebras” não aparecer disponível pra sua conta, verifique na página do modelo no Hugging Face Hub se ele lista Cerebras como opção de inferência antes de seguir. Nem todo modelo tem todos os providers habilitados.

Passo 4: fazer uma chamada de texto simples primeiro

Antes de plugar áudio, valide que o modelo responde rápido pelo provider certo. Isso isola problemas de rede dos problemas de pipeline de voz.

response = client.chat_completion(
    messages=[{"role": "user", "content": "Responda em uma frase curta: o que é Cerebras?"}],
    max_tokens=60
)
print(response.choices[0].message content)

Meça o tempo de resposta aqui. Se estiver acima de meio segundo pra esse tipo de prompt curto, revise sua conexão ou o endpoint escolhido antes de continuar.

Passo 5: montar o pipeline de fala para texto (entrada)

Para capturar a voz do usuário e transcrever, use um modelo de reconhecimento de fala rodando localmente ou via outro endpoint do Hugging Face. Whisper continua sendo a opção mais testada para essa etapa.

import sounddevice as sd
import numpy as np
import soundfile as sf

def gravar_audio(duracao=5, taxa=16000):
    print("Gravando...")
    audio = sd.rec(int(duracao * taxa), samplerate=taxa, channels=1)
    sd.wait()
    sf.write("entrada.wav", audio, taxa)
    return "entrada.wav"

def transcrever(caminho_audio):
    stt_client = InferenceClient(model="openai/whisper-large-v3", token=os.environ["HF_TOKEN"])
    with open(caminho_audio, "rb") as f:
        resultado = stt_client.automatic_speech_recognition(f.read())
    return resultado.text

Passo 6: enviar o texto transcrito para o Gemma 4

Com a transcrição em mãos, envie para o modelo rodando na Cerebras. Aqui é onde a velocidade de inferência importa de verdade, porque o usuário está esperando resposta falada.

def gerar_resposta(texto_usuario):
    response = client.chat_completion(
        messages=[
            {"role": "system", "content": "Responda de forma curta e natural, como numa conversa falada."},
            {"role": "user", "content": texto_usuario}
        ],
        max_tokens=120,
        stream=True
    )
    texto_completo = ""
    for chunk in response:
        delta = chunk.choices[0].delta.content or ""
        texto_completo += delta
        print(delta, end="", flush=True)
    return texto_completo

Usar stream=True é importante aqui. Em vez de esperar a resposta inteira, você pode começar a sintetizar áudio dos primeiros trechos de texto assim que eles chegam, cortando a latência percebida.

Passo 7: converter o texto de volta em fala

Para a saída, use um modelo de texto para fala disponível no Hugging Face. Modelos como os da família de TTS open source funcionam bem para esse pipeline.

def falar(texto):
    tts_client = InferenceClient(model="suno/bark", token=os.environ["HF_TOKEN"])
    audio_bytes = tts_client.text_to_speech(texto)
    with open("saida.wav", "wb") as f:
        f.write(audio_bytes)
    sd.play(*sf.read("saida.wav"))
    sd.wait()

Passo 8: juntar tudo em um loop de conversa

Agora é só encadear as três etapas: captura de voz, geração de resposta pelo Gemma 4 via Cerebras, e síntese de fala.

def loop_conversa():
    while True:
        caminho = gravar_audio(duracao=5)
        texto_usuario = transcrever(caminho)
        print(f"Você disse: {texto_usuario}")

        if texto_usuario.strip().lower() in ["sair", "parar"]:
            break

        resposta = gerar_resposta(texto_usuario)
        falar(resposta)

if __name__ == "__main__":
    loop_conversa()

Passo 9: medir e ajustar a latência real

Depois que o loop estiver funcionando, cronometre cada etapa separadamente para achar o gargalo.

import time

inicio = time.time()
texto_usuario = transcrever(caminho)
print(f"Transcrição: {time.time() - inicio:.2f}s")

inicio = time.time()
resposta = gerar_resposta(texto_usuario)
print(f"Geração: {time.time() - inicio:.2f}s")

Na maioria dos casos, a etapa de transcrição e a de TTS acabam pesando mais que a geração de texto pelo Gemma 4 na Cerebras, justamente porque a infraestrutura de inferência do modelo de linguagem já é otimizada pra isso. Se a latência total ainda estiver alta, considere rodar STT e TTS localmente em GPU própria e deixar só a geração de texto na nuvem.

Dicas finais

Fixe a versão do modelo (gemma-4-instruct ou variante específica) no código para evitar mudanças de comportamento quando o Hugging Face atualizar o ponteiro do modelo padrão.
Monitore o uso de tokens e o custo por chamada. Provider novo costuma ter preço diferente das rotas padrão do Hugging Face.
Se for colocar isso em produção, adicione tratamento de erro nas chamadas de rede: timeout, retry com backoff e fallback para outro provider caso a Cerebras esteja indisponível.
Teste com frases curtas primeiro. Só depois de validar a latência ponta a ponta é que vale a pena testar diálogos mais longos ou contextos com histórico de conversa.