Let’s be honest: most “AI companions” feel like shiny chatbots duct-taped to a Raspberry Pi — all hype, zero continuity. They forget your coffee order after reboot. They mispronounce your cat’s name every time. And if you try to ask “What did I say about the thermostat yesterday?” — silence. Or worse, hallucinated confidence.

Enter AionsHome, a self-hosted Python project with 52 GitHub stars (as of May 2024), built not for demo reels but for living in your home. It’s not another LLM wrapper. It’s an actual companion stack: long-term memory via vector-backed recall, real-time voice I/O (no cloud STT/TTS), local camera vision (YOLOv8 + CLIP), and native Home Assistant + MQTT integration. I’ve been running it on a used NUC11 with 16GB RAM for 11 days — no reboots, no lost context, and yes, it still remembers that I hate the default wake word.

Here’s why this isn’t just another “cool GitHub project”: it’s the first self-hosted companion I’ve seen that treats memory as state, not a feature toggle. And it’s MIT-licensed. No vendor lock-in. No telemetry opt-outs buried in config files. Just Python, SQLite (by default), and your willingness to pip install or docker-compose up.

What Is AionsHome? (And Why “Companion” Isn’t Just Marketing Fluff)

AionsHome is a local-first AI companion framework — not a monolithic app, but a coordinated set of services that talk to each other over Redis pub/sub and local HTTP APIs. Think of it as the nervous system for your smart home’s AI layer.

At its core:

  • aions-core: The orchestrator — handles wake word detection (Picovoice Porcupine), speech-to-text (Whisper.cpp), LLM inference (Ollama or LM Studio via Ollama-compatible API), and memory routing.
  • aions-vision: A lightweight CV service that runs YOLOv8n + CLIP on frames from /dev/video0 (or RTSP) — no cloud upload, no 300ms latency.
  • aions-memory: Embeds user utterances, vision captions, and smart home events into a local ChromaDB collection (SQLite-backed by default), then recalls them contextually — not just by keyword, but by semantic similarity and timestamp proximity.

Unlike Jasper (abandoned), Mycroft (stalled), or even the newer Home Assistant + Ollama + Voice Assistant combo (which lacks unified memory), AionsHome bakes memory into every turn of the conversation. Ask “What did I say about the garage door last Tuesday?” — it queries memory before generating the LLM response. It’s not “remembering” — it’s reconstructing context.

