Stack

Agora89 is a Python/FastAPI application backed by PostgreSQL, Redis, and Celery. The frontend is server-rendered Jinja2 + HTMX + Alpine.js — no single-page framework, no build step, no Node.js runtime in production. We made that choice deliberately: a smaller surface, fewer moving parts, and no transitive npm dependency tree. Everything user-facing is one HTTP round-trip away from the database.

The platform runs on a single Hetzner box behind Caddy, with Postgres, Redis, the FastAPI app, a Celery worker, and Celery Beat as separate systemd units. Daily pg_dump → R2 backups are scheduled by cron.

AI Assistant

The assistant is not a coding agent for large codebases. It is built around two strengths: a state-of-the-art memory system and a high-end reasoning model (Anthropic Claude Sonnet for the main turn, Haiku as a fallback and for cheap pre-passes). For administrative work, knowledge retrieval, and bibliographic research that combination is overkill in the best sense — fast, accurate, and cited.

Custom tools cover the parts our users care about: search the news feed, search posts and the marketplace, search the media library, list the agenda and reminders, look up profiles, write notes and reminders, remember and forget facts, and — when warranted — search the open web via Brave plus Anthropic's native web_search and code_execution server tools. A monthly €120 hard budget is checked on every request.

Memory system

Memory is the part we put the most thought into. It has three layers:

1. Typed facts — subject / predicate / object triplets with one of five fact types (identity, preference, relationship, state, event), per-type TTL, and full supersession lineage (valid_from, valid_to, superseded_by_id). Extracted post-turn by a Haiku Celery task.
2. Episodic chunks — conversation snippets stored in Postgres with a pgvector HNSW index (384-dim MiniLM embeddings) plus a tsvector GIN index for keyword search. Hybrid recall combines cosine 0.55 + BM25 0.30 + recency 0.15 (30-day half-life).
3. Active-memory pre-pass — a small Haiku call picks the top ≤20 facts and ≤5 chunks from a candidate pool of 50/10 before the main turn, so the big model sees a curated, relevant slice of memory instead of a blind top-k dump.

Beyond that, server-side compaction summarises older turns once history crosses ~70% of the model's window, keeping the last ten turns verbatim. Cross-channel history (Telegram, Matrix) is encrypted at rest with AES-256.

What we read, what we adopted, what we wrote ourselves

Building the assistant we studied five open-source agent projects. We read them — we did not copy code. Every borrowed idea was re-implemented from scratch in Python/FastAPI to fit our stack. We also explicitly avoided depending on Node.js runtimes or npm packages, even when a reference implementation was JavaScript-first.

What is original to us

Several pieces are not borrowed from any of the above:

• Five typed fact categories with per-type TTL and explicit supersession lineage. None of the reference systems carry temporal validity or formal fact types this way.
• Hybrid recall with weighted recency decay — cosine + BM25 are common; the 30-day half-life on the recency component is ours.
• Per-tier monthly budget wall (€120/mo, hard-enforced per request) with web-search capped at 3 uses per session.
• XML-wrapped tool results as a prompt-injection defence: the model is instructed to ignore instructions found inside tool output.
• Single-database operational story — facts, chunks, embeddings, conversations and channel history all live in one Postgres instance, covered by one backup cron.