LIA — Your next conversation, already prepared

I built LIA because I wanted to pick up a conversation without piecing its context together again. This self-hosted AI assistant brings your emails, meeting notes and open commitments into view, then helps you prepare the next step.

Start the guided installer:

git clone --depth 1 https://github.com/jgouviergmail/LIA-Assistant.git && cd LIA-Assistant && ./install.sh

For a Linux host with Git, Python and Docker Compose. Prerequisites and setup choices.

Explore LIA · Try the interactive walkthrough · Installation guide · Documentation

Why LIA?

The moment I wanted to improve is simple: “I'm speaking with Claire. What did we agree, what changed, and what do I still owe her?”

• Pick up the relationship. Open Relations for the recent exchanges, debrief and open commitments associated with a person.
• Prepare from your own material. Ask LIA to bring together the project brief, recent emails and previous meeting notes. Inspect the sources and anything that conflicts.
• Choose what happens next. Review the email draft before sending. Edit it, approve it or say no.

Try: “Prepare my catch-up with Claire using the project brief, our recent emails and the last meeting notes. Highlight anything that conflicts.”

That continuity is LIA's focus: the relationship, its sources and the next action in one place. Start there; voice, personal Radio, routines and the rest are available when you need them. The functional map shows how those pieces connect.

---

Quick Start

The command above starts the installer in install.sh. It asks how to expose the instance, creates the administrator account and walks you through provider keys. The first source build takes longer than starting an already installed instance.

Have these ready: a supported Linux host, Git, Python and Docker Compose; see the installer prerequisites for versions and disk space. The current installer asks for OpenAI and DeepSeek keys. Add the optional Gemini key for memory recall, document search and image analysis.

1. Run the command above; choose LAN for a first installation on your local network.
2. Follow the printed address, sign in and connect the services you want LIA to use.
3. Open Relations, or ask for a conversation brief using sources available to your account.

Already have the checkout? Run ./install.sh from its root. An interrupted installation can continue with ./install.sh --resume.

The self-hosting guide covers every installer choice and troubleshooting. The getting-started guide covers the wider setup.

Self-Hosting in Production

A guided installer lives at the repository root (ADR-215). It asks a short questionnaire (LAN exposure, your own reverse proxy, or managed HTTPS with Caddy), generates a private .env and Compose overlay, applies the reference seeds atomically, creates the admin and provider keys over stdin, verifies the installation beyond /ready and prints a non-secret report.

The experimental speaking avatar is an optional choice, disabled by default; each person then connects their own Simli account.

A complete source checkout builds the images locally; an official release directory uses prebuilt digests only when its adjacent manifest is qualified.

The Google Gemini key is an optional question — memory recall, searches by meaning and image analysis wait for it — and the final report names every capability left waiting for a key.

Two optional key pairs follow, each given whole or left empty: a Google Maps browser key with its Cloud map ID for interactive place maps, and, on an instance reached on a public domain, a Cloudflare Turnstile widget's keys for the anti-robot check on the password doors (ADR-364).

Every line of the shipped env templates states the code's default or says why it differs, and .env.prod.example carries the values production runs.

Resume an interrupted run with ./install.sh --resume; change a running installation with ./install.sh --reconfigure, which shows the answers in force (Enter keeps them) and every setting they would rewrite before anything changes, replaces each file atomically after a private backup, recreates the containers without rebuilding and puts the previous files and stack back if the new one does not come back ready.

The shipped .env profiles size the connection pools against the database's memory floor as well as its ceiling, and a guard reads both profiles with the Compose file so the sizing cannot drift (ADR-283).

Full guide: docs/guides/GUIDE_SELF_HOSTING.md — what it installs, every setting, and what to do when a step fails. Production targets include the Raspberry Pi (ARM64) through multi-arch Docker images (linux/amd64,linux/arm64).

Prerequisites

Software	Version	Required
Python	3.14	Yes
Node.js	24 LTS	Yes
Docker	24+	Yes
pnpm	10+	Yes
Task	3+	Yes (build tool)

Every command lives in Taskfile.yml.

Express Setup

# 1. Clone the repository
git clone https://github.com/jgouviergmail/LIA-Assistant.git
cd LIA-Assistant

# 2. Configure environment
cp .env.example .env  # Edit with your API keys

# 3. Full setup (backend + frontend + git hooks)
task setup

# 4. Start all services (API + Web + PostgreSQL + Redis + observability)
task dev

# 1. Start the infrastructure
docker compose -f docker-compose.dev.yml up -d postgres redis prometheus grafana

# 2. Backend setup
cd apps/api
python -m venv .venv && source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install --require-hashes -r requirements.lock.txt  # compiled lockfile (reproducible)
cp ../../.env.example .env  # Configure your API keys

# 3. Database migrations
alembic upgrade head

# 4. Frontend setup
cd ../web
pnpm install

# 5. Start the services
# Terminal 1 - Backend:
cd apps/api && uvicorn src.main:app --reload --port 8000

# Terminal 2 - Frontend:
cd apps/web && pnpm dev

Development URLs

Service	URL	Credentials
Frontend	http://localhost:3000	—
API Docs	http://localhost:8000/docs	—
Grafana	http://localhost:3001	admin/admin
Prometheus	http://localhost:9090	—

Minimal Configuration (.env)

# Database
DATABASE_URL=postgresql+asyncpg://user:pass@localhost:5432/lia
REDIS_URL=redis://localhost:6379/0

# Security (REQUIRED - change in production)
SECRET_KEY=change-me-in-production-use-openssl-rand-base64-32
FERNET_KEY=your-fernet-key-here

# LLM provider API keys are configured in the Admin UI after first login
# (Settings > Administration > LLM Configuration). At least one provider is required.

# Google OAuth (optional)
GOOGLE_CLIENT_ID=...
GOOGLE_CLIENT_SECRET=...

# Feature flags (optional, disabled by default unless stated)
MCP_ENABLED=false               # Admin MCP servers
MCP_USER_ENABLED=false          # Per-user MCP (requires MCP_ENABLED)
CHANNELS_ENABLED=false          # Multi-channel messaging (Telegram)
HEARTBEAT_ENABLED=false         # Autonomous proactive notifications
SUB_AGENTS_ENABLED=false        # Persistent specialized sub-agents
SKILLS_ENABLED=false            # Skills system (agentskills.io standard)
RAG_SPACES_ENABLED=true         # Knowledge spaces (document upload & retrieval)
FCM_NOTIFICATIONS_ENABLED=false # Firebase push notifications

Every optional subsystem is governed by a {FEATURE}_ENABLED flag, checked at startup, at route wiring and at node entry; the full list with defaults is in .env.example.

---

Try LIA Online

Explore LIA and its real interface or try the public demonstration.

The public walkthrough is available without an account and uses example data. It shows how context, results and approval controls fit together. A live demonstrator is also offered when the instance publishes one.

Hosted beta access — account access and activation are granted at the administrator's discretion. To request an invitation, write to [email protected].

To run your own LIA, start with Quick Start or the production installation guide.

The walkthrough runs without a real model, connected account or external action. Its source links let you inspect the mechanisms it illustrates.

---

Features

Start with one use case. Open a chapter when you want the details.

Every capability below is documented in an architecture decision record (ADR) or a technical document — the links lead there.

Explore	What you'll find
LIA World	A shared campus, your private home and familiar LIA functions
Talk to it	Chat, voice, live sessions, radio and a companion that feels present
Connect your world	Your accounts, documents, home, health, tools and skills
Act, under your control	Orchestration, approvals, calls, creation, browser work and tickets
Anticipate	Timely suggestions, routines, reminders and a daily briefing
Remember	Memory, journals, knowledge, meetings, people and saved work
Trust it	Records, spending limits, authentication, data protection and controls

Remember

Long-term memory

• Facts are extracted after each conversation, pinned or edited by hand, and injected by relevance with their scores visible in the debug panel (LONG_TERM_MEMORY, MEMORY_RESOLUTION).
• Newly learned standing instructions are pinned automatically. You can edit, unpin or delete them; automatic maintenance respects their protection.
• The planner, the ReAct loop and the phone look them up on purpose through one lookup door that answers what was asked, never just the latest memories (ADR-313).

Personal journals

• Introspective notebooks the assistant keeps in the first person, stratified from raw observations to a user portrait, with an epistemic status per entry and a deferred self-evaluation at zero added LLM cost.
• The portrait is an analysis of the person, not an inventory, read from everything LIA keeps — memories, interests, learned habits, relationship debriefs, open loops, Workboard tickets, routines, reminders and kept answers — each read whole under its own gates; its brief is a summary of its own, a journal change marks it stale rather than erasing it, and it shows which sources it used (ADR-079, ADR-292, ADR-343, JOURNALS).
• A read tool searches them on demand — directives, patterns and facets, never raw observations (ADR-318).

Knowledge spaces

