Dante

An AI-first, self-hosted household workspace built around conversation with Hermes — with visual tools for every plan, action, and piece of data.

Documentation · Polski · Getting started · Help · FAQ · Support · License

Important

Dante is source-available under the Dante Non-Commercial Reciprocal License 1.0: private and internal company use, modification, and free reciprocal forks are permitted, while monetizing Dante or a derivative is prohibited. It is not an OSI-approved open-source license. Read Licensing before using the project.

Download

The latest public release is Dante 2.0.0. Android users can download the signed APK and verify it with the published SHA-256 checksums. Dante is self-hosted, so install and configure the server from the getting-started guide before connecting a client.

What is Dante?

Dante is a private, single-household workspace that you run on your own server. Its primary interaction model is a conversation backed by Hermes: ask for a meal plan, update a shared shopping list, schedule training, record a note, or check the day without translating your intent into a sequence of screens.

The visual application is not a separate product beside the AI. Its dashboards, editors, and mobile views are inspectable, controllable surfaces for the same versioned tools that Hermes can use. You can see what changed, correct it manually, and keep working if the model connection is temporarily unavailable.

Dante combines lists, food and recipes, workout planning, goals, calendar, memory, notifications, and the Hermes-backed conversation in one application.

Every person gets an independent profile with their own data, language, theme, enabled modules, navigation, dashboard, and device access. Household data is shared only through an explicit shared profile. Dante does not silently merge personal profiles, and a shared profile is not an administrator.

The intended Dante experience requires a compatible Hermes integration. The visual tools remain available as a resilient manual path and do not require a cloud account, Firebase, calendar provider, voice model, or exercise-media subscription.

See the idea

One conversation can coordinate several household domains while the resulting state remains visible and editable.

Today Plans, food, lists, training, and proactive context.	Training Plans, muscle focus, exercises, sessions, and history.	Profiles Private people, a shared home, roles, and device grants.

All screenshots use a synthetic English demo household in light mode. They contain no maintainer or production data. See the screenshot notes.

What you are looking at

The mobile and desktop clients expose the same household, adapted to each screen:

Screen	What it is for
Today	A daily overview of food, training, tasks, shopping, and short Dante summaries
Lists	Shopping and to-do lists with quantities, units, completion, suggestions, and multiple list scopes
Food	A profile-specific diary with calories, macros, portions, daily goals, and product lookup
Recipes	Ingredients, preparation steps, editing, and adding recipe items to a shopping list
Training	Workout plans, schedules, body map, exercise sets, session logging, and history
Goals	Nutrition and training targets with date-specific adjustments
Calendar	Household events and schedule management
Memory	Profile notes and structured context available during Hermes conversations
Notifications	A durable inbox for reminders, workout events, list changes, and Dante messages
Profile & settings	Profiles, roles, device grants, language, appearance, modules, menus, dashboards, and automations
Dante	The Hermes-backed conversational interface to the same guarded application commands

Desktop adds a navigation rail, wider planning views, and a docked conversation that can stay open while you inspect the resulting data. Mobile keeps the primary actions thumb-accessible and uses the same profile permissions and synchronized preferences.

Main capabilities

People and access

• any number of personal profiles plus one explicit shared profile;
• administrator and member roles;
• create, edit, deactivate, reactivate, and switch profiles;
• one-time device pairing with per-profile grants;
• grant editing, device revocation, and server-enforced profile isolation.

Personalization and languages

• English as the deterministic default and fallback;
• complete English and Polish interfaces;
• per-profile language, IANA time zone, theme, accent, and recipe view;
• separate mobile and desktop module selection;
• configurable navigation visibility, ordering, and dashboard widgets.

Household organization

• shopping and task lists, archive, defaults, bulk add, and suggestions;
• food diary, nutrition totals, recipes, and goal adjustments;
• workout plans, exercise catalogue, schedules, sessions, and FIT import;
• calendar, memory, durable notifications, and opt-in briefings;
• live WebSocket updates with local caching and offline-safe fallbacks.

Operation and recovery

• transactional SQLite storage and an operation ledger;
• transactional outbox for reliable follow-up events;
• portable backups, bounded restore validation, and rollback tooling;
• guarded upgrades, health checks, and a loopback-first network configuration;
• non-root containers and paired-device authentication by default.

Conversation is the main interface

Every application operation intended for Hermes is exposed through a Dante-owned tool boundary. The model does not receive raw SQL, filesystem, or shell access. It can request one of 58 versioned, typed commands in 8 domains:

