Privacy Tools Guide

How to Replace Google Home with Local Voice Assistant Using Rhasspy or Mycroft

Replace Google Home with Rhasspy or Mycroft to process voice commands entirely on your local hardware without cloud connectivity. Both open-source alternatives offer full voice assistant capabilities, custom wake words, and integration with home automation systems—all running privately on modest hardware like a Raspberry Pi. This guide walks through installing, configuring, and deploying each solution with practical examples for developers and power users.

Why Go Local?

Before diving into implementation, understanding the benefits of local voice processing matters. When you use Google Home, your voice recordings may be stored indefinitely, used to improve Google’s AI models, and potentially accessed by third parties through legal requests. Local voice assistants process audio entirely within your network—your conversations never leave your home.

Beyond privacy, local assistants offer customization freedom. You can modify wake words, add custom commands, integrate with self-hosted services, and run everything on modest hardware like a Raspberry Pi.

The privacy implications of cloud voice assistants deserve emphasis. Google Home sends every voice interaction—including recordings before and after the wake word—to Google’s servers for processing. Google has acknowledged retaining some recordings for quality review by human contractors. Amazon Alexa operates similarly. Research has shown these devices occasionally activate on false wake words, sending unintended audio to the cloud. A local assistant eliminates this entirely: audio is processed on your hardware, by software you control, and never transmitted anywhere.

Rhasspy: The Developer-Friendly Option

Rhasspy (pronounced “raspy”) is a privacy-first, offline voice assistant toolkit designed for developers who want complete control. It supports multiple speech-to-text engines, natural language understanding systems, and text-to-speech outputs—all running locally.

Hardware Requirements

A Raspberry Pi 4 with 4GB RAM handles basic wake word detection and command processing. For faster response times, consider a desktop PC or server-grade hardware. Rhasspy also supports Docker, making deployment straightforward on any system.

Installation

The simplest getting-started method uses Docker:

# Create directories for Rhasspy configuration
mkdir -p ~/rhasspy/{profiles,scripts}

# Run Rhasspy with Docker
docker run -d \
  --name rhasspy \
  --restart unless-stopped \
  -p 12101:12101 \
  -v ~/rhasspy/profiles:/profiles \
  --device /dev/snd:/dev/snd \
  rhasspy/rhasspy

After starting the container, access the web interface at http://localhost:12101.

Configuration Steps

Rhasspy requires configuring three core components: wake word, speech-to-text, and intent recognition.

Wake Word: Rhasspy includes Precise built-in, a neural network wake word detector. In the web interface, select “Precise” under Wake Word, then download the default “Hey Mycroft” model or train your own custom wake word using collected audio samples.

Speech-to-Text: For local transcription, use Pocketsphinx or Whisper. Whisper provides superior accuracy but requires more processing power:

{
  "speech_to_text": {
    "system": "whisper",
    "whisper": {
      "model": "base",
      "device": "cpu"
    }
  }
}

Intent Recognition: Mycroft Core’s Adapt engine works well for rule-based commands. For more complex natural language, consider integrating with local LLM endpoints.

Creating Voice Commands

Define intents in JSON files within your profile:

{
  "name": "TurnOnLights",
  "sentences": [
    "turn on the {room} lights",
    "switch on {room} lighting",
    "lights on in {room}"
  ],
  "slots": {
    "room": ["living room", "bedroom", "kitchen", "bathroom"]
  }
}

Rhasspy parses these sentences and extracts the room entity, then sends the intent to your home automation system via MQTT, HTTP, or direct command execution.

Connecting Rhasspy to Home Assistant

Rhasspy integrates natively with Home Assistant through the Rhasspy Home Assistant integration. Configure the connection in Rhasspy’s profile settings:

{
  "handle": {
    "system": "hass",
    "hass": {
      "url": "http://homeassistant.local:8123",
      "access_token": "YOUR_LONG_LIVED_ACCESS_TOKEN",
      "event_type": "rhasspy_intent"
    }
  }
}

Then in Home Assistant, create an automation that listens for these events:

automation:
  - alias: "Handle Rhasspy TurnOnLights intent"
    trigger:
      platform: event
      event_type: rhasspy_intent
      event_data:
        intent:
          name: TurnOnLights
    action:
      service: light.turn_on
      target:
        area_id: "{{ trigger.event.data.slots.room }}"

This keeps the entire voice pipeline local: microphone input → Rhasspy wake word detection → local STT → local intent parsing → Home Assistant automation → device control.

