v0.5 - S.I.R.I.U.S: Reductionist Local Assistant Pipeline

A lightweight, Python-based personal assistant engine. Local-first architecture with text parsing, SQLite persistence, and WebSocket-driven UI.
python fastapi websockets sqlite local-first text-parsing personal-assistant

July 1, 2024 – Version 0.5.0

What if a personal assistant was just: parse intent, store data, display it? That’s S.I.R.I.U.S. No cloud, no complex integrations, no proprietary APIs. Just a clean, local pipeline.

Rebuilt entirely in Python. FastAPI for the API layer, WebSockets for real-time updates, SQLite for persistence, Alpine.js for the frontend. Stripped down to essentials: parse commands, track data, show results.

Core philosophy: Reductionist design. Do one thing well: help you track what matters locally.

Added

  • main.py - FastAPI Core: Central REST API server. Manages endpoints, WebSocket streaming, and serves frontend assets. Single source of truth for all client communication.

  • parser.py - Intent Recognition: Natural language parsing layer. Pydantic validation rules sanitize input and route commands via strict regex patterns. Handles: spend: [amount] [category], income: [amount] [category], cal: [YYYY-MM-DD] [event title].

  • storage.py - Data Persistence: SQLite backend. Tracks system metrics, scheduled entries, and transaction history locally. No external database, no network dependency.

  • public/index.html - Live Dashboard: Real-time UI powered by Alpine.js. Displays engine state, flowing data stream, and command results. WebSocket-driven updates.

Improved

  • Parsing Accuracy: Strict regex rules eliminate ambiguity. Commands fail fast with clear feedback instead of silent misinterpretation.

  • Local Persistence: SQLite handles all storage. Data lives on disk, no cloud sync delays, no privacy leaks. Query any time.

  • WebSocket Efficiency: Decoupled producer-consumer pattern. Parser processes independently from UI updates. No blocking, no lag.

  • Minimal Dependencies: FastAPI, Uvicorn, Pydantic. That’s it. Smaller attack surface, easier to audit, faster to deploy.

Learned

  • Pydantic Validation: Strong type checking catches errors before they reach the database. Spend 15 minutes on schema design, avoid 15 hours debugging bad data.

  • WebSocket Patterns: Broadcast is simpler than request-response for live dashboards. One command triggers many screen updates. No polling needed.

  • SQLite Scalability: Local SQLite handles thousands of entries fine. For personal tracking, it’s faster and simpler than any external database.

  • Regex Routing: Strict command parsing means clear error messages. Users know exactly what failed. No magic, no guessing.

System Architecture

Four Core Files

main.py - FastAPI Application

  • Central orchestrator for all requests
  • REST endpoints for command submission
  • WebSocket hub for real-time updates
  • Serves frontend assets dynamically

parser.py - Intent Layer

  • Pydantic validators for input sanitization
  • Regex routing for command detection
  • Structured command objects passed downstream
  • Fails fast with clear error messages

storage.py - Data Layer

  • SQLite connection and schema management
  • CRUD operations for transactions and events
  • Simple queries, indexed for speed
  • Local persistence, always available

public/index.html - Frontend

  • Alpine.js for reactive UI
  • WebSocket client for live updates
  • Command input form with validation
  • Displays parsed commands and stored data

Design Decisions

Local-First Over Cloud

  • Data lives on disk, not a server
  • No network latency, no vendor lock-in
  • Simpler mental model: what you see is what you have

Text Parsing Over AI

  • Deterministic regex is faster than LLM calls
  • Clear error messages when parsing fails
  • No hallucinations, no surprise behavior

SQLite Over External Database

  • One file to backup, no deployment complexity
  • ACID guarantees for data integrity
  • Suitable for personal-scale tracking

Quick Start

1. Install Dependencies

1

pip install fastapi uvicorn pydantic

2. Run the Engine

1

python main.py

Server starts at http://127.0.0.1:8000

3. Run Tests

1
2

python test.parser.py     # Audit parser routing
python test.pipeline.py   # Simulate full pipeline

Command Protocols

Financial Tracking

spend: 25.50 groceries
income: 5000 salary

Calendar Events

cal: 2025-03-15 Project deadline
cal: 2025-04-20 Team meeting

Parser validates format, stores in SQLite, broadcasts to dashboard via WebSocket.

Reflection

The interesting part: how simplicity reveals what actually matters. I stripped away:

  • Complex API integrations
  • Cloud dependencies
  • AI models and external services
  • Multiple platforms and deployment targets

What remained: parse → store → display. That’s it.

Most tools bloat by adding features. This one shrinks by removing them. The question isn’t: what more can it do? It’s: what less can it do while still being useful?

Local-first isn’t a limitation, it’s a feature. Your data stays yours. No sync delays, no privacy questions, no vendor lock-in. Just text parsing and SQLite.

Next Steps

  • More command protocols (habits, notes, time tracking)
  • Query interface to search historical data
  • Export to CSV for analysis
  • Dashboard statistics and trends
  • Mobile web version (responsive design)
A personal assistant doesn't need to be smart. It needs to be reliable. What would you track if input were frictionless and data always available?