• Personal document bases in 15+ formats with hybrid search (pgvector cosine + BM25), Google Drive folder sync, a Gmail label as a source, and a system space that indexes the product's own help corpus so LIA can explain itself — drawn from the in-app FAQ, whose 525 questions cover every feature a person can use, in six languages.
• A document that cannot be indexed says why in your language — a scanned PDF without a text layer names its remedy.
• Any indexed document, paused space or not, attaches to a chat message as a copy from the composer's « + » (ADR-295, GUIDE_RAG_SPACES, ADR-055, ADR-058).

Meetings and minutes

• Search complete minutes from the meeting list, with server-side filtering and pagination.

• Record from the phone or the computer while the chat stays usable, with a capture that survives reloads and lost microphones.

• Import a recording you already hold — WAV, MP3 or M4A — and it becomes a meeting with its minutes: sent in chunks under published bounds, read only as the format it claims, its length measured before any engine is paid.

• A chain of transcription engines walked at processing time.

• Minutes filled from one of thirty built-in templates or your own, reformatted in place or derived into a second set from the same transcript (ADR-258, ADR-259, MEETINGS).

People

• Share a skill, MCP server or plugin with an accepted connection as an independently owned, disabled copy. The recipient sees who shared it and when, the sharer whom it went to — under the card's line, a copy already given never sent twice —, and the recipient supplies their own credentials and manages it with the existing controls (ADR-350).

• A 360° relationship lens over open loops, calls, messages and memories, with a written debrief per person built lazily when the card opens (ADR-176, ADR-193, ADR-269).

• A timeline on each relationship card lines up its dated records — commitments, calls, memories, relayed messages, text messages — on one thread, page after page, never repeating or dropping one.

• Connections between users of the same instance, assistant to assistant — relayed messages delivered by the recipient's own assistant, field-level read-only shares, silent blocking; a first name reaches the person it designates, and a name that fits several people is asked about, never guessed (ADR-180, ADR-182).

• A generated image shared with a connection as a copy, in one click and one transaction, its comment quoted literally in their chat (ADR-316).

What LIA produced is yours

• Generated images, documents and browser screenshots have their own galleries with search, exact totals and a visible retention deadline.
• Clearing a conversation never clears them (ADR-279).
• LIA finds them again when asked and shows them as the chat's own cards (ADR-318).

What you keep is yours too

• A bookmark on every answer copies it with the request that produced it and the answer's date, so it outlives the conversation.
• A Bookmarks tab beside the galleries lists them newest first, with search, an exact total against the account's cap, sharing, a Markdown export and deletion.
• A kept answer or a generated file comes back into any discussion, from the composer's « + » or from its own card, as a copy — the original stays where it is.
• Every kept answer is also indexed in a knowledge space of your own, so LIA cites it weeks later when a question concerns it, and the card shows the indexing state and two named costs — what the answer cost to produce and what indexing it cost, as billed (ADR-282, ADR-291, BOOKMARKS).

Act, under your control

Manage LIA through conversation

Ask LIA to inspect or change supported preferences and application objects: reminders, routines, memories, skills and other declared capabilities. Reads and minor reversible settings follow their own authorization policy; creations, deletions and sensitive operations present a reviewable confirmation. File, private-input and connector authorization steps continue through their native browser flows. Commands remain account-scoped, expiring and checked against current authority; administrator capabilities stay reserved to administrators. The application commands guide describes the supported surfaces and secure continuation contract.

Two execution modes, one toggle

• The pipeline builds and validates a plan, applies the required approval gates and executes tools in dependency-aware waves.
• ReAct adapts its next steps to tool results for exploratory or ambiguous requests. Token use and latency depend on the task and configured models.
• Both stream through the same response node (ADR-070, PLANNER).
• A ReAct tool result is projected item by item under a token budget derived from the slot's own window, never cut mid-item, the cut stated to the model and counted (ADR-286).
• In the pipeline too, what a read step found beyond the cards — durations, connections, a next page — reaches the answer through the same projection, and a tool's declared failure is never returned as a success; a for-each with failed items keeps its successes (ADR-347).
• The loop binds its tools by relevance — the detected domains' tools, the best-ranked doors of every other family, the top of the turn's global ranking, a large catalogue such as the settings reached through its own domain — so no family falls off a blind cap and the schemas stop being most of the prompt, and it reads the same knowledge spaces the pipeline reads (ADR-293).
• A ReAct turn is judged on its result: every fact the loop set out to obtain ends obtained or declared with the rungs tried. A declared gap buys one bounded recovery pass through a node that calls no model (ADR-310).
• Requested outcomes are checked against canonical structured observations, including the value, operation, account and completeness expected. A draft, opaque result or delegated announcement does not prove completion. Independent eligible reads return checkpointed segments; exact fresh reads may be reused within the same turn, with mutation invalidation and bounded budgets (, ).

Human-in-the-Loop

• Approvals that interrupt the turn: clarification, draft review, a choice between matching people or items, tool confirmation and bulk FOR_EACH confirmation. Plan approval is currently auto-approved because tool-level approval supersedes it (HITL, ADR-106).
• Several independent drafts in one turn are reviewed one per question, with their position stated and nothing executed before the last answer, while a lot you pre-approved as a list keeps its grouped confirmation (ADR-288).
• A draft and its report are described once and drawn per surface — a lia-card in the chat, Markdown on a ticket or an external channel — the report naming to whom and what (ADR-289).
• An e-mail to yourself needs no confirmation, because its recipient is not a parameter — the address your mailbox's provider states, or your verified one through LIA's relay — so a routine can send you its result (ADR-314).

Phone calls on your behalf — and to you

• Through your own ElevenLabs + Twilio connector, calls to third parties require confirmation before dialing. You review the recipient, number and objective; instructions bound the mandate, calendar access exposes free/busy information, and the call is not recorded. The post-call summary and available usage information remain reviewable (ADR-127, TELEPHONY).
• The phone as a channel: LIA calls you on a number you declared and verified by a spoken code, with no confirmation card, the chat's own context and your configured personality on the line.
• The voice agent reads everything the chat reads through the same read-only tools (mails, calendar, tasks, contacts, files, places, weather, memory — one switch per domain, yours) and acts on nothing.
• What you say comes back as your own message, with drafts to confirm in the chat, ten relay verdicts and one bill per call for what LIA spent, shown on the call's report in the chat (ADR-290).
• Since ADR-301 a voice session has a mode, and the policy follows it whatever the line. In Live (the default), each request is a chat turn of yours handled while you speak; a question LIA asks is the answer, and the next request resumes the run that asked. In Live direct, the voice reads and the words are relayed at the end. Phone and browser share one closing; the effective mode is derived and published, and the browser's direct session is relayed like a call (ADR-301).

Documents and images

• CSV, Excel, Word, PowerPoint, PDF, Markdown or text produced by local renderers with each format's native mechanisms (styles, fields, layouts, typed tables, bookmarks).
• Format-specific renderers manage layout, and truncated structured model output is rejected instead of silently producing an incomplete file (ADR-226, ADR-274, ADR-275).
• Image generation and natural-language editing on OpenAI GPT Image or Qwen Image 3.0 — a model family declares its offer, so nothing the configured model cannot serve is priced, offered or selected, the person's preference is resolved to that offer and every image arrives in the chosen format (ADR-305, IMAGE_GENERATION).
• On request, a new image's description is rewritten following the provider's own advice — a quoted text kept word for word, the original sent whenever in doubt, an edit never rewritten (ADR-315).

Keep and send what LIA made

• Generated images, documents and screenshots can be kept without a deadline within published account limits, or released to a fresh normal deadline.
• Their chat cards reflect the current state (ADR-319).
• A file or answer can be sent by e-mail with a subject and optional note: chosen recipients through a connected mailbox, or the account's verified address through LIA's relay, under the selected provider's displayed size limit; typing a recipient suggests the person's contacts by name or phone number and inserts their address (ADR-321).

A browser, a sandbox, delegates

• Browser control with progressive screenshot streaming (ADR-059).
• A short Python script run in the skills sandbox when a step needs real computation, ReAct only (ADR-249) — and, when the person allows it, reaching the web through one egress proxy that swaps per-run tokens for the person's own connector keys, an unknown host asked with three answers and settled inside the loop (ADR-298).
• Persistent read-only sub-agents with their own instructions, skills and budgets; at their step limit they still write their deliverable from what they found, and a failure says how far it got (SUB_AGENTS, ADR-083).

The workboard

A ticket has a lifecycle, a holder and a result (ADR-276, WORKBOARD):

• One row per ticket, shared by its owner and its holder, across seven columns with sub-tickets, comments and a history that names both ends of every hand-over; the holder can be you, a connected peer, or LIA.
• When LIA holds it, a sweep claims one ticket at a time, runs it in the execution mode the ticket declares, and settles from an explicit result — a quota ceiling or a busy conversation postpones the run, never fails it.
• A run that needs a decision asks instead of refusing: the ticket lands in « To confirm » carrying the exact card the chat would show, and your comment is the answer.