Mycroft provides a more complete out-of-the-box experience compared to Rhasspy. It includes its own voice AI (Precise), STT engine (Precise STT), TTS system ( Mimic), and the Adapt intent parser—all pre-integrated.

Installation

Mycroft offers a dedicated Raspberry Pi image called “Picroft”:

# For manual installation on Debian/Ubuntu
git clone https://github.com/MycroftAI/mycroft-core.git
cd mycroft-core
bash dev_setup.sh

After installation, run the core:

./start-mycroft.sh all

The CLI interface appears at http://localhost:8181.

Skills Development

Mycroft uses a skill-based architecture. Each skill handles specific domains—smart home control, music playback, weather queries. Creating custom skills follows a clear pattern:

from mycroft import MycroftSkill

class HomeLightsSkill(MycroftSkill):
    def __init__(self):
        MycroftSkill.__init__(self)

    def initialize(self):
        self.register_intent_file('turn.on.lights.intent',
                                   self.handle_turn_on)

    def handle_turn_on(self, message):
        room = message.data.get('room')
        # Your home automation logic here
        self.speak(f"Turning on {room} lights")

def create_skill():
    return HomeLightsSkill()

The intent file defines sentence patterns:

turn on the {room} lights
switch on {room} light
lights on in {room}

Integration with Home Automation

Mycroft communicates with home automation systems through standardized protocols. The Mycroft Home Assistant skill provides native Home Assistant integration:

# Install via Mycroft marketplace
mycroft-pip install mycroft-home-assistant

Configuration in ~/.mycroft/mycroft.conf:

{
  "homeassistant": {
    "host": "http://localhost:8123",
    "token": "YOUR_LONG_LIVED_ACCESS_TOKEN"
  }
}

Comparing Rhasspy and Mycroft

Feature Rhasspy Mycroft
Setup Complexity Moderate Higher
Customization Highly flexible Skill-based
Resource Usage Lighter More demanding
Documentation Good Extensive
Community Active Larger
STT Engine Options Multiple (Whisper, Kaldi, Vosk) Primarily Precise STT
Wake Word Training Built-in Precise trainer Precise, custom models
MQTT Support Native Via plugin

Choose Rhasspy if you want granular control over every component and are comfortable with Docker-based deployments. Choose Mycroft if you prefer a more integrated system with easier third-party skill installation.

OpenWakeWord: A Newer Alternative for Wake Word Detection

For users who find training wake words in Rhasspy cumbersome, OpenWakeWord (compatible with both Rhasspy and Home Assistant’s Wyoming protocol) offers pre-trained models for dozens of phrases and a simpler training pipeline for custom phrases. It runs on a Raspberry Pi 4 with under 5% CPU utilization, making it viable as a dedicated always-listening microphone node that forwards detected wake words to a more powerful processing machine on the same network.

Performance Optimization

Regardless of your choice, several optimizations improve responsiveness:

Use a dedicated microphone array instead of USB microphones. The ReSpeaker series offers far-field capture that detects wake words from across the room.

Run heavy processing on a networked server. Offload Whisper transcription or intent parsing to a more powerful machine while keeping the wake word detector local for instant response.

Implement caching. Store frequent command patterns and pre-computed responses to reduce processing latency.

Select the right Whisper model size. Whisper comes in five sizes (tiny, base, small, medium, large). For English-only home automation commands, the base.en model gives roughly 90% accuracy of the full model at 4x the speed. On a Raspberry Pi 4:

Separate the wake word node from the processing node. Run a lightweight wake word detector (OpenWakeWord on a Pi Zero 2W) near your microphone, and send audio snippets over the local network to a more powerful machine running Whisper. This keeps the physical microphone device inexpensive and power-efficient while maintaining accurate transcription.

Network Isolation

Local voice assistants should be isolated on your network like any other IoT device. Even though Rhasspy and Mycroft don’t call home, their MQTT brokers and HTTP APIs should not be exposed to the internet or other untrusted network segments:

# Firewall rules to restrict Rhasspy web UI access to local subnet only
# On the host running Rhasspy:
sudo iptables -A INPUT -p tcp --dport 12101 -s 192.168.1.0/24 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 12101 -j DROP

For MQTT broker security, require authentication even on your local network. Add user credentials to Mosquitto’s configuration and configure Rhasspy to authenticate:

# /etc/mosquitto/mosquitto.conf
listener 1883 127.0.0.1
allow_anonymous false
password_file /etc/mosquitto/passwords

Built by theluckystrike — More at zovo.one

Explore Our Developer Guides

© 2026 theluckystrike Developer Guides