HomeHoard 📦

HomeHoard is my own personal rewrite of homebox.

I love what homebox does, but I wanted three things it didn't give me, so I rebuilt it from the ground up in Python:

1. Home Assistant, done properly. HomeHoard runs as a first-class HA add-on (one-click install, Ingress, no separate login) and ships a companion HACS integration with inventory sensors, a warranties/maintenance calendar, voice intents ("where is my drill?", "check out the drill", "what's in the garage?"), homehoard.locate / check_out / check_in / contents services for notifications & automations, and an in-container MCP server so an LLM-powered Assist can do everything except adding or deleting items — search, check in/out, and even edit or move things.
2. QR codes and barcodes that actually fit my life. Generate printable QR labels and register your own existing QR labels or product barcodes (UPC/EAN), stick as many codes as you like on a single bin, and scan any of them from your phone to jump straight to the record.
3. Planning my upcoming move. I needed bins — pack a bin, label it, and know exactly what's inside every box and which room it belongs to. Moving a bin to a new room moves everything inside it with it.

It's a faithful reimplementation of homebox's data model (aligned with the maintained sysadminsmedia/homebox fork) with a Flask + SQLAlchemy backend and a Vue 3 (Vite) SPA, packaged to run as a standalone Docker container, a Home Assistant add-on, or on a Raspberry Pi 5.

HomeHoard stands on the shoulders of homebox and, like homebox, is licensed under AGPL-3.0. Huge thanks to @hay-kot and the homebox community.

🏆 The headline: run your inventory from Home Assistant

HomeHoard exposes your whole inventory to Home Assistant — by voice (plain Assist sentences, no LLM needed) and through an MCP server that runs inside the same add-on container for an LLM-powered Assist. Ask "where is my drill?", say "check out the drill" or "what's in the garage?", and — with an LLM agent — edit or move things too. Everything except adding or deleting items, right from chat or voice.

📸 Screenshots

Dashboard	Find where something is
Item detail — checked out	QR codes & barcodes
Bins	Items grid

✨ What's new