Anticipate

The heartbeat

• LIA takes the initiative when it is worth it: calendar, mail, tasks, weather changes, interests, memories, habits and the workboard are aggregated, a cheap structured decision says whether to speak, at your local time, and a second pass writes it in your voice and language.
• Each source has a switch that says whether it is connected, you set the window and the channels — there is no daily quota: every pass of the window reaches the decision, bounded by the cooldowns (ADR-328) —, rate every notification, and every pass files what it read in your registers (HEARTBEAT_AUTONOME, GUIDE_HEARTBEAT).

Discussions it opens

• Beyond telling you something, LIA may start a personal conversation when you allow it — off until you switch it on: your hours and daily maximum, each source and sensitive topic chosen, topics to avoid, and four reactions on every opening.
• What LIA understood stays visible: every element of its context can be excluded, deleted, purged or rebuilt, and the last run says why it ended, what it read and what it cost. Each opening is filed as LIA's own act, every call counts under your quotas and three budgets, and an opening touching a sensitive topic stays private — a masked push, never an external channel; an opening left unanswered holds the next one back for an hour, not a day, and the panel says when LIA is waiting for your reply (ADR-358, ADR-359, ADR-360, PROACTIVE_DISCUSSIONS).

Moments served to the minute

• A periodic sweep cannot serve an instant, so a finished meeting or an awaited reply is kept as an anticipated moment, claimed under a lock, revalidated, and served under the full eligibility checker while bypassing only the deferrals.
• Mail watches are answered from the push-driven wake that already holds the Gmail delta (ADR-281, ADR-261).

Routines and reminders

• A scheduled routine or reminder uses the timezone-aware recurrence engine ("every three days", "the 2nd Tuesday of the month").
• A condition routine has no schedule: it is checked at the system's cadence for its source and records a run only when it fires. A weather condition always reads Google Weather and fires only on a change due within the next hours, above a published precipitation threshold, the run told the hour, the day and the source.
• The studio offers one mode at a time, with a week view of actual runs (ADR-268, ADR-322, ADR-265, SCHEDULED_ACTIONS).

Interests and habits, learned with restraint

• An interest is created only on a named ground quoted from your own words, with six exclusion classes and a cap on deletions per run (ADR-166, INTERESTS).
• Habits are learned deterministically from a recurrence ledger, promoted, refreshed or demoted by a nightly job and never on doubt.
• A status you set on a learned window holds for the heartbeat, its scheduling and the assistant's context alike, a missed routine is offered by name, and one learning switch closes every door (ADR-214).

A daily briefing

The home page opens on the date and LIA's living face, then aggregates your sources in parallel with a per-section cache and an LLM synthesis — an agenda on a timeline, an illustrated weather, a Workboard card with exact counts of what waits on you, what LIA holds, what your connections hold and what is overdue — served by a read-only domain outside the agent graph (BRIEFING_DOMAIN). The page fills in as it can: what is ready appears at once, each slower card arrives on its own request under one act, and the greeting and synthesis come once every card is there (ADR-271). A new account starts small: where the instance provides the weather, the dashboard opens on that card alone and a starter checklist asks for the home address first, the other cards one switch away (ADR-307). Meetings and calls read as timelines by day and part of day, and a list that cannot load says so instead of looking empty.

Talk to it

A chat that streams

• Answers arrive over SSE with rich HTML cards, interactive widgets and a per-message cost badge.
• A data card shows everything the source supplied and never invents a missing value — an e-mail's body, every organisation of a contact, conference join points, subtasks, a place's photos (full-screen gallery), reviews and opening hours, a route's alternatives, weather slots, generated-document previews — the detail behind native disclosures; opening one calls nothing. The model reads a versioned semantic view of the answer, never the card's HTML (ADR-332, HTML_CARDS).
• Reply, forward, move an e-mail to the trash or adjust a reminder from its card: the request is prepared in the composer, and the server re-checks the original message, source and account grant. E-mail deletion still passes through approval before changing its original mailbox. A route opens as an interactive Google map whose estimated cost is announced first and every construction counted (ADR-332).
• MCP cards name the server's public origin and the called method above an accessible response disclosure; opening it reveals the received result without another call. Weather icons follow the provider's condition codes and day/night information, across current, daily and hourly forecasts.
• In the rich HTML mode every data-bearing answer is a composed page — a lead sentence, one section per facet in the component that fits it, a closing callout — laid out on conversational turns too unless a voice is reading them (ADR-177).
• Images and PDFs can be attached (vision analysis, text extraction, strict per-user isolation).
• Long conversations are compacted by an LLM summary that preserves identifiers, the history scrolls back page by page without limit, and each answer is shared — to the device's sheet, or to a connection through an ordinary confirmed message — or downloaded as a dated Markdown file in one click. A formatted answer keeps its headings, lists, tables, links and code in that file, its cards summed up as a heading and a few bullets; copying stays plain text (ADR-177).

One conversation across devices and channels

• Once a message is committed, the open chat learns of it and merges the new history without replacing older pages, moving the reader or interrupting an action. Other tabs, calls, routines and external channels become visible without a reload.
• A reconnected tab catches up after an interruption (ADR-320).

Voice, both ways

• Push-to-talk, or the wake word "Dis LIA" — a small trained model run by ONNX Runtime in a browser worker, every file checked against its SHA-256, so no audio leaves the device for detection. "Stop" cuts LIA's voice while it reads an answer. French only for now, in beta; the other interface languages keep tap-to-speak (ADR-329, WAKE_WORD_TRAINING).
• Offline Whisper transcription in the user's own language, or the remote engine the administrator configured (ElevenLabs Scribe, OpenAI or Fish Audio), named before anyone opts in.
• Spoken answers from a catalogue-driven TTS (Edge, free; OpenAI; ElevenLabs; Gemini; Fish Audio), streamed sentence by sentence. Playback can begin before the complete answer is available; startup latency depends on the model, provider and connection (VOICE, ADR-081, ADR-082).
• Every heard sentence is billed once, by the engine that spoke it; ElevenLabs synthesis and every Fish Audio request share an administrator-set allowance per vendor account across API workers and speech surfaces; the browser plays queued audio in sequence, even when synthesis completes out of order.
• On the engines that perform them, LIA's spoken comments carry a few expressive cues (a sigh, a laugh, a whisper) in each engine's own syntax, while text it reads aloud never turns a bracket into a cue. Each cue is chosen from what it means: it colours the news, never how LIA's own act went — a confirmation, a failure or a search that found nothing is said plainly. Administrators manage the instance's Fish Audio voices: clone one under a consent attestation filed in the audit log, design one from a description, rename or delete (ADR-345).
• Each person picks LIA's male and female voice among the voices of the engine that speaks in the chat, kept per provider so a change of model keeps them; every voice picker — LIA's, the radio's, the administrator's slots — can be narrowed to the person's language and the multilingual voices, never hiding a voice already chosen ().

A personal speaking avatar, experimental

• Connect your own Simli account, choose a face and explicitly authorize its use. The operator must first enable the optional capability; it is off by default.
• A floating window with three sizes follows existing voice comments and Live conversations, with touch/pointer dragging and keyboard movement. The avatar and local player share one audible destination.
• The window keeps its explicit stop control even when the chat encounters an error, and reports confirmed or pending closure. Mobile keyboard, rotation and zoom adjustments preserve the chosen placement.
• The connection stays open while the voice mode is active; silence can consume your personal Simli credits. Live standby closes it, and waking opens a new connection. Radio is outside this integration.
• Provider lip motion, long silence, renewal and physical Android/iOS audio remain subject to qualification (SPEAKING_AVATAR, proposed ADR-334).

Live, voice to voice

• A real-time session on a live model the person connects with their own key (Gemini Live over a WebSocket, GPT-Live over WebRTC, or an ElevenLabs agent whose voice stays on its portal).
• The Live provider connection carries audio directly between the browser and provider. With the optional avatar enabled, LIA's spoken output also passes through the API-controlled Simli relay; its provider token stays encrypted server-side.
• In supported Live configurations, the voice model can delegate a data request or action to the chat engine. The delegated turn uses the graph’s approvals, registers and quotas and appears in the thread. Concurrent speech, interruption and delegation behavior depend on the provider, model and mode.
• A provider declares its wire and the seam never branches on its name.
• A direct session holds the read-only tools itself and acts on nothing.
• A silence puts the session on standby instead of ending it: the provider connection closes and nothing is billed until the phrase or a tap wakes it into a new connection; only the person ends a session (ADR-329).
• The provider's own usage is folded into an indicative meter and shown, never recorded — the vendor's bill read once at the end where it has one (ADR-299, ADR-300, LIVE_MODE).

A personal radio, on demand

