A personal, self-hosted AI platform for a family of four. One app, multiple LLM providers, per-member personalization, parental controls, and a morphable UI that adapts to each family member's age, role, and interests.
- Children under 18 can't have their own Claude or ChatGPT accounts — this app acts as a parent-managed intermediary via APIs
- No existing product combines homeschool education, health/fitness, household management, and project planning under one AI umbrella with family controls
- API access across 5 providers costs less than 4 individual Claude Pro subscriptions while offering more capability and control
- Every family member gets their own personalized AI assistant with age-appropriate guardrails
For parents: Full admin control over children's AI access — model restrictions, budget caps, content moderation, topic filters, time-of-day limits, and safety alerts. Google Workspace integration (Gmail, Calendar, Drive) for email triage, family scheduling, and document search. Household tools: meal planning, budget tracking, curriculum management.
For kids: A personal AI tutor and assistant with an interface they customize themselves. Socratic homework help that guides rather than gives answers. Fitness tracking, project workspaces, and an AI that remembers their interests and adapts over time. Privacy from parents on conversations (with safety guardrails).
For the family: A shared Family Space dashboard — parent-controlled, with per-child widget permissions (hidden, view-only, or interactive). Includes a family announcements board, aggregated family calendar (kids request events, parents approve), family group chat with AI, shared meal plans with kid voting, family goals and challenges with optional leaderboards, shared knowledge base, and family project widgets. Also: cross-calendar scheduling ("When is everyone free Saturday?") and a parents-only family budget overview.
Tauri v2 + React (Android, Windows, macOS, Ubuntu)
│
HTTPS/SSE
│
FastAPI (GCP Cloud Run)
├── Policy Engine (system > admin > user)
├── Content Moderation (keyword + OpenAI Mod API + response scan)
├── Budget Tracker (real-time per-user, SSE push)
├── Family Space Engine (shared dashboard, per-child permissions)
├── Google Workspace Bridge (Gmail, Calendar, Drive)
├── RAG Layer (LlamaIndex, per-user namespaces)
├── Project Engine (AI-generated workspaces)
└── LLM Layout Generator (JSON component trees → React renders)
│
LiteLLM Proxy (Cloud Run)
├── Anthropic (Claude Opus, Sonnet, Haiku)
├── OpenAI (gpt-5.4, GPT-4o, o4-mini)
├── Google (Gemini Flash)
└── OpenRouter (DeepSeek, Kimi — adults only)
│
PostgreSQL + pgvector (Cloud SQL)
Cloud Storage (GCS)
Server-Driven Morphable UI — The app has no fixed screens. The backend calls an LLM to generate JSON component trees, and React renders them dynamically via a recursive renderer + component registry (~30 pre-built components: chat, calendar, charts, kanban boards, meal planners, etc.). The AI generates each member's initial layout from an onboarding personality quiz, and users reshape their interface through prompts or drag-and-drop. Since this is a personal app (no app store review), we have full freedom for server-driven UI.
Three-Tier Governance — System rules (immutable safety) > Admin rules (parent-configurable per child) > User preferences (self-customization within bounds). A child can never override a parent's rule. A parent can never disable a system safety rule.
Family Space — A shared, server-driven dashboard for the family unit. Parents own the layout and set per-child permissions on each widget (hidden, view-only, or interactive). Includes announcements, family calendar, group AI chat, meal plans, goals/challenges, shared knowledge base, and family projects. Kids participate within the bounds parents define.
Private by Default — All content is private to the owner unless explicitly shared. Parents can review all children's AI prompts and responses on demand. Content moderation still runs independently — flagged content triggers proactive real-time alerts to parents. Non-AI content (email, Drive, health) remains private unless the child shares it.
AI-Generated Project Workspaces — "Plan our family vacation to Italy" generates a workspace with budget tracker, itinerary, packing lists, booking tracker, and map — all from the component library, shareable with family members at different permission levels.
| Layer | Technology |
|---|---|
| Frontend | Tauri v2 (Rust shell) + React 19 (TypeScript) + Tailwind CSS 4 |
| Backend | Python / FastAPI on GCP Cloud Run |
| LLM Gateway | LiteLLM (5 providers, per-user virtual keys) |
| Database | PostgreSQL 16 + pgvector (Cloud SQL) |
| RAG | LlamaIndex + pgvector embeddings |
| File Storage | Google Cloud Storage (GCS) |
| Auth | Google OAuth2 (sign-in + Workspace integration) |
| Secrets | GCP Secret Manager |
Backend is containerized. When dedicated local hardware is available, the backend stack migrates to Docker Compose with zero code changes — just environment variable updates. Tauri client is distributed directly to family devices (APK for Android, installers for desktop).
fameli/
├── frontend/ # Tauri v2 + React 19 + TypeScript + Vite
│ ├── src/
│ │ ├── components/ # React components (AppShell, SDUI renderer)
│ │ ├── pages/ # Fixed screens (auth, onboarding, settings)
│ │ ├── hooks/ # React Query, auth, SSE hooks
│ │ └── lib/ # API client, types, utilities
│ ├── src-tauri/ # Tauri Rust shell + config
│ ├── index.html
│ ├── vite.config.ts
│ └── tsconfig.json
├── backend/ # Python / FastAPI
│ ├── app/
│ │ ├── api/v1/ # Route modules (auth, family, chat, etc.)
│ │ ├── core/ # Config, database, security
│ │ ├── models/ # SQLAlchemy models
│ │ ├── schemas/ # Pydantic request/response schemas
│ │ └── services/ # Business logic
│ ├── alembic/ # Database migrations
│ ├── tests/
│ ├── Dockerfile
│ └── pyproject.toml # uv-managed dependencies
├── docs/ # Design documentation
├── docker-compose.yml # Local dev: Postgres + pgvector
└── README.md
- Node.js 22+ and pnpm 10+
- Python 3.12+ and uv
- Rust (latest stable, via rustup)
- Docker (for local Postgres)
- Tauri v2 system deps (Linux:
libwebkit2gtk-4.1-dev,libgtk-3-dev, etc. — see Tauri prerequisites)
# 1. Start the database
docker compose up -d
# 2. Backend (from backend/)
cd backend
cp .env.example .env # edit as needed
uv sync # install Python dependencies
uv run alembic upgrade head # run database migrations
uv run uvicorn app.main:app --reload --port 8000
# 3. Frontend — Vite dev server only (from frontend/)
cd frontend
pnpm install # install Node dependencies
pnpm dev # starts on http://localhost:5173
# 4. Frontend — full Tauri desktop app (from frontend/)
pnpm tauri dev # builds Rust shell + launches app# Frontend
pnpm check # TypeScript type checking
pnpm build # production build
pnpm test # run Vitest
# Backend
uv run ruff check app/ # lint
uv run ruff format app/ # auto-format
uv run pytest # run tests
uv run alembic revision --autogenerate -m "description" # new migration| Phase | Scope | Timeline |
|---|---|---|
| 0 | Deploy Open WebUI + LiteLLM as stopgap | 1-2 hours |
| 1 | Core app: Tauri + React + FastAPI + chat + profiles + SDUI foundation | 2-3 weeks |
| 2 | Governance, budget dashboard, privacy model, content moderation | 2-3 weeks |
| 3 | Google Workspace integration (Gmail, Calendar, Drive) + scheduling | 2-3 weeks |
| 4 | RAG, document ingestion, AI personas, prompt-driven UI customization | 2-3 weeks |
| 5 | Homeschool: Socratic tutor, curriculum planner, progress tracking | 2-3 weeks |
| 6 | Project workspaces, meal planning, household budget | 3-4 weeks |
| 7 | Voice I/O, notifications, multi-device session continuity | 2-3 weeks |
| 8 | Health, diet, fitness tracking per member | 2-3 weeks |
| 9 | Polish: aging/lifecycle controls, gamification, local migration | Ongoing |
All design documentation lives in docs/:
- Product Requirements (PRD) — Personas, 100+ feature requirements, user stories, acceptance criteria per phase
- System Architecture — Service boundaries, deployment topology, data flows
- Data Model — PostgreSQL schema, all tables, vector storage design
- API Design — REST endpoints, request/response schemas, SSE events, error codes
- UI/UX Specification — Navigation, user flows, component library, responsive behavior
- Privacy & Security — Access control, content moderation, encryption, threat model
- Architecture Decisions (16 ADRs) — Formalized rationale for every major technical choice
- Ideation Research (13 docs) — 8,400+ lines of market research, technology evaluation, and concept design
- SDUI Research — Server-driven UI evaluation and Tauri + React decision
| Usage Level | Monthly (Cloud) | Monthly (Local) |
|---|---|---|
| Light | $25-50 | $13-25 |
| Moderate | $40-76 | $23-45 |
| Heavy | $68-132 | $45-88 |
Compare: 4x Claude Pro = $80/mo with no parental controls, no multi-provider, and kids can't have accounts.
Personal use. Not for distribution.