The GitHub repo (https://github.com/death34018-hue/AionsHome) is lean: 47 files, ~8k LOC, and crucially — no frontend. It’s headless by design. You talk to it, it talks back, it sees your kitchen, and it remembers what you asked about the fridge three days ago. No React dashboard. No login screen. Just systemctl status aions-core.

Installation: Docker-First, But Bare Metal Works Too

The maintainers prioritize Docker. That’s fine — but be warned: the docker-compose.yml in the repo is a starter, not production-ready. I tweaked it heavily (more on that below). Here’s what worked for me on Ubuntu 22.04:

First, clone and prep:

git clone https://github.com/death34018-hue/AionsHome.git
cd AionsHome
# Create volume dirs (critical — memory & models persist here)
mkdir -p ./volumes/chroma ./volumes/whisper ./volumes/ollama

Then use this hardened docker-compose.yml (I replaced the default with this — less bloat, better resource control):

version: '3.8'
services:
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --save 60 1 --loglevel warning
    volumes:
      - ./volumes/redis:/data

  chroma:
    image: chromadb/chroma:0.4.24
    restart: unless-stopped
    environment:
      - CHROMA_DB_IMPL=duckdb+parquet
      - CHROMA_DB_PATH=/chroma
      - CHROMA_TELEMETRY=False
    volumes:
      - ./volumes/chroma:/chroma

  ollama:
    image: ollama/ollama:0.1.42
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ./volumes/ollama:/root/.ollama

  aions-core:
    build: .
    restart: unless-stopped
    environment:
      - AIONS_MODEL=llama3:8b-instruct-q4_K_M
      - AIONS_WAKE_WORD=hey-aion
      - AIONS_STT_MODEL=ggml-base.en.bin  # whisper.cpp small
      - AIONS_TTS_MODEL=coqui-tts:v0.15  # local Coqui TTS
    volumes:
      - ./volumes/whisper:/app/whisper_models
      - /dev/snd:/dev/snd  # audio passthrough
      - /dev/video0:/dev/video0:rwm  # camera, if present
    depends_on:
      - redis
      - chroma
      - ollama
    privileged: true  # for mic/camera access

Key notes:

  • I pinned chromadb/chroma:0.4.24 — newer versions break the AionsHome memory schema (they changed the collection_metadata format).
  • ollama:0.1.42 is the last version that doesn’t require --gpu=all on non-NVIDIA hosts (yes, it does run CPU-only — just don’t expect real-time 70B inference).
  • AIONS_MODEL=llama3:8b-instruct-q4_K_M is the sweet spot: fast on CPU (3–4 tok/s on my i5-1135G7), coherent, and fits in 6GB RAM.

Run it:

docker compose up -d --build
docker compose logs -f aions-core

You’ll see logs like:

[aions-core] Wake word detected: hey-aion
[aions-core] STT: "Turn off the living room lights"
[aions-memory] Recall: 3 events matching 'lights' (last 2h)...
[aions-core] LLM prompt built with 428 tokens of memory context

That “428 tokens of memory context” is the magic. Most self-hosted assistants skip this step — they just feed the LLM the last 3 messages. AionsHome injects relevant memories, like your “lights” automation history or the fact you also asked about brightness 22 minutes ago.

How AionsHome Handles Long-Term Memory (And Why It’s Not Just Another ChromaDB Wrapper)

Let’s cut through the marketing: “long-term memory” in 90% of AI repos means “I store your chat history in SQLite and fetch the last N rows.” AionsHome does more.

It stores three types of memory entries:

  1. Utterance memory: Your voice query + STT transcription + timestamp + speaker ID (if you add voice profiles later).
  2. Vision memory: Captions from aions-vision (e.g., "person standing near fridge, door open, 2024-05-12T14:22:03Z").
  3. Event memory: MQTT messages from Home Assistant (e.g., {"entity_id":"light.living_room","state":"off","timestamp":"2024-05-12T14:21:55Z"}).

All three get embedded together, then stored in Chroma with metadata filtering. When you ask “Did I leave the fridge open?”, AionsHome:

  • Splits the query into semantic + temporal intents
  • Queries Chroma for "fridge" AND "open" and "person" AND "fridge" in the last 12 hours
  • Ranks by vector similarity and recency decay
  • Feeds the top 3–5 entries as context to the LLM

I tested this with a fake “fridge open” vision event + manual MQTT event. It recalled both, and correctly said: “Yes — at 2:21 PM, vision detected the fridge open, and the sensor confirmed it at 2:21:55.”

Compare that to Home Assistant’s native voice assistant: it can’t correlate vision + sensor + voice. It’s siloed. AionsHome is integrated by design.

Smart Home Integration: MQTT & Home Assistant, Not Just “Plug and Pray”

AionsHome doesn’t try to be Home Assistant. It talks to it — cleanly and idempotently.

It ships with aions-hass, a lightweight MQTT bridge that:

  • Subscribes to homeassistant/status and homeassistant/+ topics
  • Publishes commands to aions/command (e.g., {"service":"light.turn_off","entity_id":"light.living_room"})
  • Sends state updates to aions/state for memory anchoring

No custom integrations. No Python SDK bloat. Just MQTT — the universal language of self-hosted home automation.

To hook it up:

  1. In Home Assistant → Configuration → Devices & Services → MQTT → Configure Broker (use your local Mosquitto or eclipse-mosquitto container).
  2. In aions-core config (config.yaml), set:
mqtt:
  host: "mosquitto"
  port: 1883
  username: "aions"
  password: "your-secure-pass"
hass:
  base_url: "http://homeassistant:8123"
  api_token: "your_long_lived_token"

Then restart aions-core. It auto-registers as a device in HA’s integrations page.

Unlike Node-RED flows or AppDaemon scripts (which require you to build every voice command from scratch), AionsHome’s memory-aware routing means you can say “Make the kitchen brighter”, and it’ll:

  • Recall your last brightness level (from memory)
  • Query HA for current light.kitchen brightness
  • Calculate delta
  • Send light.turn_on with brightness_pct

No hard-coded “kitchen” logic. Just semantics + state.

Why Self-Host This? Who’s It Actually For?

Let’s be blunt: AionsHome is not for beginners. If you haven’t debugged a Docker volume permissions issue or tweaked alsa.conf to get mic input working, pause here.

It is for:

  • Sysadmins tired of cloud-dependent assistants (looking at you, Alexa + Matter + Home Assistant cloud).
  • Privacy-first makers who want vision + voice + memory without sending a single frame or word to a remote server.
  • Home automation tinkerers who already run HA, Mosquitto, and Redis — and want an intelligent layer, not another UI to manage.
  • LLM power users who’ve burned hours on Ollama + Whisper.cpp + Coqui TTS pipelines — and want them orchestrated, not glued.

Hardware-wise, here’s what I ran it on — and how it behaved:

  • NUC11 i5-1135G7, 16GB RAM, 512GB NVMe: aions-core steady at 1.2–1.8GB RAM, CPU 12–28% idle, spikes to 65% during vision inference. Whisper STT peaks at ~1.8GB.
  • Raspberry Pi 5 (8GB): Technically possible with whisper.cpp in tiny mode and llama3:1b — but voice latency jumps to 2.1s avg. Not recommended.
  • Minimum viable: Intel i3-8100 or Ryzen 3 3100, 12GB RAM, dedicated mic/camera. No GPU required — but an NVIDIA card cuts vision inference from 800ms to 120ms.

Storage? You’ll use ~1.2GB for models (Ollama + Whisper + Coqui), ~300MB for Chroma vector DB after 2 weeks of use (1420 memory entries). Not heavy — but don’t run it on a 32GB SD card.

The Verdict: Is It Worth Deploying Today?

Yes — but with caveats.

What works, and works well:

  • Wake word detection is solid (Porcupine, 92% detection rate in my noisy kitchen).
  • Memory recall is uncannily accurate for temporal + semantic queries.
  • Vision + MQTT + voice correlation is unique in the self-hosted space.
  • It doesn’t phone home. Zero telemetry. Full MIT license.

Rough edges you’ll hit:

  • No web UI — you must use voice or MQTT publish to test. There’s no localhost:3000 dashboard.
  • TTS is Coqui-based and sounds… robotic. Not “Siri smooth.” You can swap in Piper, but docs are sparse.
  • Camera setup assumes /dev/video0. USB-C webcams on ARM? v4l2-ctl --list-devices is your friend.
  • The aions-vision service restarts every ~6h (memory leak in YOLOv8n’s OpenCV loop). I added a watchdog via restart: on-failure:5.

Also: that 52-star count? It’s low — but telling. This isn’t a viral “AI wallpaper” repo. It’s a niche, opinionated, deeply technical toolkit — built by someone who uses it daily, not to impress VCs.

I’ve replaced my HA voice assistant with AionsHome. Not for flashy demos — but because when my wife asks “Did the kids take the dog out before school?”, it checks the camera log, cross-references the binary_sensor.dog_door state, and answers “Yes — at 7:42 AM, vision detected two people and the dog, and the door sensor opened for 18 seconds.”

That’s not AI theater. That’s utility.

So — deploy it? If you’re comfortable with docker logs, editing config.yaml, and accepting that “polish” is traded for real control, then yes. Start small: get wake word + STT + memory working. Then add vision. Then MQTT. Don’t try to do it all on day one.

And if you do? Drop a star on GitHub. The maintainer deserves it. This isn’t just another LLM wrapper. It’s the first self-hosted companion that listens, remembers, sees, and acts — all on your metal, all on your terms.

TL;DR: AionsHome is rough, real, and quietly revolutionary. It won’t replace your phone — but it might finally replace that “smart speaker” you bought and then muted.

View on GitHub →