• A deterministic programme grid blends the listener's day with news from identified sources, over the station's own instrumental music, lowered under every voice.
• Models write and voice the segments, while verification decides what may air. The listener chooses subjects, sources, voices and verification, sees sources and live cost, and ends the session with a timer. Production runs only while someone listens.
• An administrator controls the capability and the guided self-host installer asks before enabling it (ADR-324, RADIO).
• The radio settings group programme, sources, verification, voices and spending so a listener can see what will be used before starting.
• Debates and discussions are voiced in takes on the engines that voice several speakers — never more voices per take than the engine accepts —, each commentator with the voice the listener chose, never one shared with LIA, the anchor or another commentator. Where a programme converses, a chuckle, a laugh or a sigh may open a turn; the news is never read with one. The second-model verification is off unless the listener chooses it, because every check is billed (ADR-324).
• Editorial selection excludes advertisements, sponsorships and purchase pitches while retaining genuine news, scientific reporting, invoices, reservations and appointments. Raw PCM and µ-law speech are wrapped with their actual format before mixing.

An expressive companion

The complete native catalogue uses original designs and contextual expressions. Reviewed offline artwork supplies bounded body relief, while the shared rig owns head pose, eyes, brows and mouth. Reduced motion and unavailable graphics retain their native fallback. See the volume guide for projection and performance limits.

• Psyche temperament, actual tool execution and the delivered answer's tone share one animation rig, including the shaded Smiley. Eyes lead a head with depth and weight.
• Continuous mouth/brow contours, quiet thought and varied resting scenes keep transitions natural. Speech follows actual audio, and a prepared draft never earns an accomplished-action gesture. Fresh cached weather and the account clock add discreet ambience without a provider or LLM call.
• You place the companion — a drag, the arrow keys, or a fold into its restore dot — and on a phone nothing else moves it.
• Reduced motion keeps static contextual poses (ADR-240, ADR-252, ADR-253, ADR-264, ADR-294).

A psyche of its own

• Big Five traits, a mood space, discrete emotions, a relationship stage and curiosity drives shape word choice and rhythm without ever being announced.
• Settings › LIA's psyche draws it — emotion rings around the mood, a pleasure × arousal plane, the Big Five pentagon, relationship and drive meters, an evolution chart on a true time axis — beside the temperament sliders and two reset scopes (PSYCHE_ENGINE).
• An experience per domain learned from evidence, never from its own grade: what an answer verifiably established and the usefulness you expressed (👍/👎) are kept apart, and an index needs several recent observations. Where evidence is thin, LIA checks a point, asks one question or names its limit — a pilot, no gain claimed before a held-out comparison (ADR-348).

Wherever you are

• Six languages end to end (UI, approvals, notifications, Telegram, skills).
• A bidirectional Telegram channel with OTP linking and localized approval keyboards (GUIDE_TELEGRAM).
• Native Android and iOS shells that load your server, with native push and the sign-in flow Google permits (ADR-246, GUIDE_MOBILE_ANDROID, GUIDE_MOBILE_IOS).
• An offline-capable PWA (ADR-146).

Connect your world

Mail, calendar, contacts, tasks

• Google (OAuth 2.1 + PKCE), Apple iCloud (IMAP/SMTP, CalDAV, CardDAV) and Microsoft 365 (Graph API, personal and business tenants).
• One active provider per category; activating one deactivates its competitor.
• Google and Microsoft each offer one consent to connect or reconnect several services on the same verified account, and the connection alert offers it as soon as two services of one provider have expired. Each service can still be disconnected separately (ADR-302, OAUTH).
• Access is renewed through one door: one exchange per token whoever asks and on whichever worker, no transaction held while the provider answers, a write conditioned on the token it started from, and a service marked disconnected only after the provider's refusal is confirmed (ADR-302).
• The SMS your phone receives, relayed by an iPhone Shortcuts automation into an encrypted personal archive — search, sender names from your contacts, erasure and export — with replay-safe receipts and recognised access codes kept out; the assistant reads them only under a separate consent (ADR-357, SMS_INGESTION, GUIDE_IPHONE_SHORTCUTS_SMS).

E-mail, read whole and clean

• The three providers speak one vocabulary at the client boundary: a text body, never HTML, with quoted history and signature removed, measured on real payloads.
• The assistant chooses how much to read from the question: headers to list, a body paginated by paragraph to read, or a digest per message to reason over many. A small model computes each digest once; it is cached thirty days and counted in your usage. If digest generation fails or is truncated, the original body remains available (ADR-287, EMAIL_FORMATTER).
• An attachment is read too — its text when it has one, the vision slot for a picture or a scan — bounded, paginated and treated as what a stranger sent (ADR-296).
• Your mailbox drafts — Gmail, Outlook, iCloud — are saved, listed, edited and trashed from the conversation without a confirmation, since nothing reaches anyone; sending one asks once, on a card that shows the draft as the mailbox holds it, and a draft edited elsewhere since is not sent (ADR-344).

Connected from the first day

• The connectors that ask nothing of the person (Wikipedia, page browsing, Google Places, Weather and Environment) belong to the instance: no per-account row and no entry in « My connectors », always on unless the administrator switches one off for everyone or the instance has no platform key.
• For the weather, a person's own OpenWeatherMap key takes precedence over the instance's default (ADR-307, CONNECTORS_PATTERNS).

Documents, places and weather

• Google Drive folders, sub-folders included, and a Gmail label as knowledge sources, synced incrementally, with the exact number of files stated before a large sync starts (ADR-262, ADR-297).
• Google Maps places, routes and geocoding. A Position card precedes place cards in Cards, HTML and Markdown; interactive Maps starts on a priced click, with an address-list fallback (ADR-352). Each place carries one number in the list and on its pin; selecting it shows the details the answer already gathered and one priced route — walking up to 2 km, otherwise driving — from your position, your last known one or home (ADR-355, ADR-356).
• Weather with change detection.
• A last-known-position cascade so every feature knows where you are, with the age of the fix stated (ADR-219).

Home and body

• Philips Hue lighting by voice (rooms, scenes, local bridge or cloud).
• Daily steps and heart-rate batches pushed from an iPhone Shortcut, idempotently, with baselines, variation detection and charts (ADR-076, ADR-148, GUIDE_IPHONE_SHORTCUTS_HEALTH).

Your own tools (MCP)

• Per-user servers with API key, bearer or OAuth 2.1 authentication (dynamic registration, PKCE), HTTPS-only, SSRF-checked, credentials encrypted.
• Conformant to the protocol's current revision on both halves and reading tool declarations to the letter of JSON Schema 2020-12 (ADR-224, ADR-255).
• MCP Apps rendered as sandboxed widgets behind a CSP airlock (ADR-098).
• An iterative mode where a dedicated agent reads a complex server's docs before calling it (MCP_INTEGRATION).
• A provider's cooldown is shared across workers for that person's server, so another concurrent request cannot restart a wait the service already imposed.
• What a personal server offers is kept as a snapshot every worker shares and served while it is revalidated, so a message waits for none of your servers; one that must be asked again is prepared in parallel under a ceiling and named when it is slow, and a call checks the declaration it relies on before it is sent (ADR-366).

Skills and plugins

• Agentskills.io skills with progressive disclosure, sandboxed scripts and rich outputs (maps, dashboards, calendars, QR codes…), written from a conversation and proposed on a card the person installs in one click (SKILLS_INTEGRATION).
• A public skill library: search skills.sh, read a skill's every file, source, exact version and published audits before installing it at the commit that was read, and update it when its folder moves; a skill from the library, an address or a plugin is third-party — run in an isolated runner, never near a connector, its answer drawn without images or HTML (ADR-327).
• Skills that run their own commands — Python, Node, shell — in a throwaway copy of their folder, from a dedicated sandbox image with no Docker client and no application code; what they write comes back as generated files, and a command reaches only the hosts it declares, through the egress proxy.
• Agent Plugins v1 packages — skills plus streamable-http MCP servers — installed in one step with an exhaustive per-component report (ADR-225).

Trust it

Three registers, sealed on request

• Optional JEV badges qualify displayed emails (professional, personal, spam or phishing/scam; normal, urgent or critical priority) and appointments (professional or personal). Accepted labels also inform the answer. Uncertainty produces no badge; these advisory labels grant no permission and provide no guarantee of safety (ADR-351).

• One row per action (claimed before it happens, closed from an explicit result), one per consultation (which capability read what, when, with what outcome), one per turn.

• Proactive acts and direct reads are recorded too.

• Extractions are complete, never capped.

• An opt-in per-account hash chain makes the registers tamper-evident while preserving the right to erasure, and LIA answers « what did you do? » from them with exact totals (ADR-263, ADR-270, ADR-273, ADR-318, AI_ACT_TRACEABILITY).

Spend that answers to two ceilings

