DEV Community: Ewansalan Dkhar

Sloth-Mode for Your Inbox: Building a Private, Local Email Agent with Gemma 2

Ewansalan Dkhar — Sat, 24 Oct 2026 07:36:33 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built (And Why I Needed It)

I have a confession: I genuinely, passionately hate reading emails.

It’s not just a minor annoyance—it's an executive function black hole. Every morning greets you with an overwhelming wall of administrative noise: marketing blasts disguised as product updates, vendor follow-ups, circular discussion threads, and calendar invites.

Because of this email avoidance, I’ve paid a real price. I've missed deadlines, forgotten critical follow-ups, and caused unnecessary chaos in my life. The wake-up call came when I nearly missed the mandatory document verification deadline for my scholarship. The notification wasn’t flagged or marked urgent; it was quietly buried inside paragraph four of an innocuous administrative newsletter. Missing that single deadline would have cost me thousands of dollars and months of bureaucratic grief.

And even on the days I forced myself to open my inbox, the second hurdle was waiting: I despise drafting email replies. Staring at a blank compose box, agonizing over how to sound polite, professional, and crisp just to say "Yes, received, let's meet Thursday" drains more cognitive bandwidth than writing 200 lines of complex backend code.

In honor of International Sloth Day and the "Slow and Steady" challenge, I decided to channel my inner sloth productively: if I'm too lazy to wade through email clutter and draft polite replies, I should build an AI agent to do it for me—without compromising my privacy.

Enter Local Email Agent: a local-first, privacy-preserving inbox assistant and ReAct co-pilot powered entirely by Google's open-weight Gemma 2 9B running locally via Ollama.

How It Solves My Three Core Problems

"I hate reading emails" → Zero-Effort Triage: The agent connects to IMAP in the background, strips away HTML/tracking clutter, and runs every incoming message through gemma2:9b. It categorizes emails (action_needed, review, informational, low_priority) and generates a punchy, one-sentence digest so I never have to read wall-of-text threads again.
"I almost missed my scholarship verification" → Automated Deadline & Action Extraction: The prompt pipeline explicitly commands Gemma to detect time-sensitive requirements, submission dates, and pending action items. Imminent deadlines are flagged in high-visibility alert badges on the dashboard so nothing falls through the cracks.
"I hate drafting replies" → ReAct Co-Pilot with Human-in-the-Loop Send: An interactive drawer assistant inspects thread context, formulates an appropriate response in seconds, and queues it for approval. I don't type a single word—I just review the proposed draft, tweak if necessary, and click Approve & Send over authenticated SMTP.

Most importantly: zero email data ever leaves my machine.

flowchart LR
    subgraph Local Workstation
        IMAP[Mailbox via IMAP SSL] -->|Sync UIDs| Core[FastAPI Sync Engine]
        Core -->|Sanitize & Store| DB[(SQLite WAL Vault)]
        Core -->|Structured Prompts| Ollama[Ollama: Gemma 2 9B]
        Ollama -->|Classification & Drafts| Core
        UI[React 18 SPA] <-->|REST API| Core
        User((User)) -->|Approve Draft| UI
        Core -->|Authenticated SMTP| Outbound[Outbound Mail Server]
    end

Demo

Here is a step-by-step walkthrough of how Local Email Agent operates, from initial ingestion to verified email dispatch:

Step 1: The Zero-Effort Triage Dashboard

When you open the application, incoming emails synced from IMAP are pre-classified into intuitive categories (Action Needed, Review, Informational, Low Priority). Extracted action items and imminent deadlines are prominently highlighted so you know exactly what requires your attention without opening dense threads.

Figure 1: The main inbox triage view showing unread messages ranked by urgency with extracted deadlines.

Step 2: The ReAct Co-Pilot Drawer

Selecting any email opens the interactive side drawer. The agent operates using a ReAct (Reasoning + Acting) loop: it can call local tools to read thread context, summarize conversation history, or draft a targeted response tailored to the sender's tone.

Figure 2: The ReAct co-pilot analyzing email context and composing a reply draft.

Step 3: Human-in-the-Loop Review & Approval

