Como construir um assistente de IA faça-você-mesmo com Raspberry Pi

Quer um assistente de voz minúsculo que realmente siga suas instruções, funcione no seu próprio hardware e não peça acidentalmente doze abacaxis porque entendeu errado? Um assistente de IA faça-você-mesmo com Raspberry Pi é surpreendentemente viável, divertido e flexível. Você vai conectar uma palavra de ativação, reconhecimento de fala (ASR = reconhecimento automático de fala), um processador de linguagem natural (regras ou um LLM) e um conversor de texto em fala (TTS). Adicione alguns scripts, um ou dois serviços e alguns ajustes de áudio cuidadosos, e você terá um alto-falante inteligente de bolso que obedece às suas regras.

Vamos te guiar do zero à comunicação com seu Raspberry Pi sem a frustração de sempre. Abordaremos componentes, configuração, código, comparações, armadilhas... tudo o que você precisa saber. 🌯

Artigos que você pode gostar de ler depois deste:

🔗 Como estudar IA de forma eficaz
Crie um plano de estudos, pratique projetos e acompanhe seu progresso.

🔗 Como iniciar uma empresa de IA
Validar o problema, construir o MVP (Produto Viável Mínimo), montar a equipe, garantir os primeiros clientes.

🔗 Como usar a IA para ser mais produtivo
Automatize tarefas rotineiras, otimize fluxos de trabalho e aumente a produção criativa.

🔗 Como incorporar a IA em seu negócio
Identificar processos de alto impacto, implementar projetos-piloto, medir o ROI e expandir.

O que torna um assistente de IA faça-você-mesmo com Raspberry Pi bom? ✅

Por padrão, o áudio fica privado – mantenha-o localmente sempre que possível. Você decide o que sai do dispositivo.
Modular – componentes intercambiáveis como peças de Lego: mecanismo de ativação por palavra-chave, reconhecimento automático de fala (ASR), memória de longo prazo (LLM), síntese de voz (TTS).
Acessível – em sua maioria de código aberto, com microfones e alto-falantes comuns, além de um Raspberry Pi.
Personalizável – quer automação residencial, painéis de controle, rotinas, habilidades personalizadas? Fácil.
Confiável – gerenciado pelo serviço, inicializa e começa a escutar automaticamente.
Diversão garantida – você aprenderá muito sobre áudio, processos e design orientado a eventos.

Uma pequena dica: Se você usa um Raspberry Pi 5 e planeja executar modelos locais mais pesados, um cooler de encaixe ajuda sob carga contínua. (Na dúvida, escolha o Active Cooler oficial projetado para o Pi 5.) [1]

Peças e ferramentas necessárias 🧰

Raspberry Pi: Recomenda-se o Pi 4 ou o Pi 5 para maior margem de segurança.
Cartão microSD: recomenda-se 32 GB ou mais.
Microfone USB: um microfone USB simples para conferências é ótimo.
Alto-falante: USB, alto-falante de 3,5 mm ou um HAT de amplificador I2S.
Rede: Ethernet ou Wi-Fi.
Acessórios opcionais: caixa, cooler ativo para Pi 5, botão de pressão para comunicação por voz, anel de LED. [1]

Sistema Operacional e Configuração Básica

Grave o Raspberry Pi OS com o Raspberry Pi Imager. É a maneira mais simples de obter um microSD inicializável com as configurações predefinidas que você deseja. [1]
Inicialize o sistema, conecte-se à rede e, em seguida, atualize os pacotes:

sudo apt update && sudo apt upgrade -y

Noções básicas de áudio: No Raspberry Pi OS, você pode definir a saída padrão, os níveis e os dispositivos por meio da interface do usuário da área de trabalho ou do raspi-config. O áudio USB e HDMI é compatível com todos os modelos; a saída Bluetooth está disponível nos modelos com Bluetooth. [1]
Verificar dispositivos:

arecord -l aplay -l

Em seguida, teste a captura e a reprodução. Se os níveis parecerem estranhos, verifique os mixers e as configurações padrão antes de culpar o microfone.

A arquitetura em resumo 🗺️

Um fluxo de trabalho sensato para um assistente de IA faça-você-mesmo com Raspberry Pi seria assim:

Palavra de ativação → captura de áudio ao vivo → transcrição ASR → tratamento de intenção ou LLM → texto de resposta → TTS → reprodução de áudio → ações opcionais via MQTT ou HTTP.