• Every platform-paid token counts against the account's quota and the instance's daily budget.
• A refusal carries a dedicated code and a Retry-After.
• Where each module's spend is recorded is declared and guarded, never inferred.
• The rule covers more than model tokens: every euro the platform pays for a person — a Maps lookup during a call, the briefing's weather, a photo shown, a voice synthesis — reaches their ledger whatever the path. One persistence predicate covers every family the tracker holds, and a counter fails closed into an alert (ADR-216, ADR-272, USAGE_LIMITS).
• Spend uses the price the provider bills: tariffs read from the vendors' pages, a prompt-cache write billed at its price, a pricing window that names its days, a Maps call filed at the SKU its request triggers, and every tariff writer reaching every worker (ADR-306, LLM_PRICING_MANAGEMENT).
• Every reported model attempt keeps the tariff and exchange rate captured when it started. Paid failures, retries and background work reach the same ledger, including work that finishes after a cancelled conversation; missing usage is not invented (TOKEN_TRACKING_AND_COUNTING).

Strong authentication

• WebAuthn passkeys, a TOTP second factor with backup codes, step-up re-authentication on sensitive actions, device sessions with per-device revocation, server-side Redis sessions behind HTTP-only cookies (ADR-143, ADR-144, AUTHENTICATION).
• A federated sign-in proves an address, never a right — it can neither activate nor unblock an account (ADR-002) — and every « who is calling? » reads one resolver (ADR-213).
• A client that probes unknown routes or keeps failing to sign in is banned for a while by every API worker at once, ordinary errors never counted, and every « too many requests » names its client in the logs (ADR-353, ADR-354).
• A password reset answers for one account: one decision when the link is asked for and when it is used — nothing for an administrator, a notice and never a link for an account that signs in with Google without a password —, an e-mail budget per account whoever asks, and a link bound to the account and to its password; an administrator's way back is a command on the server (ADR-363). An optional Cloudflare Turnstile anti-robot check guards sign-up, sign-in and the reset request, and when Cloudflare cannot answer only the sign-in proceeds (ADR-364).

Your data, by construction

• Credentials are encrypted with Fernet. Logs keep facts, never the words of the people they concern; the guard checks the value rather than the field name (ADR-317).
• A full-account GDPR export is available (ADR-145). External content keeps its provenance through compaction, and its envelope holds in every spelling (ADR-167); mail servers present a verified certificate before any login.
• Skill scripts run in a throwaway container. Automated backups have a tested one-command restore (ADR-109, SECURITY).

Exact where it must be

Arithmetic, dates and currencies use tools in both execution modes, never a model's estimate:

• Calculations are parsed and evaluated in exact decimal, with rounding stated.
• Durations are counted between absolute instants across a clock change.
• Currency conversion uses the European Central Bank reference rate with its date (ADR-318).

Failures made visible

• One status vocabulary whose every member is produced and read, one success predicate for the register, the metrics and the ReAct loop, a structural failure marker on the ReAct message, and an honesty directive that names the tool that failed and the exact total, so the response has the recorded failure evidence instead of an unexplained gap (ADR-303).
• Each step of an answer says what it did — how many calls, results found and read, failures — live and in the trace kept with the message (ADR-133).
• Every act is filed under its own turn and stated to the response as the assistant's own (ADR-263).
• A notification is filed delivered only once it was archived, pushed or sent on a channel — an SSE event alone never counts (ADR-263).
• No database transaction stays open while a provider answers, and the database bounds what the code might forget — a lock wait, an idle transaction — counting and alerting every bound it reaches (ADR-304).
• A routine never asks a question nobody can see and never repeats an action after a timeout; an e-mail is sent once, and a provider's rate limit is waited out rather than reported as an outage (ADR-276).
• A call whose outcome is unknown is never repeated: no model generation is relaunched after a timeout or once its stream began, and a calendar create carries the provider's own idempotency, so a lost answer never makes a second event (ADR-221).

Switches, not redeploys

• Every capability switches off from the admin panel, each declaring where it is enforced.
• The tools a switched-off capability names leave both execution modes at once: the switches are applied to the turn's catalogue once, and the Pipeline planner, the ReAct loop, a delegated sub-agent and a skill's ready-made plan all read that same catalogue; the Workboard, LIA connections, MCP servers and Skills switches name no tools and close their pages alone (ADR-280).
• A switch removes the capability, never the record (ADR-217, ADR-280).

LIA World

An isometric campus makes LIA's capabilities places you can visit. Explore its rooms and garden with keyboard or touch, use the minimap and camera controls, and let LIA accompany you. Daylight, optional cached weather and separately controlled sounds give the place atmosphere without calling a model for decoration.

• Your familiar assistant, in a place: rooms and the Functions menu open private native panels for conversations, meetings, knowledge, Relations and other enabled activities. Drafts, approval requests, costs and quotas follow the same application rules.
• Your own home and appearance: start from one of ten editable appearances or build your avatar, and choose your home's colour palette. Home contents and native assistant data do not enter shared presence.
• A place to meet: consent to showing your native account name, see other admitted people and exchange direct or explicitly public text. A quick bar addresses the nearest reachable person, otherwise the public channel, and shows the destination before you send. Six gestures greet without a word. Translation requires an explicit choice and uses the configured model and spending controls. Coarse presence information is shared with accepted, unblocked connections.
• A place to play: three arcade cabinets — tic-tac-toe, four-in-a-row and Reversi — for two people or against a deterministic computer. The server confirms every move and result; playing calls no model.
• A place that answers: sit at a table and choose whether to open your full dashboard; familiar objects show your own fired reminders, messages and tickets; LIA's face follows what it is really doing; seasons, the pond, the fountain, lamps and machines react locally. A private photo keeps the moment — your avatar, LIA and the scenery only — to download, or share where your device offers it.
• A bounded shared space: the server admits people, manages the waiting queue and validates movement. Losing authority suspends interaction until reconnection; a second tab cannot silently take control.

World is optional and starts disabled in the minimal installer. An operator enables it for the instance, with the native capability policy still applying. Live voice with LIA remains its existing feature; direct voice between people is a separate proposal. See the World guide, architecture decision and the qualification ledgers (World, interactions and play) for implementation, evidence and remaining physical-device/provider checks.

---

What is LIA?

LIA is an open-source personal AI assistant in a web application you can host yourself. It connects the information you make available — emails, calendar, documents, preferences and commitments — to help you prepare conversations, organize your day and follow through.

Its strength is the continuity between those activities. Memory, knowledge spaces, meeting records and Relations, its personal relationship view, make relevant context available for the next supported request. A preference you correct, a document you keep or a commitment you record can become useful again. Each feature contributes through its own sources, permissions and settings.

LIA also helps between conversations: a daily briefing, a personal Radio, reminders, routines, proactive suggestions and, when you allow it, a personal discussion it opens itself. You choose the sources and enabled features, and the time windows and channels for proactive help. Chat, rich cards, voice and Live sessions keep this assistance accessible in the same application.

LIA World gives that assistance a place. Walk through a shared campus with LIA, open your private workspaces from its rooms, return to your own home or exchange text with other people. The world is shared; your assistant's conversations, documents and home preferences stay private. The operator chooses whether to enable this optional experience.

You can inspect sources, correct remembered information and review prepared drafts. Actions covered by approval flows ask for your decision before execution. Registers expose recorded consultations, action attempts and outcomes; usage and budgets are visible to users and operators.

Start with something that would help you

Your situation	Ask LIA, or use its dedicated view
A discussion to prepare	“Prepare my catch-up with Claire using the project brief, our recent emails and the last meeting notes. Highlight anything that conflicts.”
A promise to follow up	Open Relations to review recent exchanges, the debrief and open commitments before contacting someone.
A message to get right	“Draft an email to the supplier asking which delivery date they can commit to. Show me the draft before sending it.”
A meeting to keep useful	Record it, review and correct the minutes, search their full content, then export a PDF. Successfully indexed minutes can be retrieved in a later conversation.
A day to listen to	Choose personal and news sources in Radio, then listen with the programme, transcript and articles beside you.
People to coordinate with	“Find a time for dinner with Sam tomorrow evening using the availability shared with me. Show the invitation before sending it.” This uses an accepted connection and its permissions on the same instance.
A place to work and meet	Enter LIA World, find LIA in the campus, open your private calendar or meeting records, then exchange a message with another person without sharing your assistant's context.

These examples use the services and permissions enabled on your instance. Generated conclusions and documents remain yours to review.

What LIA brings together

What matters in daily use	What LIA provides
Relevant context, ready to reuse	Memory, knowledge, meeting records, saved answers and Relations support relevant requests from their authorized sources. You can inspect and correct what is kept.
Help when you ask and between requests	Conversation, daily briefing and personal Radio, alongside reminders, scheduled work, conditional routines, proactive suggestions and opt-in discussions with their own source and timing controls.
A clear next step	Rich results, reviewable drafts, downloadable documents and compatible skills or MCP apps present information and controls in the appropriate form.
A choice of how to work	Pipeline builds and validates a plan before execution; ReAct explores iteratively from tool results. Chat and Live voice use documented provider and mode capabilities.
One installation for several people	Separate accounts have their own connectors, memory and preferences. Accepted connections choose what to share and can exchange messages through their assistants.
A system you can inspect and operate	Open code, a documented architecture, registers, model configuration, account and instance budgets, administration, Grafana dashboards and alert rules.

