简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Rhasspy?
Rhasspy is an open-source, fully offline set of voice assistant services for many human languages. You define voice commands in a template language, and Rhasspy turns recognized speech into JSON events that trigger actions in home automation software. It is designed to work with Home Assistant and Hass.io, Node-RED, Jeedom, OpenHAB, and services compatible with the Hermes protocol (such as Snips.AI), communicating over MQTT, HTTP, and WebSockets.
What it is good for
Rhasspy is strongest when you have a known set of commands that can be described with a grammar—for example, a phrase like [LightState] states = (on | off) turn (){state} [the] light produces an event with the intent LightState and the slot state: "on". That makes it a practical fit for a home automation setup where you want local control and predictable intent recognition rather than open-ended conversation. It also supports open-ended speech recognition and lets you add uncommon words phonetically with automated assistance.
It is less suited to someone who wants a general-purpose conversational assistant out of the box; the emphasis is on pre-specified commands and integration with external automation services.
How you would use it
A typical path, per the project's own getting-started steps, is: confirm your hardware, choose an installation method, open the web interface to download a profile, author and train your custom voice commands, then connect Rhasspy to Home Assistant or a Node-RED flow via MQTT, the HTTP API, or a WebSocket. The web interface lets you configure, program, and test the assistant remotely from a browser, and all of its functionality is exposed through the HTTP API.
As a next step, decide whether your use case is a fixed command set (where Rhasspy's grammar approach fits well) or open-ended speech, then check the supported languages and installation options for your hardware. The official documentation is at Rhasspy.
How do I install Rhasspy on my device?
Rhasspy is installed by choosing one of its supported installation methods for your device, then opening its web interface to download a profile and train your voice commands. The project's own getting-started sequence is: confirm you have the necessary hardware, pick an installation method, access the web interface, author custom voice commands, and connect Rhasspy to software such as Home Assistant or Node-RED.
What that means in practice
- Hardware first. Rhasspy needs audio input and output plus a microphone/speaker setup; confirm what your device provides before installing, since a headless box may need a USB microphone and speaker.
- Pick the method that matches your device. The documentation lists several installation options (for example, container-based or device-specific images). Choose the one written for your hardware rather than adapting instructions for a different platform.
- Use the web interface for setup. After installation, Rhasspy is configured remotely from a browser: you download a profile, define commands in its template language, and train the assistant. The same functions are available through its HTTP API if you prefer scripting.
- Connect it last. Once commands work locally, wire Rhasspy into Home Assistant, Node-RED, or another tool via MQTT (Hermes messages), HTTP, or WebSockets.
A concrete example
A typical first command looks like this in Rhasspy's template language:
[LightState]
states = (on | off)
turn (){state} [the] light
Saying "turn on the light" produces a JSON event with the intent LightState and the slot state: on, which a Node-RED flow or Home Assistant automation can act on.
Decision criterion
If you want a fully offline assistant with tight Home Assistant integration and grammar-based commands, follow the official getting-started guide at Rhasspy and match the installation method to your exact device; if your hardware isn't listed, check the community forum before improvising, since audio and wake-word support vary by platform.
Can Rhasspy work fully offline without sending data to the cloud?
Yes. Rhasspy is described as an open source, fully offline set of voice assistant services, so its core speech and intent pipeline is designed to run on your own hardware without sending voice data to a cloud service.
What "offline" means in practice
- Processing stays local: wake word, speech-to-text, intent recognition, and text-to-speech are listed as services you run yourself. A typical setup puts them on a small local server such as a Raspberry Pi or a home server.
- Commands are defined locally: you write voice commands in a template language, and Rhasspy turns them into JSON events. For example, a command like "turn on the light" produces an intent event with a name and slot values that your automation software can act on.
- Integration is local-network based: Rhasspy is built around MQTT, HTTP, and WebSockets, and works with Home Assistant, Node-RED, openHAB, and Jeedom. These connections can run entirely on your home network.
Where "fully offline" needs a caveat
Offline processing does not mean no network traffic ever. Two practical points:
- You still need a network for setup and control. The web interface and HTTP API are accessed over your network, and MQTT messages travel between local devices. That is local traffic, not cloud traffic, but it is traffic.
- Optional external services can change the picture. Rhasspy supports Hermes-compatible services and external integrations; if you deliberately connect a cloud speech or intent service, data leaves your network. Staying offline depends on choosing local services for each stage of the pipeline.
A concrete scenario
A household wants voice control for lights and heating but does not want audio recordings leaving the house. They install Rhasspy on a local machine, define a small grammar for the commands they actually use ("turn on the kitchen light"), and connect it to Home Assistant over the local network. Recognition is limited to the phrases they authored, which keeps accuracy high for those commands and avoids sending audio anywhere.
Decision criteria
Choose Rhasspy's offline approach if privacy, no subscription dependency, and control over your own data matter most, and you are comfortable specifying commands rather than expecting open-ended conversation. If you need broad, unscripted natural-language understanding with minimal setup, a cloud-based assistant will generally handle that more easily, at the cost of sending audio off-site. Rhasspy does support open-ended recognition and adding uncommon words phonetically, so the trade-off is about effort and accuracy, not a hard capability limit.
Next step: read the Getting Started Guide on Rhasspy and check the supported languages list before committing, since language coverage affects which local speech-to-text options you can use.
How do I connect Rhasspy to Home Assistant or Node-RED?
Connect Rhasspy to Home Assistant or Node-RED by sending its JSON intent events over MQTT (Hermes protocol), the HTTP API, or a WebSocket. Rhasspy is built for this: it emits a JSON event per recognized command, and Home Assistant, Node-RED, Jeedom and OpenHAB can act on it.
How the event looks
You define commands in Rhasspy's template language, for example:
[LightState]
states = (on | off)
turn (){state} [the] light
Rhasspy then produces:
{
"text": "turn on the light",
"intent": { "name": "LightState" },
"slots": { "state": "on" }
}
Choosing a connection method
| Method | Best for | Trade-off |
|---|---|---|
| MQTT / Hermes | Home Assistant, Node-RED and other Hermes-compatible tools; multiple consumers at once | Needs a broker; you subscribe to topics rather than calling directly |
| HTTP API | Scripts or services that poll or call on demand | You handle requests yourself; less natural for push-style events |
| WebSocket | Live event streams into a custom app or Node-RED | You manage the connection and reconnects |
Home Assistant
Home Assistant and Hass.io have built-in support, so the MQTT route is the usual choice: point Rhasspy at your broker and let Home Assistant react to the intent events. You still write the automation (for example, an intent named LightState with slot state mapped to a light service call); Rhasspy supplies the parsed command, not the device logic.
Node-RED
Subscribe to Rhasspy's MQTT messages in an MQTT-in node, or open a WebSocket, then branch on intent.name and use slots.state in a switch or service node. The web interface's test area lets you confirm the JSON before wiring the flow.
Practical next step
Start with one command, such as the light example, and confirm the JSON in the Rhasspy web interface. Then connect it through MQTT to a single automation or flow. If you later need several consumers or non-Hermes tools, the HTTP API and WebSocket options cover those cases; the Getting Started Guide and community forum at Rhasspy cover installation and profiles.
Which languages does Rhasspy support?
Rhasspy describes itself as supporting "many human languages," but the supplied page information does not list them. The page has a "Supported Languages" section, yet its text is cut off before any languages appear, so no specific list can be given here.
What the page does make clear is that language support is a core part of Rhasspy's design: it is described as an offline voice assistant service for many human languages, and its command templates and phonetic word additions are meant to be adapted to the language you use.
How to check before committing
- Open the "Supported Languages" section on the Rhasspy documentation site and confirm your language is listed.
- Check whether your language has the pieces you need: speech-to-text, text-to-speech, and intent recognition may not all cover the same set of languages.
- If you plan to use uncommon words or names, verify that phonetic word addition works for your language's pronunciation rules.
For a concrete case: if you want voice control in, say, German or French for a Home Assistant setup, confirm that language appears in that section and that the relevant speech services are available for it before installing a profile.
How do I write custom voice commands using Rhasspy's template language?
You write custom commands in Rhasspy's sentence-template language: define a sentence with named slots, and Rhasspy generates matching JSON events. The page shows the pattern directly:
[LightState] states = (on | off)
turn (){state} [the] light
This produces an event like:
{
"text": "turn on the light",
"intent": { "name": "LightState" },
"slots": { "state": "on" }
}
Reading the syntax
[IntentName]— the bracketed label at the top names the intent that the JSON event will carry.states = (on | off)— a named list of alternatives; any value in the group can fill the slot.turn (){state} [the] light— the sentence itself.(){state}inserts the slot at that position, and[the]marks an optional word the speaker may or may not say.()— an empty group, as in the example, appears to act as a placeholder the slot fills.
The result is that "turn on the light" and "turn off the light" both match, with the spoken value captured in slots.state.
A practical next step
Write one intent per action you actually use — lights, a thermostat, a media player — and keep slot values short and distinct so recognition stays reliable. Then connect the events to your automation: Rhasspy is built to work with Home Assistant and Hass.io (which have built-in support), Node-RED, OpenHAB, Jeedom, and Hermes-compatible services, sending events over MQTT, HTTP, or WebSockets. A Node-RED flow listening for LightState with slots.state == "on" is the simplest end-to-end test.
When templates fit, and when they don't
Rhasspy is optimized for pre-specified commands described well by a grammar, which is exactly what this template approach gives you: fast, predictable matching for a fixed vocabulary. The page notes you can also do open-ended speech recognition, and that uncommon words or pronunciations can be added phonetically with automated assistance — useful if a device name keeps getting misheard.
For a concrete scenario: someone automating a single room might define five or six intents with tight slot lists and get very dependable results; someone wanting free-form conversation across many topics will find the grammar approach more work, since every phrasing has to be anticipated.
Getting it running
The documented flow is: confirm your hardware, choose an installation method, open the web interface to download a profile, author and train your commands, then connect to Home Assistant or Node-RED. The web interface lets you configure, program, and test remotely from a browser, and the same functions are exposed through an HTTP API. If you get stuck, the page points to the Rhasspy community site and GitHub issues. The project's own documentation at Rhasspy includes a Getting Started Guide and a whitepaper explaining the design.
Cloudflare
Google Workspace
User reviews (0)