calendar · food · goals · home · lists · memory · recipes · training

Dante validates the command, active profile, device grant, role, enabled feature, approval requirement, and idempotency data before execution. Sensitive operations can require an approval receipt. Hermes handles the conversation and tool orchestration; Dante remains the authority for identity, permissions, validation, execution, and stored state.

This creates two views of one system:

• conversation is the fastest way to express intent across several domains;
• the visual clients show the current state, offer precise editing, and provide a fallback when Hermes is disconnected.

See the generated assistant capability registry and Hermes integration guide.

Deployment model

                    ┌──────────────────────────────┐
You ── conversation │ Dante chat backed by Hermes │
                    └──────────────┬───────────────┘
                                   │ typed tool requests
Web / Android / Desktop ───────────┤
          │                        ▼
          │ paired device     Dante command registry
          │ over HTTPS             │
          ▼                        ▼
     Dante FastAPI ─────── validation, grants, approvals
          │
          ├── SQLite data, notifications, outbox, backups
          ├── operator-supplied training media
          └── calendar, push, FIT, and voice adapters

One Dante installation currently represents one household. It is not a hosted multi-tenant service and does not include a public cloud control plane. A compatible Hermes endpoint is required for conversation; the visual and data services continue to operate when that endpoint is offline.

Quick start

Requirements:

• Docker Engine with Docker Compose v2;
• Git;
• curl and Python 3 on the host;
• a Linux host for the first supported release.

git clone <repository-url> dante
cd dante
./ops/install.sh

The installer creates a private .env, generates independent random secrets, validates the configuration, builds the application, and waits for the API and bundled web UI to become healthy. Dante binds to 127.0.0.1:8770 and requires a paired device by default.

Create the first one-time administrator pairing code from the server host, then follow first-run setup to pair the client, create profiles, and choose the modules visible to each person.

Do not expose the development HTTP endpoint directly to the internet. Keep the loopback default or put an authenticated TLS reverse proxy in front of Dante. The installation guide includes the supported Caddy example, exact CORS guidance, and optional integrations.

Common operations:

make health
make logs
make backup
make upgrade
make public-check

Privacy and security expectations

• Private data stays in the self-hosted SQLite database and protected runtime directories unless an operator deliberately configures an integration.
• UI visibility is not treated as authorization; profile access is checked by the backend.
• Notifications are stored in the profile inbox before live or push delivery.
• Public installations require paired devices and should use HTTPS.
• Logs and stable client errors are designed not to expose provider bodies, credentials, private URLs, or profile data.
• Backups contain private household data and must be encrypted and stored off-host.

Read the security model, profiles and grants guide, and backup/restore guide before operating an internet-accessible installation.

Optional exercise catalogue and media

Dante does not distribute an exercise dataset, photos, videos, or GIFs. The training catalogue can read operator-supplied metadata and media from TRENING_DIR; the operator must verify and preserve the license and attribution for every supplied file. A familiar filename, API name, or public repository mirror is not evidence that an exercise animation is free to redistribute.

The separate English candidate demo uses three wger community videos credited to Goulart under CC BY-SA 4.0, transformed into short GIFs with exact source and transformation attribution. Those demo files are not included in this repository and are not covered by the Dante project license. See Third-party notices.

Documentation map

If you want to…	Start here
understand the first launch	Getting started
install or expose Dante safely	Installation
create profiles and device grants	Profiles
configure modules and menus	Personalization
understand stored notifications	Notifications
back up, restore, or upgrade	Operations
inspect the API and model commands	Reference
troubleshoot an installation	Troubleshooting
read in Polish	Polska dokumentacja

Development

The pinned toolchain uses Python 3.12 and Node.js 26.4.0.

python3.12 -m venv .venv
.venv/bin/pip install -r server/requirements.txt -r server/requirements-dev.txt
DB_PATH=/tmp/dante-dev.db PYTHONPATH=server .venv/bin/pytest server/tests

cd app
npm ci
npm run test
npm run check
npm run lint
npm run build

Build the documentation:

cd full-docs
npm ci
npm run generate
npm run check
npm run build
npm run smoke

Read CONTRIBUTING.md before opening a pull request. Report security issues through the private process in SECURITY.md. Dependencies and vendored assets retain the licenses listed in THIRD_PARTY_NOTICES.md.

License

Dante is licensed under the custom Dante Non-Commercial Reciprocal License 1.0. The plain-language licensing guide explains the intended boundary; the license text controls if the two differ. This is a source-available license, not an OSI-approved open-source license.