Cloud models and compatible local models served through native Ollama can be configured for supported processing roles. Model capabilities, host resources and enabled external services determine the available features and where information is processed. Hosting and provider services may incur costs.

A foundation for an internal company assistant

Preparing meetings, retrieving business knowledge and following commitments can also help colleagues. LIA's multi-user web application, connectors, MCP, APIs and observability provide a foundation to customize and integrate into your organization.

Define the deployment's identity, permissions, business sources, usage rules, integrations and hosting. The architecture, documentation and self-hosting guide help scope that work.

---

Screenshots

Browse the views that interest you; open any image at full resolution.

The Administration & Monitoring section below includes the three Grafana views supplied by the project.

The World illustration above is the owner's supplied French application capture, published with this release. It is an unmodified illustration of the current interface; its visible account name is part of that supplied image. Its provenance manifest distinguishes it from the automated fictional-data captures below.

Explore the real application interface in English and light mode, filled with fictional demonstration data. The geographic maps and walking route use real Google Maps imagery and geographic data, prepared separately and served locally with attribution. The browser captures exercise the actual pages, controls and widgets without model inference, provider calls, connected accounts or external actions. Radio uses a local silent audio fixture. The interactive budget is a custom skill example produced by an executed Python fixture generator; its estimates are illustrative and no booking is made.

Open any image at full resolution. The home capture manifest, workflow manifest and extended application manifest record the images and their provenance. Reproduce the campaigns with the public capture workflow, workflow runner and extended capture runner.

---

Product presentation

Watch or download the complete film. The French presentation follows concrete uses, contextual native avatars, display modes, reminders, Relations, planned actions, administration and the installable mobile web application. Interfaces follow the product's UI with fictional demonstration data. The landing's blue Presentation button opens the full film with sound and controls in an exclusive fullscreen player.

The editable construction, production and update procedure and decision record preserve the scenario, native-view sources, feature focuses and soundtrack provenance for future product updates. Release assets include a checked editable source archive. The video is a product demonstration, not a recorded provider session.

---

Administration & Monitoring

The admin interface brings deployed capabilities, accounts, model configuration, budgets and diagnostics into one place. The observability stack adds metrics, logs, traces and alerts. Deployment settings still define which services and capabilities are available.

Admin Dashboard

Area	What you control
LLM configuration	The model behind every node and slot, provider parameters, prompt versions, the context window per slot
Bounded JEV decisions	An independent opt-in switch for each native decision, a general switch, dedicated model and price settings, and diagnostic traces of duration, fallback and spend; uncertain results return to the established path (ADR-325, guide)
Model catalogue & pricing	Providers, capability flags, accepted reasoning depths, a provenance badge and prices per model — the source of truth for the LLM factory, with its status against the public registries; image-generation and Google API pricing alongside; live cross-worker invalidation
Platform capabilities	One switch per capability, grouped in families, each row showing the deployment bound, the operator choice and the state actually enforced
Budgets & limits	Per-user token, message and cost quotas with live gauges; the instance daily ceiling in euros, today's spend and what remains
Knowledge & skills	Knowledge spaces and reindexation, the system FAQ space, skills (enable, translate, delete), admin MCP servers and plugins
People & voice	Users with every per-account switch as a sortable column, roles, connector health, assistant personalities, the TTS catalogue and voice picker
Platform health	Incidents and their diagnoses, each shown with the evidence it was written from
Registers	Readable, technical and Article-12 extractions over one, several or all accounts — masked unless audited
Broadcast, debug, demo	Announcements to everyone or to chosen accounts, each stored with its recipients and listed with its audience; per-user debug verbosity, the public showroom link, CSV consumption exports

Real-Time Debug Panel

A panel embedded in the chat, organised into six groups; an empty section shows "N/A" rather than disappearing.

Group	Sections
Request Analysis	Intent classification, Domain detection, Routing decision, Query transformations
Planning & Execution	Planner output, Tool selection, Context resolution, Token budget, Execution timeline, ForEach analysis, Execution waves
Intelligent Mechanisms	Cache hits, pattern learning, semantic expansion, Skills activation
Context Injection	Memory injection (scores), RAG injection (scores), Knowledge enrichment (Brave), Journal injection (per-entry scores, budget)
Background Extraction	Memory detection (create/update/delete), Journal extraction, Interest profile
LLM & API Pipeline	Request lifecycle (timing breakdown per node), LLM Pipeline (chronological reconciliation), LLM call details (model, tokens, latency, cost), Google API calls

Built for developers and operators: diagnose, optimise prompts and understand the agent's decisions in real time — no external tool, no log access needed (DEBUG_PANEL).

Observability

• Prometheus: 652 custom metrics (agents, LLM, infrastructure), labelled by route template — a name or a search in an address never becomes a series. A metric nobody can see is a metric nobody acts on: every one must be wired to a Grafana panel, a recording rule or an alert, and a shrink-only ratchet fails the build on a newly blind metric — and the reverse holds: every panel reads a series something produces.
• Grafana: 33 dashboards, including product-value and radio cockpits · Loki: structured JSON logs that keep facts, never people's words, shipped by Grafana Alloy (ADR-317) · Tempo: distributed tracing, spans named by the route template · Langfuse: LLM tracing with prompt versions. The whole stack runs on supported versions, pinned by digest.
• Linked signals, a pipeline that watches itself: a log line opens its trace, a trace its logs and metrics, a latency point its exemplar; Loki, Alloy, Tempo and Grafana are scraped on closed keep-lists and LogsNotDelivered fires when lines go missing; every dashboard opens on seven days (logs and traces on four hours) behind one shared menu — ADR-333.
• Probes: liveness (GET /health) split from readiness (GET /ready, 503 unless PostgreSQL and Redis answer) — ADR-115.
• Alerting: a vital core (service, database and Redis down, disk, OOM, 5xx rate, SSE latency, backup failure, public-endpoint and TLS probes, chain self-monitoring) evaluated by Prometheus, emailed by a dedicated Alertmanager, unit-tested with promtool, every alert linking its runbook. The latency alert observes only turns a person waits for, and only over enough of them for a p95 to mean something; the operator's daily report opens on the alerts that fired, the incidents still open and the container restarts, each source named when it cannot be read. One Alertmanager template drops what is not configured, every severity reaches the team receivers it announces, deduplicated, and the routing matrix runs against the production image's real entrypoint — ADR-119.

---

See the instance from the operator's side

These three Grafana screenshots were supplied by the project owner and reproduced unchanged. Their figures show the supplied dashboard state; the Grafana manifest records their origin and dimensions.

---

Architecture

Three layers: a Next.js front end (chat, settings, six languages, SSE streaming, voice) talking over HTTP-only cookies to a FastAPI backend, whose LangGraph graph orchestrates the agents and tools; PostgreSQL (data, checkpoints, pgvector) and Redis (cache, sessions, rate limiting, locks) underneath, with Prometheus, Langfuse, Loki and Tempo watching. The backend follows Domain-Driven Design: one bounded context per domain, each with its router, service, repository and schemas.

Two Execution Modes

Switchable per user from the chat header:

• Pipeline (default) — a Planner decomposes the request into an execution plan (a small DSL with dependencies, conditions and FOR_EACH iteration), a Semantic Validator checks its coherence, tool-level approval flows review the actions that require confirmation, and a Task Orchestrator runs the tools in parallel waves; Bayesian pattern learning shortens the next similar request. Planning and validation precede execution; token use depends on the task and selected models.
• ReAct (⚡) — the model reasons iteratively, calling tools one by one and adapting to each result. Suited to exploratory, research or ambiguous queries; cost and latency depend on the work and selected models. Its iteration budget is extended while the loop keeps producing results, a turn that stops mid-flight closes its own books, the tools it binds are chosen by relevance to the question rather than cut by a cap — or all of them, when the person chose frequent exchanges so the provider's cache reads each turn back from the previous one — and a turn is judged on its result: a gap it declares buys a bounded recovery pass.

graph TD
    A[User Message] --> CP[Compaction]
    CP --> B[Router Node]
    B -->|conversation| C[Response Node]
    B -->|pipeline mode| D[Planner Node]
    B -->|react mode| R1[ReAct Setup]
    D -->|empty plan| C
    D --> E[Semantic Validator]
    E -->|ambiguous| CL[Clarification]
    CL --> E
    E -->|replan| D
    E --> F{Approval Gate}
    F --> G[Task Orchestrator]
    G --> H[Domain Agents + Tools]
    G -->|drafts| HD[HITL Dispatch]
    G -->|bulk action| FE[FOR_EACH Confirm]
    FE -->|approved| G
    H --> I[Initiative]
    HD --> I
    I --> C
    R1 --> R2[ReAct Call Model]
    R2 -->|tool_calls| R3[ReAct Execute Tools]
    R3 --> R2
    R3 -->|draft| HD
    R2 -->|declared gap| R5[ReAct Recovery]
    R5 --> R2
    R2 -->|done| R4[ReAct Finalize]
    R4 --> I
    C --> J[SSE Stream]