• ⚡ One-click check-out — one tap checks an item out immediately; add who has it, a due date, and notes as an optional next step (in the app and via the scanner).
• 🤖 Full MCP surface for Home Assistant — 13 inventory tools (where_is, suggest_placement, check_out_item, move_item, update_item, …) over SSE, in the same container. Everything except adding/deleting items is available to an LLM-powered Assist. (Also fixed the MCP host-header check so HA's MCP Client can actually connect to the add-on by hostname.)
• 🗣️ Voice, no LLM required — Assist sentences for "where is my drill?", "check out / check in the drill", and "what's in the garage?" (a bin or location's contents), plus matching homehoard.locate / check_out / check_in / contents services for automations & messaging.
• 📷 Scan-to-checkout — the camera scanner has Open / Check out / Check in modes: scan a label to lend or return an item on the spot, or scan a bin / location to glance at what's inside — inventory-only, no outbound calls.
• 🗃️ Bins with photos, plus items that inherit (and follow) their bin's location.
• 🩺 HA sensors + calendar — totals, insured value, checked-out count, warranties-expiring, maintenance-overdue, and a warranties/maintenance calendar.
• 🎨 Polished add-on — a proper HomeHoard icon & logo, and one-tap auto-discovery of the companion integration (no duplicate entries).
• 🚀 Reliable CI — native amd64 + arm64 (Raspberry Pi 5) images, merged into a multi-arch manifest and auto-versioned on every push.

🗺️ Roadmap

• Consumables / low-stock thresholds → a to-do / shopping list entity
• Multi-language Assist sentences
• Optional photo recognition for label-less bins/shelves (AI vision)

What's new

• Daily digest with one-tap buttons — A blueprint tells your phone what is running low and what maintenance is overdue, with Bought and Done buttons that act right from the notification. See Daily digest with one-tap buttons.
• Richer printable QR label sheets — The Print QR labels page now offers three layout presets (Address labels 3-up, Small labels 4-up, Large labels 2-up), each with its own label and QR size, and remembers your choice. The large layout also prints each item's asset id under its name.

Home Assistant

HomeHoard ships with both halves of a proper Home Assistant integration — a Supervisor add-on (the app itself, via Ingress) and a HACS integration (inventory sensors). Set it up in three clicks:

Step 1 — Add the Supervisor repository

Or manually: Settings → Add-ons → Add-on Store → ⋮ → Repositories → paste https://github.com/Amantux/homehoard

Step 2 — Add the integration via HACS

Or manually in HACS: Integrations → ⋮ → Custom repositories → paste https://github.com/Amantux/homehoard → category Integration → Add.

Step 3 — Start the add-on, watch it appear automatically

Install HomeHoard from the add-on store, then Start it. Within seconds a New device found card will appear in Settings → Devices & Services — no manual configuration needed.

The add-on opens from the sidebar (Ingress, no separate login), stores data in /share/homehoard, and builds for aarch64 (Raspberry Pi 5) and amd64.

Connecting a standalone HomeHoard (auth enabled)

The add-on runs auth-disabled behind Ingress, so it connects with no credentials. If instead you run HomeHoard standalone (Docker/Pi) with authentication on, give the integration an API token:

1. In HomeHoard, open Home Assistant in the sidebar → Generate token → copy it (shown once).
2. In Home Assistant, add the HomeHoard integration manually (Settings → Devices & Services → Add Integration → HomeHoard), enter the host/port, and paste the token into API token.

The same page shows the exact MCP URL to paste into HA's MCP Client. (For the standalone MCP server, set HBOX_MCP_API_TOKEN to a token too.)

What the integration gives you

The companion integration (custom_components/homehoard) polls a consolidated /api/v1/ha/summary endpoint and creates one HomeHoard device with:

• Sensors — total items, total value, insured value, locations, bins, labels, warranties expiring (30d) (with a 90-day + item list attribute), maintenance overdue (with upcoming + entries attribute), and restock needed (with the low items as an attribute).
• Binary sensor — Online (connectivity to the HomeHoard instance).
• Calendar — Warranties & maintenance: every warranty-expiry and scheduled maintenance date as calendar events, so you can automate reminders ("notify me 30 days before any warranty expires").
• Branded icon — the integration ships its own logo inline (custom_components/homehoard/brand/, HA 2026.3+ brands proxy), so the HomeHoard box shows in Devices & Services with no home-assistant/brands PR.

Daily digest with one-tap buttons

A blueprint sends your phone one notification a day, only when something is running low or maintenance is overdue. Its Bought buttons add the amount they name, and its Done buttons mark the maintenance done and schedule the next occurrence. It needs this integration and the Companion app.

Or Settings → Automations & scenes → Blueprints → Import blueprint and paste https://raw.githubusercontent.com/Amantux/homehoard/main/blueprints/automation/homehoard/homehoard_daily_digest.yaml. Then create an automation from it and pick a time and your phone's notify action. The add-on's Documentation tab covers what each button does, and the action strings for building your own notifications.

Find, check out & query by voice & messaging

You can find, check out / in, and look inside your inventory by voice or chat. There are two ways to do it — pick one:

Recommended: the MCP server + an LLM Assist pipeline. If your Assist conversation agent is an LLM (OpenAI, Google, Ollama, …), just connect the MCP Client (see MCP server below). Nothing to install, no sentence files, full natural language — ask "where's the drill and is it lent out?" and it just works. This is the easiest path and the one to reach for first.

The alternative below (plain Assist sentences) needs no LLM but only understands fixed phrasings and requires a one-time file copy. Use it if you run the default, non-LLM conversation agent.

• Voice sentences (no LLM, optional): sentence files ship for English (en), German (de), Spanish (es), French (fr) and Dutch (nl). Copy the file for your Assist language, e.g. custom_components/homehoard/custom_sentences/en/homehoard.yaml to <your HA config>/custom_sentences/en/homehoard.yaml (same pattern for de/es/fr/nl — the directory name is the language code), and restart HA. Then say (English shown; each language uses natural equivalents such as German "wo ist mein …" or Spanish "dónde está mi …"):

  • Find — "where is my …", "find the …", "which bin has the …"
  • Check out / in — "check out the …", "I'm borrowing the …", "check in the …", "put back the …"
  • Contents — "what's in the …", "what's inside the …", "contents of the …" (a bin or location)

• Services (automations / messaging): homehoard.locate and homehoard.contents (response services returning { speech, … }), plus homehoard.check_out / homehoard.check_in (by item name). Great for Telegram/notify bots:

  # Reply to a Telegram message like "where is my passport"
  - alias: HomeHoard locate over Telegram
    trigger:
      - platform: event
        event_type: telegram_text
    action:
      - service: homehoard.locate
        data:
          query: "{{ trigger.event.data.text }}"
        response_variable: found
      - service: telegram_bot.send_message
        data:
          message: "{{ found.speech }}"

  homehoard.locate returns { speech, results[] }, where each result has type (item/bin/location), name, where, and (for bins/locations) count.

MCP server (for Assist / LLMs)

HomeHoard ships an MCP server that runs in the same container (no extra service) and exposes inventory tools to Home Assistant's MCP Client integration — so an LLM-powered Assist can call them directly. Everything except adding or deleting items is available:

• Query — where_is, search_inventory, get_item, get_bin_contents, get_location_contents, list_checkouts, inventory_statistics, suggest_placement ("where should this go?" — ranks bins/locations by where similar items already live)
• Act — check_out_item, check_in_item, set_checkout_details, update_item (edit details), move_item (into a bin/location)

Adding and deleting items are intentionally not exposed to Home Assistant — do that in the app. HA is for finding, checking out, editing, and moving.

• Served over SSE on port 7766 (/sse), enabled by default (add-on option enable_mcp). The port is not published to your host/LAN — it's reachable only on Home Assistant's internal network, so nothing about HomeHoard is exposed outside the HA boundary (the UI/API go through Ingress; MCP stays internal).
• Connect it in HA: Settings → Devices & Services → Add Integration → Model Context Protocol — this is the MCP Client (it connects HA to HomeHoard); it is not the MCP Server integration, which points the other way. Point it at the add-on's internal container hostname: http://<addon-hostname>:7766/sse — e.g. http://b3264f33-homehoard:7766/sse (shown on the add-on's info page). HA Core reaches this over the Supervisor network; there is no host IP to use because the port isn't published.
• The MCP tools are only used when your conversation agent is an LLM (Settings → Voice assistants → Conversation agent). With the default, non-LLM agent, use the voice sentences above instead.
• Standalone (outside HA): python backend/mcp_server.py (HBOX_MCP_API points it at the app's API; defaults to http://127.0.0.1:7745/api/v1).

Example automation:

automation:
  - alias: HomeHoard warranty warning
    trigger:
      - platform: numeric_state
        entity_id: sensor.homehoard_warranties_expiring_30d
        above: 0
    action:
      - service: notify.notify
        data:
          title: HomeHoard
          message: >-
            {{ states('sensor.homehoard_warranties_expiring_30d') }} warranty(s)
            expiring within 30 days.

The HomeHoard card (Lovelace)

The HACS integration ships a custom Lovelace card and auto-registers it — no manual resource, no helper entities. Add HomeHoard Card from the card picker (or type: custom:homehoard-card) for a full overview in a single card: inventory stats, quick actions (find · what's inside? · lend & return · scan-to-check-out/in · open the app), the checked-out list, recently added, and locations. Its quick actions call the homehoard.* services directly (with response), so there's nothing else to wire up.

type: custom:homehoard-card
# all optional:
title: HomeHoard
app_path: /hassio/ingress/b3264f33_homehoard   # Open / Scan button target
prefix: sensor.homehoard_                        # entity-id prefix

The card is driven by the integration's sensors, whose total_items, locations, and checked_out entities carry recent / locations / items attributes. Prefer plain core Lovelace? docs/ha/overview_dashboard_core.yaml rebuilds the same thing from built-in cards (with docs/ha/overview_package.yaml for the input/script helpers). All examples live under docs/ha/.

Features

• Items with quantity (fractional), purchase/warranty/sold details, custom fields (text/number/boolean/time), notes — field set aligned with the maintained sysadminsmedia/homebox fork
• Nested locations (tree) and labels/tags (color, icon, hierarchy)
• Bins: a location holds bins, and each bin holds a collection of items. Items can sit directly in a location or inside a bin.
• Multiple QR codes per item, bin, or location — stick several printed codes on one physical object; scanning any of them opens that record. QR images and print-ready pages included.
• Vault (hidden items) — mark items hidden and they vanish from every listing, search, count, total, export and agent answer until you unlock with a passphrase. Ask the assistant to "unhide my items", give the phrase, and they stay visible until you say "lock". See The vault.
• Check in / out — mark an item as here or checked out ("yes it's there, no it's not"). One click checks it out immediately; who has it, a due date, and notes are an optional next step. /checkouts lists everything currently out (with overdue flags); a Checked out HA sensor tracks the count.
• "Where is it?" search — a spotlight-style search (top bar or the / key) matching items, bins, and locations and showing the full location path (e.g. Drill → Tool Bin · Garage › Shelf). Also powers HA voice/MCP.
• Scan to find & act — the camera scanner (QR + 1D barcodes) is inventory-only, no outbound calls, with Open / Check out / Check in modes: a known code opens the record, checks the item out/in, or shows a bin/location's contents inline; an unknown code lets you create or link it on the spot.
• Photos on bins too — attach photos/files to bins the same way as items.
• File attachments & photos (primary photo support)
• Maintenance logs per item with cost totals
• CSV import/export compatible with homebox's HB.* columns
• Auto asset IDs (000-001), group statistics & reporting
• Multi-tenant groups with invitations
• Optional auth: JWT login, or disable it entirely to run behind Home Assistant ingress (which already authenticates the user)
• Maintenance actions (ensure asset IDs / import refs, zero time fields, set primary photos)

Web UI

The Vue 3 SPA is a full homebox-style interface:

• App shell with sidebar navigation, a global search bar, a ＋ Create quick-add (item/bin/location/label), a camera QR scanner button, and a light/dark theme toggle (persisted).
• Dashboard with stat tiles, recently added item cards, and a locations overview.
• Items: card grid ⇄ table toggle, search, filter by location/label, sort (name / newest / updated / price), archived toggle, pagination.
• Item detail with tabs (Details · Attachments · Maintenance · QR), breadcrumb location path, hero photo, inline edit, attachment gallery, and a maintenance log form.
• Location & bin detail pages with tabbed items/bins/sub-locations and QR.
• Maintenance page aggregating scheduled/overdue/completed tasks group-wide.
• Scanner page/modal using the browser BarcodeDetector API to scan a QR or barcode with the camera and jump to the item/bin/location — or switch to a Check out / Check in mode to act on the scanned item, or view a bin/location's contents inline (with a manual-entry fallback).
• Toasts, loading skeletons, and empty states throughout.

Bins & QR codes

• A bin belongs to a location and contains items. Adding an item to a bin inherits the bin's location. Deleting a bin keeps its items (just detaches them). See the Bins tab.
• QR codes are managed from the QR panel on any item, bin, or location detail view. Each code has a short token and encodes a scan URL (<app>/#/t/<token>). Scanning opens the app, resolves the token, and navigates to the record. Scan URLs are Home Assistant ingress aware — they honor the X-Ingress-Path / X-Forwarded-* headers so printed codes keep working when the app is reached through ingress.

🔒 The vault (hidden items)

Some things you own are nobody else's business — presents before a birthday, anything you'd rather not have on a screen someone else is looking at. Marking an item hidden removes it from the app until you unlock the vault.

What hidden actually means

While the vault is locked, a hidden item appears in no listing, search result, resolve, barcode scan, bin/label/location page, report, statistic, price total, CSV export, HA sensor or calendar entry, notification, or agent answer. Not "greyed out" — absent. Its item count doesn't move, its price doesn't appear in a total, and fetching it by id returns 404, because "this exists but is hidden" would itself give it away.

Notifications are stricter still: a warranty or maintenance alert never names a hidden item, even while you're unlocked. An unlock is one browser tab for a few hours; a notification sitting on a phone is permanent and visible to whoever picks it up.

Using it

Action	In the app	To the assistant
Set the passphrase	Items → 🔑 Set vault passphrase	— (owner-only, deliberately not a chat action)
Hide something	select items → Hide	"hide the telescope"
Unlock	click 🔒 N hidden	"unhide my items" → it asks for the phrase
Lock again	click 🔓 Hidden shown — lock	"lock my items"
See what's hidden	Items → ?onlyHidden=true	"what's hidden?"

Unlocking applies to that session only — your phone stays locked when you unlock on a laptop, and an API token never inherits your unlock. It re-locks when you log out, and after 12 hours idle.

Forgot the passphrase — the reset

There is no recovery. The passphrase is stored only as a bcrypt hash, so nothing in HomeHoard can tell you what it was, and nothing can open the vault without it.

What you can do is reset the vault, which permanently deletes everything in it:

# 1. preview — changes nothing, and reports a COUNT only
curl -X POST http://<host>/api/v1/vault/reset \
  -H "Authorization: Bearer <owner-token>" -H "Content-Type: application/json" -d '{}'
# -> {"willDestroy": 3, "confirmed": false, "warning": "..."}

# 2. confirm — irreversible
curl -X POST http://<host>/api/v1/vault/reset \
  -H "Authorization: Bearer <owner-token>" -H "Content-Type: application/json" \
  -d '{"confirm": true}'
# -> {"destroyed": 3, "configured": false}

Afterwards the vault has no passphrase and no contents; set a new phrase and start again.

Why it deletes rather than just re-keying. If a reset simply set a new passphrase and kept the items, then any household owner could re-key their way into reading them — and the vault would protect nothing from exactly the people most likely to look. The reset gives you back the vault, never its contents.

Why the preview won't name them. Every other destructive action in HomeHoard names precisely what it is about to remove. This one reports a number, because listing the names would hand the contents to someone who has just demonstrated they can't open the vault.

Owner-only, rate-limited, and two-step: the first call always previews.

What this does and does not protect

This is access control inside the app, not encryption:

• Hidden rows sit in the database in plaintext. Anyone with the database file, a filesystem backup, or an admin API token can read them regardless of lock state.
• If you unlock through the chat assistant, the passphrase is an ordinary chat message: it reaches whichever LLM provider you configured and stays in chat history. Unlock from the UI if that matters to you.
• A locked CSV export omits hidden items; unlock first if you want a complete backup.

It stops someone browsing the app, searching, or asking the assistant. It does not stop someone with access to the machine.

Project layout

homehoard/
├── backend/            # Flask API + SQLAlchemy models
│   ├── app/
│   │   ├── api/        # route blueprints (items, bins, qr, checkout, search, ha, …)
│   │   ├── models/     # SQLAlchemy models
│   │   ├── schemas/    # JSON serializers (homebox-compatible camelCase)
│   │   ├── services/   # CSV import/export
│   │   ├── auth.py     # optional JWT auth layer
│   │   └── __init__.py # app factory (+ SPA serving, additive migrations)
│   ├── mcp_server.py   # MCP server exposed to Home Assistant (SSE)
│   ├── ha_discovery.py # Supervisor discovery registration
│   ├── seed.py         # demo data
│   ├── run.py          # dev entrypoint
│   └── tests/          # pytest suite
├── frontend/           # Vue 3 + Vite SPA
├── custom_components/  # HACS integration (custom_components/homehoard)
├── homehoard/          # HA add-on (config.yaml, DOCS.md, CHANGELOG.md)
├── repository.yaml     # HA add-on repository manifest (root, for Supervisor)
├── hacs.json           # HACS repository manifest
├── docker-entrypoint.sh# starts the app + MCP server in one container
├── Dockerfile          # standalone / add-on multi-arch image
└── docker-compose.yml

Quick start (development)

Clone the repository:

git clone https://github.com/Amantux/homehoard.git
cd homehoard

Backend:

cd backend
pip install -r requirements.txt
python seed.py          # optional demo data
python run.py           # serves http://localhost:7745

Frontend (hot-reload dev server, proxies /api to :7745):

cd frontend
npm install
npm run dev             # http://localhost:5173

Production / Docker

docker compose up --build
# → http://localhost:7745  (frontend + API from one container)

The image builds the Vue app and serves it from Flask, so a single container runs the whole stack.

Configuration (environment variables)

Variable	Default	Description
HBOX_DATA_DIR	./data	SQLite DB + attachments location
HBOX_DATABASE_URL	(sqlite in DATA_DIR)	External database. Blank = built-in SQLite. Postgres: postgresql+psycopg://user:pass@host:5432/db (postgres:///postgresql:// are accepted and normalized). Schema is created + migrated automatically (Alembic). See docker-compose.yml for an opt-in Postgres service.
HBOX_MIGRATE_FROM_SQLITE	false	One-shot: with HBOX_DATABASE_URL set to an empty Postgres, set true and restart once to copy existing SQLite data into it. No-op once the target has data; SQLite source is never modified. Or use Tools → Migrate to PostgreSQL in the UI.
HBOX_OLLAMA_SEARCH_KEY	(none)	An Ollama API key enabling AI item descriptions: look an item up online and store a short searchable description (✨ Describe on an item, or Tools → describe all). Blank = feature off.
HBOX_OLLAMA_URL	http://localhost:11434	Ollama server used to phrase the description from search results (any local Ollama). Optional — falls back to a raw snippet if unreachable.
HBOX_OLLAMA_MODEL	llama3.1	Model for that phrasing step.
HBOX_SECRET_KEY	change-me-in-production	JWT signing key (use ≥ 32 chars)
HBOX_DISABLE_AUTH	false	Skip auth; bind all requests to a default local user/group
HBOX_ALLOW_REGISTRATION	true	Allow public self-registration
HBOX_JWT_HOURS	168	Token lifetime
HBOX_MAX_UPLOAD_MB	50	Max attachment upload size
HBOX_PORT	7745	App (API + UI) port
HBOX_FRONTEND_DIST	../frontend/dist	Built SPA directory
HBOX_MCP_ENABLED	true	Run the MCP server (in-container)
HBOX_MCP_PORT	7766	MCP SSE port
HBOX_MCP_API	http://127.0.0.1:7745/api/v1	API base the MCP server calls
HBOX_MCP_API_TOKEN	(none)	Bearer token for the MCP server's API calls (only if app auth is on)

Home Assistant add-on options: disable_auth, allow_registration, enable_mcp, mcp_expose_external, mcp_require_key, ollama_search_key, barcode_lookup, barcode_db_key, public_url, database_url, migrate_from_sqlite, use_shared_postgres, postgres_provision_token, mcp_debug_tools, log_level — see homehoard/DOCS.md for what each does.

API

JSON REST API under /api/v1, mirroring homebox's routes — e.g. /items, /items/{id} (GET/PUT/PATCH/DELETE), /items/import, /items/export, /locations, /locations/tree, /labels, /groups/statistics, /users/login, /users/self, /notifiers, /actions/*, /qrcode, /status.

Photo thumbnails: uploading a photo attachment writes a JPEG thumbnail (max 400px long edge) beside the original; GET /documents/{id}?thumb=1 serves it, falling back to the original when none exists (pre-existing photos, non-image files). Item and bin cards request ?thumb=1. POST /actions/generate-thumbnails backfills thumbnails for photos uploaded before this pipeline existed — idempotent, returns {generated, skipped}.

Vault (hidden items):

Method	Path	Description
GET	/vault/status	{configured, locked, hiddenCount} — a count, never contents
POST	/vault/passphrase	Set ({phrase}) or change (+ {currentPhrase}); owner-only
POST	/vault/unlock	{phrase} → unlocks this session; 401 wrong, 409 if none set
POST	/vault/lock	Re-hide immediately
POST	/vault/reset	Preview; with {"confirm": true} deletes every hidden item and clears the passphrase. Owner-only

An item is hidden with PATCH /items/{id} {"hidden": true}, and GET /items?onlyHidden=true lists the vault (which works while locked, so nothing is ever stranded).

Bin & QR extensions:

Method	Path	Description
GET/POST	/bins	List / create bins (?location=<id> filter)
GET/PUT/DELETE	/bins/{id}	Bin detail / update / delete (items kept)
PUT/DELETE	/bins/{id}/items/{itemId}	Add / remove an item to/from a bin
GET/POST	/qr-tags	List (?kind=&targetId=) / create a QR tag
GET/DELETE	/qr-tags/{id}	Get / delete a QR tag
GET	/qr-tags/{id}/image	PNG of the QR code
GET	/qr-tags/resolve/{token}	Resolve a scanned token to its target

POST /qr-tags body: { "kind": "item"｜"bin"｜"location", "targetId": "<id>", "description": "optional" }.

Search, scan, check in/out & Home Assistant:

Method	Path	Description
GET	/search?q=	Find items, bins, and locations with a location path (?types=item,bin,location)
GET	/barcode/{code}	Inventory-only lookup — registered code → record (+ bin/location contents), else not_found
POST	/items/{id}/checkout	Check an item out ({ person?, due?, notes? })
PATCH	/items/{id}/checkout	Update an active checkout's details ({ person?, due?, notes? })
POST	/items/{id}/checkin	Check an item back in
GET	/items/{id}/checkout	Current status + check in/out history
GET	/checkouts	Everything currently checked out (with overdue flags)
GET	/bins/{id}/attachments …	Bin photos/attachments (mirrors item attachments)
GET	/ha/summary	Totals + attention counts (warranties expiring, maintenance overdue, checked out)
GET	/ha/calendar?start=&end=	Warranty-expiry + scheduled-maintenance events

An MCP server (SSE on :7766) exposes these as tools for Home Assistant — see MCP server above.

Tests & CI

cd backend
pip install -r requirements.txt pytest
pytest

GitHub Actions (.github/workflows/ci.yml) on every push to main: runs the backend test suite + frontend build, auto-bumps the patch version (keeping homehoard/config.yaml and the integration manifest in lockstep), then builds the image natively per arch — amd64 on ubuntu-latest, arm64 (Raspberry Pi 5) on ubuntu-24.04-arm — and merges them into a single multi-arch manifest published to GHCR (ghcr.io/amantux/homehoard:<version> and :latest).

Running on a Raspberry Pi 5

docker run -d --name homehoard -p 7745:7745 \
  -e HBOX_DISABLE_AUTH=false \
  -e HBOX_SECRET_KEY="$(openssl rand -hex 32)" \
  -v homehoard-data:/data \
  ghcr.io/amantux/homehoard:latest

License

HomeHoard is a personal rewrite of homebox and, like homebox, is distributed under the GNU Affero General Public License v3.0 (see LICENSE).