Autonomy without safety is a liability. When the agent finishes drafting, clicking Send Reply opens an explicit approval modal displaying the recipient, subject line, and generated message body. You can inspect the text, make direct line edits if necessary, and approve the dispatch.

Figure 3: Human-in-the-loop confirmation modal ensuring no email leaves without explicit verification.

Step 4: Authenticated SMTP Dispatch & Audit Logging

Once approved, the backend securely dispatches the message over authenticated SMTP (supporting both port 465 SSL and port 587 STARTTLS) and creates a persistent audit entry in the local sent_emails SQLite table.

Figure 4: Instant visual confirmation after successful outbound SMTP transmission.

Quickstart Guide: Running Locally

The entire application is containerized with Docker Compose using host networking to communicate directly with your local Ollama instance:

# 1. Clone the repository
git clone https://github.com/Ewan-Dkhar/email-agent.git
cd email-agent

# 2. Configure mailbox and SMTP credentials
cp config.example.yaml config.yaml
# Edit config.yaml with your IMAP and SMTP server settings

# 3. Pull Google's Gemma 2 9B model in Ollama
ollama pull gemma2:9b

# 4. Start the stack
docker compose up -d

Navigate to http://localhost:5173 to start using your local email triage assistant.

Code

Local Email Agent is fully open source under the MIT License:

GitHub Repository: https://github.com/Ewan-Dkhar/email-agent
Automated Test Suite: 37 passing unit and integration tests covering IMAP ingestion, Ollama structured generation, SQLite migrations, prompt injection sanitation, and authenticated SMTP dispatch (backend/.venv/bin/pytest backend/tests).

How I Built It

The stack is designed for speed, isolation, and predictability:

Inference Engine: Ollama serving Google's gemma2:9b. We enforce structured outputs via Pydantic schemas and deterministic JSON prompting, tuning temperature to 0.2 for classification stability and 0.6 for natural conversational drafting.
Defensive Prompt Sanitization: Incoming emails from untrusted third parties are potential prompt injection vectors. The backend strips zero-width unicode characters, neutralizes pseudo-system markers (<system>, [INST]), and isolates email contents in delimited context blocks before presenting them to Gemma.
Sync Engine: Python 3.12 with imaplib, normalizing multipart MIME structures, HTML formatting, and tracking message UIDs to avoid duplicate re-processing.
Storage: SQLite operating in Write-Ahead Logging (PRAGMA journal_mode=WAL) mode with explicit connection pooling and foreign key constraints.
Outbound SMTP Client: Python's smtplib offloaded asynchronously using asyncio.to_thread with automatic switching between SSL (port 465) and STARTTLS (port 587).
Frontend: React 18, Vite, TypeScript, and TailwindCSS, served behind an optimized Nginx reverse-proxy container.

Why Open Innovation Matters

Email is arguably the most sensitive personal data stream we possess. It contains scholarship notices, bank records, tax forms, employment contracts, security verification codes, and private conversations.

Routing your entire mailbox history through proprietary third-party cloud APIs poses significant privacy risks, vendor lock-in, and ongoing API subscription costs.

Open-weight models like Gemma 2 change the equation. At 9 billion parameters, gemma2:9b delivers the instruction-following fidelity and reasoning capacity required for nuance, deadline extraction, and reply drafting, all while running comfortably on consumer workstation hardware. Open innovation means:

Absolute Privacy: Your emails never leave your machine or train third-party models.
No Recurring Fees: Zero token billing or API rate limits.
Total Transparency: The entire pipeline—from prompt construction to email dispatch—is auditable and modifiable in code.

The Lazy Payoff

What does channeling your inner sloth actually save?

Zero Triage Paralysis: Instead of wading through 40+ unread threads every morning, Gemma categorizes, extracts action items, and flags upcoming deadlines into a clean digest.
No More Missed Scholarship/Grant Deadlines: High-stakes dates buried in dense administrative text are extracted immediately and highlighted on your dashboard.
Effortless Responses: For routine administrative requests ("Can you confirm receipt?", "When can we meet?"), the ReAct co-pilot pre-drafts the response. You review it, make any minor adjustments, and click "Approve & Send".
Daily Time Savings: Reduces typical email overhead from 35–45 minutes of daily dread down to under 5 minutes of glancing, approving, and moving on with your day.