Code Structure

apps/api/src/
├── core/                 # Settings composed per domain, constants, i18n tables, recurrence engine
├── domains/              # Bounded contexts (DDD); shared helpers stay separate
│   ├── agents/           # The LangGraph graph: nodes (router, planner, react ×4, response…), tools, prompts, orchestration
│   ├── connectors/       # Google, Apple and Microsoft clients behind one provider resolver
│   ├── heartbeat/ proactive_discussions/ moments/ scheduled_actions/ reminders/ habits/ interests/ briefing/  # initiative
│   ├── memories/ journals/ rag_spaces/ meetings/ relations/ peers/ sms/ workboard/ attachments/               # what LIA keeps
│   ├── auth/ users/ usage_limits/ capabilities/ feature_switches/ diagnostics/              # control
│   └── voice/ skills/ plugins/ user_mcp/ telephony/ document_generation/ image_generation/ …
└── infrastructure/       # Cross-cutting: cache and Redis key families, LLM factory and providers,
                          # MCP client pool, browser pool, rate limiting, scheduler, startup steps, observability
apps/web/src/             # Next.js App Router under app/[lng]/, components, hooks, stores, six locales
apps/mobile/              # Capacitor shells for Android and iOS, loading a self-hosted server
infrastructure/           # Compose stacks, database seeds, observability config, backups, Caddy
scripts/                  # Release, audit, deployment and measurement tooling
docs/                     # Architecture, technical documents, guides, runbooks, ADRs, the public audit

Key Design Patterns

Pattern	What it buys
Five-layer tool system	A generic connector base with OAuth auto-refresh, a meta-decorator composing metrics + rate limiting + context save, domain formatters, a declarative ToolManifest, and a catalogue loader — a tool is a few lines, not a file
Domain taxonomy	One declarative DOMAIN_REGISTRY (agents, result key, related domains, priority, routability) feeds catalogue filtering, semantic expansion and the initiative phase — never a second hand-maintained table
Data registry	Tool results live in an in-memory store decoupled from the message history, so aggressive message windowing never loses a $steps.X.field reference
Semantic validator	A dedicated LLM, distinct from the planner, inspects every plan for hallucinated capabilities, ghost dependencies, cardinality and scope errors before anything runs
Re-plan before running	Validator issues go back to the planner a bounded number of times, and panic mode retries planning once over a wider catalogue; once a plan has run, a failed step is stated in the answer, never replayed
Connector abstraction	Python protocols and normalisers make Google, Apple and Microsoft interchangeable behind unified domain models; a resolver guarantees one provider per category
Published bounds	Whatever a validator can reject, its producer can read: every enforced limit is published to the planner, and what is mechanically repairable is repaired before validation (ADR-184)
Exact counts	A number shown to a person is exact or it does not exist — aggregates over the whole set, pages of rows, never a count derived from a capped page (ADR-185)
Boot-time completeness	Every registry keyed by an enum or a domain is asserted complete at startup; the app refuses to boot on a missing entry rather than failing silently later

The long version: How does LIA work? (public architecture guide), ARCHITECTURE.md, ARCHITECTURE_LANGRAPH.md, and the living maps — the functional map, the technical map and the history of every decision, also published in six languages on the public site.

---

Technologies

Stack

Layer	Technology	Role
Backend	Python 3.14 · FastAPI 0.141.1 · Pydantic 2.13.4 · SQLAlchemy 2.0.54 · Alembic	REST API, SSE streaming, validation, async ORM, migrations
Orchestration	LangGraph 1.2.14 · LangChain 1.3.15 · mcp SDK (Streamable HTTP)	Multi-agent graph, LLM abstraction, Model Context Protocol
Data	PostgreSQL 16 + pgvector · Redis 7.4	Data, checkpoints, vector search · cache, sessions, locks
Frontend	Node.js 24 LTS · Next.js 16.4.2 · React 19.3.1 · TypeScript · TailwindCSS · Radix UI · TanStack Query · react-i18next	App Router UI, accessible primitives, server state, six languages
Voice	ONNX Runtime Web (wake word) · sherpa-onnx (offline Whisper) · Edge TTS · OpenAI · ElevenLabs · Gemini · Fish Audio	In-browser detection, server transcription, speech synthesis
Observability	Prometheus · Grafana · Loki · Tempo · Langfuse · structlog	Metrics, dashboards, logs, traces, LLM tracing
Delivery	Docker (multi-arch amd64/arm64) · GitHub Actions · Task	Images, CI/CD, one build tool for every command

The UI is responsive by design — desktop, tablet and phone — with touch-friendly, mobile-first components.

Supported LLM Providers

The model catalogue lives in the database, curated from vendored public registries and editable from the admin panel; every row states where its capabilities came from, and a slot's output budget is held to the cap a vouched row declares, flagged on the configuration screen when it exceeds it (ADR-244). Reasoning depth has one stored shape for every provider (ADR-245); a model family is declared once, and a caller that needs two sentences asks for no reasoning rather than a small budget — a reasoning model bills its thinking inside max_tokens (ADR-285). What a prompt says is what the code enforces, and nothing else: every placeholder has a producer, every published bound is the applied bound, prose never lives in a .py (ADR-284). Every prompt follows one layout — stable before volatile, one boundary each provider adapter translates into its own cache mechanism, no cache write nobody reads — and what each model generation accepts is measured on its API and declared once (ADR-309, ADR-306).

Provider	Notes
OpenAI	Prompt caching, reasoning models, structured output
Anthropic	Extended and adaptive thinking; request surface declared per generation, prompt cache read back across turns and its writes billed
Google	Gemini, multimodal; gemini-embedding-001 for retrieval
DeepSeek	Cost-effective reasoning with a thinking-mode toggle (deepseek-flash, deepseek-v4-pro); tariff by UTC window
Qwen	Thinking, tools and vision through Alibaba Cloud DashScope; explicit prompt cache where the family needs it; Qwen Image 3.0; regional endpoint via QWEN_BASE_URL
Perplexity	Web-augmented answers; endpoint via PERPLEXITY_BASE_URL
Ollama	Compatible local models, capabilities discovered from the server, native client; OLLAMA_BASE_URL

Local Models as First-Class Models

Compatible chat models hosted on your own machine can serve processing slots whose required capabilities they meet. Image generation, embeddings, Live and native decision providers have their own supported paths. Local inference depends on the chosen model and host resources. LIA drives Ollama through its native API rather than an OpenAI compatibility layer (ADR-267):

• Thinking is controlled, not endured — the configured depth reaches the server as think, including switching it off, and the thinking trace comes back separated from the answer.
• The server declares the capabilities — tools, vision, thinking and context length are read from the tag listing, so a depth never reaches a model that cannot think and a control a local model would ignore is not offered.
• The context window belongs to the configured slot (ADR-278) — a frugal router and a generous responder can share one model with different windows; it is the number LIA asks for and the number it counts with.

---

Quality: Tests, CI/CD, Security

Tests

task test:backend:unit:fast        # fast unit suite, parallel (what the pre-commit hook runs)
task test:backend:unit:coverage    # the CI unit suite verbatim, measuring coverage
task test:backend:coverage         # the coverage floor, on unit + integration together
task test:backend:integration      # requires PostgreSQL + Redis
task test:backend:agents           # LangGraph agent suite
task test:frontend                 # vitest
task test:e2e                      # Playwright + axe journeys (hermetic, mocked API)

Metric	Value
Backend tests	54,033 collected over tests/, across 3,636 files (pytest --collect-only -q --no-cov, Windows/Python 3.14, 2026-10-28)
Frontend tests (vitest)	15,161 across 1,317 files (vitest list, 2026-10-28), plus hermetic Playwright journeys with axe, dark-mode and zoom checks
Coverage floor	78% enforced in CI on the backend — a shrink-only ratchet, never lowered; frontend thresholds per glob
Technical audit	Method, evidence and open findings — full public report & protocol

Tests are risk-driven and behavioural: a module never disables itself on a missing provider key, a test double that receives a coroutine owns it, and an unawaited coroutine or a post-summary warning is a failure (GUIDE_TESTING).

CI/CD

Two layers: a local pre-commit hook (fast, on staged files) and a GitHub Actions pipeline on every push and PR to main. The workflow orchestrates and the Taskfile implements: every CI step is a task <name> call, so the pipeline runs literally the command a developer runs, and a guard fails on any inline step.