Palavra de ativação: Porcupine é pequeno, preciso e funciona localmente com controle de sensibilidade por palavra-chave. [2]
ASR: Whisper é um modelo ASR multilíngue de propósito geral treinado em ~680 mil horas; é robusto a sotaques/ruído de fundo. Para uso no dispositivo, whisper.cpp fornece um caminho de inferência C/C++ enxuto. [3][4]
Cérebro: Você escolhe – um LLM na nuvem via API, um mecanismo de regras ou inferência local, dependendo da capacidade de processamento.
TTS: Piper gera fala natural localmente, rápido o suficiente para respostas rápidas em hardware modesto. [5]

Tabela de comparação rápida 🔎

Ferramenta	Ideal para	Preço razoável	Por que funciona
Palavra de despertar do porco-espinho	Gatilho de escuta constante	Nível gratuito +	Baixo consumo de CPU, preciso, configurações fáceis [2]
Whisper.cpp	ASR local no Pi	Código aberto	Boa precisão, amigável à CPU [4]
Sussurro mais rápido	ASR mais rápido na CPU/GPU	Código aberto	Otimizações do CTranslate2
Piper TTS	Saída de voz local	Código aberto	Vozes rápidas, muitas línguas [5]
API Cloud LLM	Raciocínio rico	Com base no uso	Descarrega computação pesada
Node-RED	Ações de orquestração	Código aberto	Fluxos visuais, compatível com MQTT

Guia passo a passo para criar seu primeiro loop de voz 🧩

Usaremos o Porcupine para a palavra de ativação, o Whisper para a transcrição, uma função "cérebro" leve para a resposta (substitua pelo seu LLM preferido) e o Piper para a fala. Mantenha a configuração minimalista e, em seguida, faça iterações.

1) Instalar dependências

sudo apt install -y python3-pip portaudio19-dev sox ffmpeg pip3 install sounddevice numpy

Porcupine: obtenha o SDK/bindings para o seu idioma e siga o início rápido (tecla de acesso + lista de palavras-chave + quadros de áudio → .process). [2]
Whisper (otimizado para CPU): compile whisper.cpp:

clone o repositório https://github.com/ggml-org/whisper.cpp; acesse o diretório whisper.cpp; execute os seguintes comandos: `cmake -B build && cmake --build build -j ./models/download-ggml-model.sh base.en ./build/bin/whisper-cli -m ./models/ggml-base.en.bin -f your.wav -otxt`.

O exposto acima reflete o início rápido do projeto. [4]

Prefere Python? O faster-whisper (CTranslate2) costuma ser mais rápido que o Python puro em CPUs modestas.

2) Configurar o Piper TTS

git clone https://github.com/rhasspy/piper cd piper make # Baixe um modelo de voz de sua preferência, por exemplo, en_US-amy echo "Olá." | ./piper --model voices/en/en_US-amy-medium.onnx --output_file hello.wav aplay hello.wav

Piper foi projetado para TTS no dispositivo com várias opções de voz/idioma. [5]

3) Um laço auxiliar mínimo em Python

Deliberadamente compacto: aguarda uma frase de ativação (stub), grava, transcreve com whisper.cpp, gera uma resposta (placeholder) e então fala via Piper. Substitua o placeholder pela sua lógica de regras ou LLM favorita.