Prize Categories

I am submitting Local Email Agent for the following challenge category:

Featured Category: Best Use of Gemma ($200): Local inference powered by Google's open-weight gemma2:9b model running on Ollama. Gemma acts as both the structured extraction engine for inbox triage and the reasoning backbone of the ReAct co-pilot.

AI Disclosure: Development was assisted by Claude/Antigravity for pair-programming, test authoring, and drafting this submission narrative. All code, architecture, and tests were verified locally.

A Sub-Millisecond In-Game HUD Powered by Local SLMs

Ewansalan Dkhar — Sun, 18 Oct 2026 06:39:51 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

🧭 Wayfinder: Building a Zero-Lag, Local-First In-Game Companion HUD with Tauri v2, SQLite BM25, and Local SLMs

What I Built

Wayfinder is a sub-millisecond, local-first in-game companion HUD built for action RPGs and Soulslike titles (Sekiro: Shadows Die Twice, Elden Ring, Lies of P, Black Myth: Wukong).

With a single hotkey press (Alt + G), Wayfinder summons a frameless, transparent glassmorphic overlay directly above your game. Using a local SQLite FTS5 BM25 retrieval engine and local open-weight Small Language Models (SLMs) running on your own GPU via Ollama, it synthesizes an authoritative 3-bullet tactical cheat sheet in under a second:

Telegraph & Counter: Critical perilous attacks and how to deflect/dodge them.
Key Vulnerability: Effective elemental weaknesses, items, or prosthetic tools.
Phase Shifts: Exact cues and positioning adjustments across battle phases.

┌─────────────────────────────────────────────────────────────┐
│                      Wayfinder HUD                          │
│        (Tauri v2 + Vanilla TypeScript + Glassmorphism)      │
│  - Summon: Alt + G Hotkey     - Focus Hand-off: Escape      │
│  - Multi-Game Switcher        - Dynamic SLM Model Picker    │
│  - Drag-and-Drop Ingestion    - 0.08ms DOM Mutation Budget  │
└──────────────────────────────┬──────────────────────────────┘
                               │ HTTP / JSON (127.0.0.1:8765)
┌──────────────────────────────▼──────────────────────────────┐
│                  Wayfinder Micro-Daemon                     │
│               (FastAPI + SQLite WAL Engine)                 │
│  ┌───────────────────────────┐ ┌──────────────────────────┐ │
│  │   SQLite FTS5 + BM25      │ │     Distillation Engine  │ │
│  │  - Sub-ms exact retrieval │ │  - Local Ollama SLM API  │ │
│  │  - Zero B-tree lock (WAL) │ │  - Dynamic Hot-Swapping  │ │
│  └───────────────────────────┘ └──────────────────────────┘ │
└──────────────────────────────┬──────────────────────────────┘
                               │ Local IPC (127.0.0.1:11434)
┌──────────────────────────────▼──────────────────────────────┐
│                    Ollama Runtime                           │
│                 (qwen2.5:1.5b-instruct)                     │
│  - Local GPU/NPU inference with 0 cloud latency             │
└─────────────────────────────────────────────────────────────┘

The Problem It Solves

When facing brutal boss encounters, gamers currently face three painful tradeoffs:

Alt-Tabbing to YouTube / Wikis: Breaks combat flow, causes window focus lag, and forces you to scrub through 20-minute video intros while tabbed out.
Second-Monitor Wikis: Diverts eye tracking away from fast enemy attack telegraphs.
Heavy Overlays (Overwolf / Electron): Introduce frame pacing stutter (frame time spikes >16.6ms), inject bloated Chromium runtimes, and hog gigabytes of memory.

Wayfinder is engineered for absolute performance: ~3.2ms summon time, 0.42ms SQLite search, 0.08ms DOM mutation pacing, and a tiny ~42MB idle RAM footprint.

The Side Hustle Angle: Who Would Pay For It?

Gamers hate bloatware, but they gladly pay for competitive convenience, speed, and privacy:

Target Audience: Soulslike & ARPG players, speedrunners, content creators, and handheld gamers (e.g., Steam Deck users who cannot easily alt-tab).
The Business / Monetization Model:
- Free & Open-Source Core: Full local HUD, local Ollama integration, manual markdown/URL ingestion, and zero tracking.
- Pro / Subscription Tier ($4.99/mo or $39/year):
- Cloud-Synced Community Guide Packs: One-click downloads of verified, high-tier boss strategies across newly released AAA titles without manual ingestion.
- Multi-Device Sync: Cloud sync of game progress and boss notes between your desktop gaming rig and Steam Deck/ROG Ally.
- Automated Video Guide Pipeline: Cloud-accelerated transcript & timestamp indexing for long-form video walkthroughs.

Demo

Code

Github: Wayfinder

The repository is organized into a clean, decoupled architecture:

desktop/: Tauri v2 desktop shell with a lightweight Vanilla TypeScript frontend (zero bulky frameworks, hand-tuned glassmorphic CSS).
core/: Python micro-daemon powering the SQLite FTS5 database, chunking engine, and Ollama integration.
scripts/build_sidecar.py: Automated zero-terminal PyInstaller pipeline embedding the Python daemon as a native sidecar binary inside the Tauri bundle.

How I Built It

1. Open-Source AI Stack

Open-Weight SLMs (Small Language Models): Defaulted to qwen2.5:1.5b and llama3.2:3b. These compact models deliver remarkable reasoning density while consuming as little as 1.2 GB of VRAM, leaving your GPU free to render demanding games.
Local Inference via Ollama: All inference runs over local HTTP IPC (127.0.0.1:11434) with zero telemetry, zero token bills, and zero cloud round-trip latency.
Dynamic Model Hot-Swapping: Wayfinder queries GET /api/tags from Ollama on boot to automatically populate the HUD header with every model installed on the host. Players can hot-swap models mid-game without touching a terminal.

2. High-Performance Retrieval Engine

Instead of high-overhead vector databases that demand hundreds of megabytes of RAM and heavy embeddings calculation on every boot, Wayfinder uses SQLite FTS5 with BM25 ranking:

Sub-millisecond exact keyword and token matching (0.42ms average query time).
WAL (Write-Ahead Logging) mode to prevent database locks during game sessions.
Multi-source ingestion that extracts and normalizes Markdown guides, Steam Community articles, and YouTube transcripts with automated chunking.

3. Tauri v2 Desktop & The PyInstaller Sidecar Pattern

To deliver a true consumer app that doesn't require users to know Python, Node, or terminal commands:

The Python micro-daemon is compiled into a self-contained binary via PyInstaller (wayfinder-daemon.spec).
Tauri manages the sidecar lifecycle: launching the daemon on app startup, communicating over a local loopback port, and cleanly killing background processes on exit.
A strict 0.08ms DOM mutation budget using pure Vanilla TypeScript ensures that rendering the HUD never interferes with GPU frame pacing in 144Hz gaming setups.

Why Does Open Innovation Matter?

In competitive gaming, timing is measured in frames (16.6ms at 60 FPS). Closed AI APIs (like proprietary cloud LLMs) are fundamentally unsuited for real-time in-game tools:

Network Latency & Jitter: Cloud APIs introduce variable round-trips (400ms to 2000ms+). If your internet hiccups during a boss fight, a cloud HUD fails completely.
Per-Token Metering & Unpredictable Costs: A gamer querying boss strategies fifty times an evening would rack up API subscription costs or hit rate limits. Local open-weight models have zero recurring token costs.
Privacy & Offline Sovereignty: Your gaming habits, machine status, and custom guide documents stay 100% on your machine.
Hardware Flexibility: Open innovation means players on a Steam Deck can run a 0.5B model, while players with an RTX 4090 can spin up an 8B DeepSeek reasoning model—without waiting for a cloud provider's permission.

Open-source AI made it possible to build a genuinely fast, offline utility that prioritizes player experience over cloud lock-in.

Built with ❤️ for gamers and performance purists. Stars and feedback are welcome on GitHub!

A Brand New Day

Ewansalan Dkhar — Sat, 03 Oct 2026 20:47:51 +0000

Starting a new journey as I aim to become a more skill developer.