Pre-commit (local)              GitHub Actions CI
===================             ==================
.bak files check                Lint Backend (Ruff + Black + MyPy strict)
Secrets grep                    Lint Frontend (ESLint + TypeScript)
Ruff + Black + MyPy             Fast unit tests + coverage floor
Fast unit tests                 Integration tests (PostgreSQL + Redis)
Critical pattern detection      Agents suite
i18n keys sync                  Code hygiene (i18n, Alembic, lockfiles, patterns, docs)
Alembic migration conflicts     Docker build smoke test
.env.example completeness       Secret scan (Gitleaks)
ESLint + TypeScript check       ──────────────────────
Pre-push: secret scan           Security workflow (weekly)
                                  CodeQL (Python, JS/TS, Actions)
                                  Dependency audit (pip-audit + pnpm audit)
                                  Trivy filesystem scan
                                  SBOM generation
                                Dependency watch (weekly, ADR-331)
                                E2E + a11y matrix: Chromium · Firefox · WebKit (weekly)

Practice	Implementation
Reproducible builds	Universal Python lockfiles (linux/amd64, arm64, Windows), hash-verified installs everywhere, a guard failing manifest edits without lock regeneration (ADR-112)
Supply chain	Every GitHub Action pinned by commit SHA and every production build input by version and digest, permissions: contents: read; a weekly watch of the advisories each dependency publishes, a refresh under a cooling-off period that never moves backwards, Dependabot on the same cooldowns (ADR-331); the CI's secret scan before every push; SBOM per release
Shrink-only ratchets	Coverage, file size, cyclomatic complexity, MyPy debt, React hooks, accessibility and metric visibility can only improve — a baseline is lowered after the work, never raised to absorb a regression
Coverage where code runs	The backend floor holds over the unit and integration suites together, combined strictly, and the lines a change adds are held at the floor in CI (ADR-113)
Findings register	Every audit finding lives in a machine-readable public register checked on every documentation build: a closure or a remediation carries its proof, and a release is refused while a priority finding is overdue (AUDIT_PROTOCOL)
Documentation gate	Every version, count and threshold a document states is recomputed from the code that owns it and a mismatch fails the build; broken links, stale code paths and unreachable documents too
Release pipeline	A tag builds candidates; a release is promoted only from a qualified, disposable-machine installer run (ADR-215); multi-arch images on ghcr.io

Full details: CI/CD documentation.

Security

Reference	Concrete measure
GDPR / RGPD	PII filtering, data minimisation, full-account export and account deletion that also removes linked OAuth grants and transparency records (privacy guide)
EU AI Act	The interface identifies LIA as AI; approval before mutation and separate records of actions, reads and decisions support transparency and traceability. Applicable duties still depend on the deployment and use case (traceability boundaries)
OWASP Top 10	XSS, SQL injection and CSRF safeguards; a global Redis-backed rate limit before routes; request bodies bounded before they are read, webhooks included; reset links bound to their account and capped per account, an optional anti-robot check on the password doors (ADR-363, ADR-364)
Prompt injection	External content wrapped in safety markers, trust classified by data type rather than by producing tool, and a provenance that survives history compaction — a summary built from third-party text inherits its banner instead of promoting the claim to system authority
SSRF & hostile text	Every fetched URL is validated, then fetched on the very address the check resolved, one redirect hop at a time; text flatteners run in linear time on hostile input, held by growth and equivalence tests (ADR-326)
OAuth / PKCE	PKCE S256, single-use state and issuer/identity checks; grouped Google/Microsoft consent shares grants only within the verified provider account, and every token renews through one door (); linking a federated identity never changes an account's status ()

These references describe implemented controls, not a GDPR/AI Act legal opinion, OWASP or ISO certification, or a security-audit score. The public technical audit measures 24 technical-quality areas against an ISO/IEC 25010:2023-inspired grid and explicitly excludes security.

Reporting a vulnerability — do not open a GitHub issue. Write to [email protected] with a description, the steps to reproduce and the potential impact; we answer within 48 hours. Policy and supported versions: SECURITY.md.

Performance

Instrumentation and caching are in place — per-node message windowing, LLM context compaction with a threshold derived from the response model's window, prompt caching shaped for every provider mechanism (breakpoints, explicit markers, implicit prefixes) with a cross-turn cache for ReAct that the exchange rhythm switches on, asymmetric Gemini embeddings, parallel execution of independent domains, persistent HTTP pools — all instrumented in production. The perceived response time is dominated by the LLM call cascade (seconds to tens of seconds depending on the request and the hardware); that is the optimisation programme in progress. The technical audit describes the current performance limits: no sustained load campaign has been executed yet, and the figures will be published when one has.

---

Documentation

Entry point	What it covers
GETTING_STARTED.md	Detailed installation guide
ARCHITECTURE.md	Complete system architecture
INDEX.md	The full documentation map
Living maps	A functional map, a technical map and the illustrated history of every decision — interactive pages on the public site (/maps, six languages) and offline French documents, from one set of data checked on every commit
CLAUDE.md	The engineering rulebook the AI works under — its systemic rules, each paid for by a measured defect

Domain	Documents
Agents & LLM	ARCHITECTURE_LANGRAPH • PLANNER • SEMANTIC_ROUTER • LLM_PROVIDERS
HITL & registers	HITL • AI_ACT_TRACEABILITY • PROVENANCE_AND_CAPABILITIES
Voice & meetings	VOICE • VOICE_MODE • MEETINGS
Memory & knowledge	LONG_TERM_MEMORY • MEMORY_RESOLUTION • JOURNALS •

Guide	Description
GUIDE_DEVELOPPEMENT	Complete development workflow
GUIDE_AGENT_CREATION	How to create a new agent
GUIDE_TOOL_CREATION	How to create a new tool
GUIDE_TESTING	Testing strategy
GUIDE_DEBUGGING	LangGraph and log debugging
GUIDE_SELF_HOSTING	Production self-hosting

Architecture Decision Records

364 ADR files (ADR-001 through ADR-366 — ADR-008 has no separate file) record every major architectural decision with its context, the alternatives and, increasingly, the production measurement that motivated it. Three to start with, and the full index:

• ADR-070: ReAct Execution Mode — why two execution modes rather than one
• ADR-263: Execution Authority Chain and Effect Register — how every act is claimed, closed and recorded
• ADR-184: Published Bounds and Non-Prescriptive Verdicts — an enforced-but-hidden bound is a trap, not a contract

---

About the project

I choose the product's direction, its architecture and the details of its everyday use. I use AI tools to help write the code, with a written engineering rulebook, automated checks, reviews and adversarial audits. I remain responsible for what ships.

The full story covers the method, trade-offs and work still to do.

60 backend domain packages	1,059,000+ source lines (excl. tests)	69,000+ inventoried automated tests	364 ADRs
292 versions shipped	6 languages, parity enforced in CI	652 Prometheus metrics	Technical audit and protocol

Source-line figure: 1,059,000+ physical lines in Python, TypeScript, JavaScript and CSS under apps/api/src and apps/web/src, excluding test directories and *.test.*/*.spec.* files (measured 2026-10-30). The domain figure counts backend domain packages. Test inventory combines backend collection and the frontend suite; release qualification executes the repository's required gates. The published technical audit does not score security.

• The full story — method, trade-offs, results and what remains to be done, weaknesses included: lia.jeyswork.com/story
• The audit itself — the method, executed evidence, open work and full report: docs/audit/

Full changelog

Your day. LIA keeps up. You decide. Designed in France, open source, self-hostable, with a six-language interface.

---

Contributing

Contributions are welcome — bug fixes, features, documentation, tests, translations in the six supported languages, performance work. Start with the Contributing Guide.

git clone https://github.com/YOUR-USERNAME/LIA-Assistant.git && cd LIA-Assistant
git checkout -b feature/my-feature
task setup                          # backend + frontend + git hooks
task test:backend:unit:fast         # develop and test
git commit -m "feat(agents): add weather forecast agent"   # Conventional Commits
git push origin feature/my-feature  # then open a PR

• Python: Black + Ruff + MyPy strict · TypeScript: ESLint + Prettier · Commits: Conventional Commits
• Before pushing: task ci:fast runs every CI gate that needs no service; task pre-commit is what the git hook runs
• Rules that are not stylistic: read the Systemic Rules in CLAUDE.md — each one closes a bug class measured in production, and a guard enforces most of them

---

Support

Channel	Usage
GitHub Issues	Bugs, feature requests
GitHub Discussions	Questions, ideas
[email protected]	General inquiries

Also: the documentation index, the practical guides and the operational runbooks.

---

License

Copyright (c) 2024-2026 LIA Contributors.

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0) — see LICENSE.

A commercial license is available for organizations that cannot comply with AGPL-3.0 terms: contact [email protected].

---

Acknowledgments

LIA stands on excellent open source work: Python, FastAPI, LangGraph and LangChain, SQLAlchemy, Pydantic, Alembic, PostgreSQL with pgvector, Redis, structlog, Edge TTS, sherpa-onnx, Docker; Node.js, Next.js, React, TypeScript, TailwindCSS, Radix UI, TanStack Query, react-i18next; , , , and ; and the , and open standards.

---