import os, subprocess, wave import sounddevice as sd WAKE_WORD = "hey computer" # troca por Porcupine em produção [2] RECORD_SECONDS = 6 SAMPLE_RATE = 16000 CHANNELS = 1 WORKDIR = "/home/pi/assistant" ASR_BIN = "/home/pi/whisper.cpp/build/bin/whisper-cli" # [4] ASR_MODEL = "/home/pi/whisper.cpp/models/ggml-base.en.bin" PIPER_BIN = "/home/pi/piper/build/piper" # [5] PIPER_VOICE = "/home/pi/piper/voices/en/en_US-amy-medium.onnx" os.makedirs(WORKDIR, exist_ok=True) def record_wav(path, seconds=RECORD_SECONDS): audio = sd.rec(int(segundos * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=CHANNELS, dtype='int16') sd.wait() with wave.open(path, 'wb') as w: w.setnchannels(CHANNELS); w.setsampwidth(2); w.setframerate(SAMPLE_RATE) w.writeframes(audio.tobytes()) def transcribe(path): cmd = [ASR_BIN, "-m", ASR_MODEL, "-f", path, "-otxt"] subprocess.run(cmd, check=True, cwd=WORKDIR) with open(path.replace(".wav", ".txt"), "r", encoding="utf-8") as f: return f.read().strip() def generate_reply(prompt): if "weather" in prompt.lower(): return "Não consigo ver as nuvens, mas pode estar tudo bem. Traga um casaco por precaução." return "Você disse: " + prompt def speak(text): proc = subprocess.Popen([PIPER_BIN, "--model", PIPER_VOICE, "--output_file", f"{WORKDIR}/reply.wav"], stdin=subprocess.PIPE) proc.stdin.write(text.encode("utf-8")); proc.stdin.close(); proc.wait() subprocess.run(["aplay", f"{WORKDIR}/reply.wav"], check=True) print("Assistente pronto. Digite a frase de ativação para testar.") while True: typed = input("> ").strip().lower() if typed == WAKE_WORD: wav_path = f"{WORKDIR}/input.wav" record_wav(wav_path) text = transcribe(wav_path) reply = generate_reply(text) print("Usuário:", text); print("Assistente:", reply) speak(reply) else: print("Digite a frase de ativação para testar o loop.")

Para detecção real de palavras-chave de ativação, integre o detector de fluxo do Porcupine (baixo uso de CPU, sensibilidade por palavra-chave). [2]

Ajustes de áudio que realmente fazem a diferença 🎚️

Algumas pequenas alterações podem fazer seu assistente parecer 10 vezes mais inteligente:

Distância ideal do microfone: 30–60 cm é o ponto ideal para muitos microfones USB.
Níveis: evite distorção na entrada e mantenha a reprodução estável; corrija o roteamento antes de tentar resolver problemas no código. No Raspberry Pi OS, você pode gerenciar o dispositivo de saída e os níveis por meio de ferramentas do sistema ou raspi-config. [1]
Acústica da sala: paredes duras causam eco; um tapete macio sob o microfone ajuda.
Limiar de palavra-chave: muito sensível → acionamentos fantasmas; muito restritivo → você vai ficar gritando com plástico. O Porcupine permite ajustar a sensibilidade por palavra-chave. [2]
Térmica: transcrições longas no Pi 5 se beneficiam do cooler ativo oficial para desempenho sustentado. [1]

De brinquedo a eletrodoméstico: serviços, inicialização automática, verificações de saúde 🧯

Humanos esquecem de executar scripts. Computadores esquecem de ser gentis. Transforme seu loop em um serviço gerenciado:

Criar uma unidade systemd:

[Unit] Description=Assistente de Voz Faça Você Mesmo After=network.target sound.target [Service] User=pi WorkingDirectory=/home/pi/assistant ExecStart=/usr/bin/python3 /home/pi/assistant/assistant.py Restart=always RestartSec=3 [Install] WantedBy=multi-user.target

Ative-o:

sudo cp assistant.service /etc/systemd/system/ sudo systemctl daemon-reload sudo systemctl enable --now assistant.service

Caudas de toras:

journalctl -u assistente -f

Agora ele inicia na inicialização do sistema, reinicia em caso de falha e, em geral, se comporta como um eletrodoméstico. Um pouco entediante, mas muito melhor.

Sistema de Habilidades: Torne-o Realmente Útil em Casa 🏠✨

Assim que a entrada e a saída de voz estiverem estabilizadas, adicione as seguintes ações:

Roteador de intenções: rotas simples baseadas em palavras-chave para tarefas comuns.
Casa inteligente: publique eventos no MQTT ou chame os endpoints HTTP do Home Assistant.
Plugins: funções rápidas em Python como set_timer, what_is_the_time, play_radio, run_scene.

Mesmo com um LLM na nuvem envolvido, priorize o roteamento de comandos locais óbvios para maior velocidade e confiabilidade.

Somente local vs. Assistência na nuvem: as vantagens e desvantagens que você sentirá 🌓

Apenas local.
Prós: privado, offline, custos previsíveis.
Contras: modelos mais pesados podem ser lentos em placas pequenas. O treinamento multilíngue do Whisper ajuda na robustez se você o mantiver no dispositivo ou em um servidor próximo. [3]

do Cloud Assist
: raciocínio poderoso, janelas contextuais maiores.
Desvantagens: os dados saem do dispositivo, dependência da rede, custos variáveis.

Uma abordagem híbrida costuma ser a melhor: palavra de ativação + ASR local → chamada de API para raciocínio → TTS local. [2][3][5]

Solução de problemas: Problemas estranhos e correções rápidas 👾

Disparos falsos da palavra de ativação: diminua a sensibilidade ou tente um microfone diferente. [2]
Atraso ASR: use um modelo Whisper menor ou compile whisper.cpp com flags de lançamento (-j --config Release). [4]
TTS intermitente: pré-gere frases comuns; confirme seu dispositivo de áudio e taxas de amostragem.
Nenhum microfone detectado: verifique arecord -l e os mixers.
Limitação térmica: use o Active Cooler oficial no Pi 5 para desempenho sustentado. [1]

Avisos sobre segurança e privacidade que você realmente deveria ler 🔒

Mantenha seu Raspberry Pi atualizado com o APT.
Se você usar alguma API na nuvem, registre o que enviar e considere ocultar primeiro os dados pessoais localmente.
Execute os serviços com privilégios mínimos; evite usar sudo em ExecStart, a menos que seja necessário.
Disponibilize um modo somente local para convidados ou em horários de silêncio.

Variantes de Montagem: Misture e Combine como um Sanduíche 🥪

Ultralocal: Porcupine + whisper.cpp + Piper + regras simples. Privado e robusto. [2][4][5]
Assistência rápida na nuvem: Porcupine + (Sussurro local menor ou ASR na nuvem) + TTS local + LLM na nuvem.
Central de automação residencial: Adicione fluxos do Node-RED ou do Home Assistant para rotinas, cenas e sensores.

Exemplo de habilidade: Ligar as luzes via MQTT 💡

import paho.mqtt.client as mqtt MQTT_HOST = "192.168.1.10" TOPIC = "home/livingroom/light/set" def set_light(state: str): client = mqtt.Client() client.connect(MQTT_HOST, 1883, 60) payload = "ON" if state.lower().startswith("on") else "OFF" client.publish(TOPIC, payload, qos=1, retain=False) client.disconnect() # if "turn on the lights" in text: set_light("on")

Adicione uma frase de voz como: "acenda a lâmpada da sala de estar", e você se sentirá um mago.

Por que essa combinação funciona na prática 🧪

Porcupine é eficiente e preciso na detecção de palavras de ativação em placas pequenas, o que torna viável a escuta contínua. [2]
O amplo treinamento multilíngue do Whisper o torna robusto para ambientes e sotaques variados. [3]
whisper.cpp mantém esse poder utilizável em dispositivos somente com CPU, como o Pi. [4]
Piper mantém as respostas rápidas sem enviar áudio para um TTS na nuvem. [5]

Muito longo, não li.

Construa um assistente de IA modular e privado com Raspberry Pi , combinando o Porcupine para palavra de ativação, o Whisper (via whisper.cpp ) para reconhecimento automático de fala (ASR), o algoritmo de sua escolha para respostas e o Piper para síntese de voz local. Empacote-o como um serviço systemd, ajuste o áudio e integre ações MQTT ou HTTP. É mais barato do que você imagina e surpreendentemente agradável de usar. [1][2][3][4][5]

Referências

Software e refrigeração para Raspberry Pi – Informações sobre o Raspberry Pi Imager (download e uso) e o Pi 5 Active Cooler.
- Raspberry Pi Imager: leia mais
- Resfriador ativo (Pi 5): leia mais
Palavra-chave de despertar do Porcupine – SDK e guia de início rápido (palavras-chave, sensibilidade, inferência local)
- Leia mais
Whisper (modelo ASR) – ASR multilíngue e robusto, treinado com aproximadamente 680 mil horas de treinamento.
- Radford et al., Reconhecimento de fala robusto via supervisão fraca em larga escala (Whisper): leia mais
whisper.cpp – Inferência Whisper otimizada para CPU com linha de comando e etapas de compilação
- Leia mais
Piper TTS – TTS neural local e rápido com múltiplas vozes/idiomas
- Leia mais

Encontre as últimas novidades em IA na Loja Oficial de Assistentes de IA

Sobre nós

Voltar ao blog