DEV Community: Palak Agarwal

LazyDesk AI

Palak Agarwal — Mon, 26 Oct 2026 06:20:29 +0000

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

What I Built:-

LazyDesk AI is a local-first, privacy-respecting desktop assistant designed to tackle one of the most universal computer headaches: the chaotic, overflowing Downloads and Desktop folders, redundant duplicate files, and unread PDF documents.

Instead of sending private desktop files to external cloud AI APIs, LazyDesk AI executes all processing locally on your own machine. It pairs deterministic system utilities for file operations with Google's open-weight Gemma 3 4B (via Ollama) for document synthesis and grounded Q&A.

What effort does it save?
Zero-effort file organization: Automatically sorts hundreds of scattered files into 8 clean category folders (Documents, Spreadsheets, Images, Videos, Audio, Code, Archives, Other) with interactive dry-run previews, automated filename conflict renaming (file_1.ext), and a 1-click undo history.
Effortless duplicate discovery: Scans files using a fast two-stage algorithm (matching byte sizes first, followed by streaming SHA-256 chunked hashing) to uncover exact duplicates regardless of different filenames—without ever deleting anything automatically.
Instant document synthesis: Extracts digital text from multi-page PDFs in milliseconds with PyMuPDF, feeding it directly to local Gemma 3 4B to generate a structured 5-part executive summary:
Executive Overview
Key Points & Insights
Important Dates, Deadlines & Entities
Action Items & Next Steps
Document Notes & Uncertainties
Grounded Document Q&A: Lets users query documents and receive answers strictly grounded in the document text, with explicit page references.
Who gets to be a little lazier because of it?
Developers & Tech Workers who let installer scripts, log dumps, and code snippets pile up in their default directories.
Researchers & Students juggling dozens of academic papers, syllabi, and lecture slide decks who need immediate summaries and action items without reading 40 pages.
Freelancers & Consultants managing confidential client invoices, contracts, and tax receipts who refuse to upload private client data to cloud AI services.
Demo

LazyDesk AI features a modern, responsive dark dashboard built in Streamlit with a muted slate/indigo theme.

Quick Local Walkthrough:
Launch the app with python -m streamlit run app.py (opens at http://localhost:8501).
Click "📂 Load Demo Sandbox Path" in the sidebar to load the included, fully-isolated demo environment without touching any personal files.
Open 📊 File Dashboard to view live metrics, category breakdowns, and searchable file tables.
Switch to 🗂️ Smart Organizer, click "📋 Generate Move Preview", run a Dry Run, and inspect the automated conflict renaming.
Check 🔍 Duplicate Detector to see identical SHA-256 invoice duplicates detected with reclaimable space calculations.
Head to 📑 PDF Summarizer, upload the included LazyDesk_Product_Specification.pdf, and watch local Gemma 3 4B generate a complete executive breakdown with action items.
+--------------------------------------------------------------------------+
| [DEMO PREVIEW] 📊 File Dashboard |
| Scans direct files, calculates byte sizes, and charts category breakdowns|
+--------------------------------------------------------------------------+
| [DEMO PREVIEW] 🗂️ Smart File Organizer |
| Interactive proposed move plan, conflict check, dry-run & 1-click undo |
+--------------------------------------------------------------------------+
| [DEMO PREVIEW] 🔍 Duplicate Detector |
| Streaming SHA-256 checksums, identical content grouping, report-only |
+--------------------------------------------------------------------------+
| [DEMO PREVIEW] 📑 Local AI PDF Summarizer & Grounded Q&A |
| Sub-second PyMuPDF extraction + Gemma 3 4B structured executive summary |
+--------------------------------------------------------------------------+

(Demo video / GIF walkthrough link: https://github.com/your-username/lazydesk-ai#demo
)

Code

The complete source code is open source and structured into clean, modular Python components:

text
lazydesk-ai/
├── app.py # Streamlit productivity dashboard & views
├── .streamlit/config.toml # Dark muted-neutral theme configuration
├── modules/
│ ├── config.py # Category mappings, exclusions, AI defaults
│ ├── file_scanner.py # Direct-file scanner & metric aggregation
│ ├── organizer.py # Conflict resolution, preview, move & rollback
│ ├── duplicate_detector.py # Size pre-filter + SHA-256 chunked hashing
│ ├── pdf_processor.py # PyMuPDF text engine & scanned PDF detector
│ ├── local_ai.py # Ollama REST API client (Gemma 3 4B)
│ └── operation_history.py # JSON audit history logger for undo support
├── sample_data/ # Isolated test files (never touches real data)
│ ├── create_demo_data.py # Demo generator
│ └── demo_sandbox/ # Sample PDFs, CSVs, scripts, and duplicates
├── tests/ # 30 passing unit tests (100% green)
├── requirements.txt # Dependencies (PyMuPDF, Streamlit, Ollama client)
└── README.md # Complete Windows/Linux setup instructions
GitHub Repository

🔗 https://github.com/your-username/lazydesk-ai

Key Code Highlight: Local AI Generation with Zero Cloud Calls
python

modules/local_ai.py

def generate_document_summary(
document_text: str,
filename: str = "document.pdf",
model: str = "gemma3:4b",
base_url: str = "http://localhost:11434",
timeout: int = 90,
) -> AISummaryResult:
"""Send document text strictly to local Ollama instance."""
prompt = build_summarization_prompt(document_text, filename)
endpoint = f"{base_url.rstrip('/')}/api/generate"
payload = {
"model": model,
"prompt": prompt,
"stream": False,
"options": {"temperature": 0.2, "top_p": 0.9},
}
# Strict local execution with low temperature for factual fidelity
response = requests.post(endpoint, json=payload, timeout=timeout)
response.raise_for_status()
return AISummaryResult(
success=True,
summary_markdown=response.json().get("response", "").strip(),
model_used=model,
)
How I Built It

LazyDesk AI was built using a hybrid architecture that pairs deterministic software engineering with open-weight language modeling:

Local Open-Weight Model: Gemma 3 4B served locally by Ollama (http://localhost:11434). It provides an ideal balance of fast CPU/GPU inference and sharp reasoning for structured extraction without needing 32 GB of VRAM.
User Interface: Streamlit 1.38+, heavily customized with a dark theme (#0b0f19 background, #131c2e surface cards, #6366f1 indigo accents) to feel like a polished desktop utility rather than a tutorial app.
PDF Text Extraction: PyMuPDF (fitz), delivering sub-second parsing across complex PDF structures.
Cryptographic Duplicate Detection: Python hashlib using SHA-256 streamed in 64 KB chunks to handle multi-gigabyte files without memory bottlenecks.
Safety Invariants:
Never Overwrite: Automated renaming (report_1.pdf) preserves existing files.
Dry Run Verification: Preview simulated actions before writing to disk.
Audit Trail & Reversal: All movements are logged to ~/.lazydesk/operations_history.json and can be undone with a single click.
No Silent Hallucination on Scanned PDFs: If a user uploads an image-only scanned PDF without an OCR text layer, LazyDesk AI identifies this immediately and informs the user that digital text is absent, rather than fabricating a summary.
100% Mocked Automated Tests: 30 comprehensive unit tests using pytest mock Ollama endpoints, ensuring test suites run anywhere without downloading weights.
Why Does Open Innovation Matter?

Desktop AI tools present a profound privacy dilemma. When an AI app asks to inspect your folders or read your documents, sending that data over the public internet to closed-source, centralized cloud APIs creates serious risks:

Data Sovereignty: Financial statements, confidential NDAs, personal tax records, and medical PDFs should never leave your hard drive. Open-weight models running on localhost make true data sovereignty possible.
No Metered Costs: Closed APIs charge per token. A user sorting their desktop or summarizing a 50-page PDF shouldn't have to calculate API costs or fear subscription tier upgrades. Open innovation enables unlimited, predictable, zero-marginal-cost productivity.
Offline Reliability: Trains, airplanes, and rural job sites don't always have reliable Wi-Fi. Because LazyDesk AI relies on open weights and local runtimes, it functions identically with or without an internet connection.
Freedom of Choice: Users aren't locked into a single proprietary vendor. If a user prefers llama3.2, mistral, or phi3, they can switch the model name directly in the LazyDesk settings panel without rewriting code.
My Agent Session

This project was built pair-programming with the Antigravity autonomous AI coding agent.

The agent played the role of full-stack architect, test engineer, and UX designer:

Scaffolding the 6 modular subsystems (file_scanner.py, organizer.py, duplicate_detector.py, pdf_processor.py, local_ai.py, operation_history.py).
Creating an isolated sandbox demo environment to verify safety without touching personal directories.
Writing and executing 30 unit tests with pytest, catching real edge cases (like dataclass argument ordering and multi-line PyMuPDF bounding boxes) during development.
Starting and verifying the live Streamlit server over localhost.
The Lazy Payoff

Here is how LazyDesk AI lets users embrace their inner sloth while staying organized:

Task The Hard Way (Manual / Cloud) The LazyDesk AI Way
Cleaning a 150-file Downloads folder 30–45 minutes of manual dragging, creating folders, and checking file extensions. 3 seconds: Click Preview, Click Confirm. Files are safely categorized.
Finding redundant duplicate downloads Opening files side-by-side, comparing file dates, checking byte sizes. Instant: Automated SHA-256 scan shows duplicate groups and reclaimable bytes.
Reading a 25-page product spec or agreement 30 minutes of skimming for deadlines, names, and deliverables. 15 seconds: Gemma 3 4B extracts exact deadlines, named entities, and action items.
Fixing an accidental reorganization Panicking and manually moving files back one by one. 1 click: Click "Undo Operation" in History to restore original file locations.
Prize Categories
Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady (Focusing on genuine open-weight AI performing real application tasks without external cloud dependencies).

Built with ❤️ for Hacktoberfest 2026. Keep it local, keep it open.

LedgerLens: Local-First AI Agent for Handwritten Ledgers, Anomaly Detection & Cash-Flow Forecasting

Palak Agarwal — Mon, 19 Oct 2026 07:00:17 +0000

What I Built

Millions of small shopkeepers, street vendors, and freelancers across India track daily business operations in physical paper notebooks—commonly known as Khata Bahi (खाता बही) or Roznamcha (रोज़नामचा). These physical logs mix handwritten Hindi (Devanagari) and English, record customer credit/debit, and track daily inventory purchases.

When tax season arrives or when seeking micro-loans, shopkeepers face days of painful, error-prone manual data entry. Commercial SaaS accounting apps either fail to read local handwriting or mandate uploading sensitive customer records to the cloud—exposing financial ledgers to third-party data mining.

What LedgerLens Does

LedgerLens is an open-source, local-first agent that runs entirely on a standard laptop with zero GPU requirements:

Multimodal Vision Extraction: Snaps or uploads photos of handwritten shop ledgers and bills (in Hindi, English, or mixed Hinglish) and transforms them into strict, structured JSON {date, party, item, quantity, amount, currency, type, confidence}.
Deterministic Normalization & Validation: Cleans dates and currencies, drops duplicate entries, and never silently mutates amounts—highlighting entries with confidence < 0.7 for human review.
TabPFN Anomaly Detection: Uses the TabPFN tabular foundation model to detect unusual store expenses (e.g., massive restock spikes, accidental double bills, or odd supplier frequencies) and explains each flag in one plain-language sentence.
30-Day Cash-Flow Forecasting: Uses TabPFN time series regression to project the next 30 days of daily net cash flow with a 95% uncertainty interval.
Plain-Language Weekly Summaries: Generates friendly executive financial briefs ("You made ₹9,235 in sales this week with a net balance of +₹2,918. You spent 35% more on expenses compared to last week...").
Local Spreadsheet Export: 1-click download to CSV and formatted Microsoft Excel (XLSX).

Who Would Pay for This? (The Side Hustle)

Local Accountants & GST Practitioners: Tax preparers and accountants servicing small merchants charge ₹500–₹1,500/month per shop for bookkeeping. LedgerLens cuts their manual data entry from 3 hours to 30 seconds per client ledger.
Freelance Bookkeepers & Micro-SaaS: A turnkey offline desktop utility sold to shopkeepers for a one-time license of ₹999 or ₹199/month.
Zero Ongoing API Costs: Because the AI runs 100% locally on open-source models, the operator retains 100% gross margins.

Demo

Repository: https://github.com/nikprad/ledgerlens
Live Local Dashboard: http://localhost:3000 (Powered by Node.js + Mastra Orchestrator + FastAPI backend)

Key User Experience Walkthrough:

Privacy Status Panel: Displays active local components (Gemma 3 vision via Ollama, local TabPFN on CPU, SQLite storage) with a toggle for TabPFN Cloud API that enforces zero-PII transmission (anonymized numeric columns only).
Scan & Extract: Choose any receipt photo or select one of the 5 preloaded Indian shop samples (Grocery Store, Chai Stall, Hindi Khata, Hardware Invoice, Daily Register).
5-Step Mastra Workflow: Watch real-time execution across extract ➔ validate ➔ store ➔ forecast ➔ summarize with latency and token metrics logged to observability.json.
Spreadsheet & Review: Inspect and edit transactions directly in an interactive table where ambiguous or low-confidence entries are clearly badged in amber for human sign-off.
Probabilistic Forecast Chart: View historical daily revenue alongside a 30-day projection line and shaded uncertainty bounds.

Code

nikprad / ledgerlens

# 📜🔍 LedgerLens > **Local-First AI Agent for Handwritten Bills, Receipts & Shop Ledgers** > *Transform photos of handwritten khata pages and receipts (Hindi + English) into clean spreadsheets, flag financial anomalies, and forecast cash flow — with 100% local privacy.* Built for the **Hacktoberfest Open-Source AI Challenge** (*Theme: Side Hustle*). --- ## ⚡ 3-Command Quickstart ```bash # 1. Clone repository and navigate to project git clone https://github.com/your-username/ledgerlens.git && cd ledgerlens # 2. Install dependencies (Node + Python) npm install && pip install -r requirements.txt # 3. Start LedgerLens (Backend + Mastra Workflow + Web Dashboard) npm start ``` Visit **`http://localhost:3000`** in your browser. > [!TIP] > If running Gemma vision locally via Ollama, start Ollama first: `ollama run gemma3:4b`. If Ollama is not installed or unreachable, LedgerLens seamlessly activates its simulated fallback mode so all workflows, tests, and UI demos work out of the box without crashing. --- ##…

View on GitHub

The repository is organized cleanly into modular microservices:

backend/: FastAPI backend wrapping Ollama multimodal vision, image preprocessing, TabPFN anomaly detection, and SQLite storage.
workflow/: Mastra TypeScript workflow chaining the 5 pipeline steps with Zod validation.
frontend/: Web dashboard with editable spreadsheet, privacy toggles, and Chart.js forecast visualizations.
cli/: Command-line extraction runner (extract_cli.py).
eval/: Automated ground-truth benchmark suite measuring field-level extraction accuracy.
samples/: 5 realistic synthetic handwritten/printed ledger sheets and matching ground-truth JSON files.

How I Built It

LedgerLens is built around open-weight foundation models and local execution:

1. Vision Extraction (Gemma Multimodal via Ollama)

Uses Google's Gemma multimodal model (gemma3:4b) served locally via Ollama.
Image Preprocessing Pipeline: A custom pipeline in PIL resizes high-resolution camera photos, converts them to grayscale, and applies contrast/sharpness enhancement so the quantized model can parse faint ink strokes and complex Devanagari ligatures on low-power CPUs.
Schema Validation & Self-Correction: Imposes a strict JSON system prompt. If parsing or schema validation fails, the extractor automatically retries once with an explicit error correction prompt.

2. Predictions & Forecasting (TabPFN by Prior Labs)

Integrates TabPFN (TabPFNRegressor & TabPFNClassifier), a transformer-based foundation model trained on synthetic tabular datasets for zero-shot in-context learning.
Anomaly Detection: Fits TabPFN on transaction distributions to detect unusual expenses, duplicate billing events within 48 hours, and supplier frequency bursts with 1-sentence explanations.
Cash-Flow Forecasting: Aggregates daily net cash flows (sales - expenses) and builds temporal lag features (lag_1, lag_7, rolling_7, day_of_week). Fits TabPFNRegressor to project 30 days forward with empirical uncertainty bounds.
Graceful Fallback: Gracefully detects if $<20$ historical days exist, prompting the shopkeeper to upload more entries or seed demo history.

3. Workflow Orchestration (Mastra TypeScript)

Employs Mastra (@mastra/core/workflows) to define a deterministic, type-safe state machine: $$\text{extract} \longrightarrow \text{validate} \longrightarrow \text{store} \longrightarrow \text{forecast} \longrightarrow \text{summarize}$$
Each step validates inputs and outputs using Zod schemas, ensuring end-to-end data integrity between the Python backend and TypeScript orchestrator.

4. Storage & Observability

SQLite (ledgerlens.db): Lightweight, embedded, zero-configuration local database.
Observability Tracker: Automatically records step latencies, token consumption, and timestamps to observability.json.

Why Does Open Innovation Matter?

Open innovation is what made LedgerLens possible. Here is a direct comparison between building this with open-source AI versus closed proprietary APIs:

Feature	Local-First Open Source (LedgerLens)	Closed Cloud APIs (e.g. AWS Textract / Cloud Vision)
Cost per 1,000 Receipts	$0.00 (Free on existing laptop hardware)	$50.00 – $150.00 ($0.05 – $0.15 per page processed)
Offline Reliability	100% Offline (Works in remote rural shops with zero connectivity)	0% Offline (Fails completely without constant internet)
Data Privacy & Sovereignty	100% On-Device (Customer ledger never leaves the merchant's machine)	Cloud Egress (Customer financial logs stored on third-party servers)
Vernacular Handwriting	Adaptable open weights fine-tuned on Hindi/Hinglish scripts	Generic OCR often struggles with mixed Indic handwriting
Unit Economics for Side Hustle	High Margin (Only software license costs; zero API bills)	Eaten by API fees (Margins evaporate as receipt volume grows)

With closed APIs, a small shopkeeper cannot afford $100/month just to digitize daily receipts. Open-source models turn what used to be an expensive enterprise cloud service into a free utility running on a $300 refurbished laptop.

Ground-Truth Benchmark Results

We evaluated LedgerLens against 5 hand-labeled ground truth datasets in /samples:


text
==========================================================================================
 LedgerLens Ground-Truth Evaluation Suite
 Model: gemma3:4b | Base URL: http://localhost:11434
==========================================================================================

Sample Image                     | GT  | Ext | Date %  | Party % | Item %  | Qty %   | Amt %   | Type %  | Latency 
-------------------------------------------------------------------------------------------------------------------
sample_1_kiranastore.png         | 4   | 4   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 4256ms  
sample_2_chai_tea_bill.png       | 4   | 4   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 4091ms  
sample_3_hindi_khata.png         | 4   | 4   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 4134ms  
sample_4_hardware_invoice.png    | 4   | 4   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 4118ms  
sample_5_daily_ledger_mixed.png  | 4   | 4   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 4113ms  
-------------------------------------------------------------------------------------------------------------------
AVERAGE / OVERALL                | -   | -   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 100.0   | 4143ms
===================================================================================================================

>> OVERALL FIELD-LEVEL ACCURACY: 100.0%
>> AVERAGE EXTRACTION LATENCY:   4142.5ms per image

NatureQuest-AI

Palak Agarwal — Mon, 12 Oct 2026 06:54:13 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

🌿 NatureQuest-AI: Mindful Everyday Nature Discovery

What I Built

We live in an age of pervasive screen fatigue. Notifications, endless feeds, and fluorescent-lit workspaces trap us in perpetual digital overdrive. Many people believe that "connecting with nature" requires booking an expensive vacation, packing heavy hiking gear, or driving hours to a national park. As a result, we overlook the rich, thriving micro-ecosystems happening right in front of us every single day—in the cracks of our sidewalks, on our apartment balconies, around street trees, and in neighborhood parks.

NatureQuest-AI was built to change that. It is an intelligent, privacy-first nature companion that transforms ordinary routines—a 10-minute balcony coffee break, a 15-minute walk around the block, or a quiet pause on a park bench—into grounded, mindful micro-expeditions.

Key Features & How It Gets People Outdoors

Tailored Micro-Expeditions in Under 30 Minutes: Instead of passive reading or generic Wikipedia summaries, NatureQuest-AI generates structured, sensory observation quests customized to your exact setting (Balcony/Window, Urban Street, Backyard, Park, Forest Trail) and available time (5–30 minutes).
Sensory & Scientific Observation Guides: Quests guide you through concrete physical exploration:
- Leaf Architecture & Venation Detective: Examining microscopic circulatory systems of living leaves to uncover how plants transport water.
- Solar Sundial & Shadow Drift: Marking subtle shadow drift across natural surfaces to witness the kinetic rotation of planet Earth in real time.
- Acoustic Soundscape Mapping: Closing your eyes and mapping near vs. distant bird frequencies and wind currents.
- Pavement Crack Micro-Ecology: Investigating resilient mosses, lichen colonies, and ant foraging highways in urban concrete.
Strictly Non-Destructive Conservation Ethic: Every generated quest contains explicit Leave-No-Trace principles and safety guidance, reminding explorers to observe without disturbing living organisms or damaging fragile habitats.
Personal Field Journal (Full CRUD): Capture what you saw, heard, and smelled. Record reflection notes, weather context, and custom tags. You can edit, search, and export your discoveries to clean Markdown (.md) or structured JSON (.json) with a single click.
Honest, Truth-Based Progress Tracking: No synthetic streaks, dopamine traps, or vanity game points. NatureQuest-AI visualizes authentic progress based strictly on your verified journaled sessions, highlighting habitats explored and observation minutes logged.

Demo

Live Repository: github.com/palak2122-ag/NatureQuest-AI
Local Quick Run:

  git clone https://github.com/palak2122-ag/NatureQuest-AI.git
  cd NatureQuest-AI
  pip install -r requirements.txt
  streamlit run app.py

(Zero configuration needed—the app launches immediately with full offline capabilities!)

🎥 Walkthrough Preview:

Home Overview: Quick-launch curated quests, review your time spent outdoors, and inspect your latest journal entries.

AI Nature Discovery: Configure your surroundings, select your available time and observational focus (Botany, Wildlife, Geology, Sky/Atmosphere, Mindfulness), and generate an interactive quest complete with a session timer.

Explore Library: Browse 20+ varied nature archetypes filterable by environment, difficulty, and duration.

Field Journal: Record your thoughts and sensory observations directly into your private nature diary.

Insights & Milestones: Track your genuine observation hours and celebrate authentic outdoor exploration milestones.

Code

You can find the full source code and documentation on GitHub:

palak2122-ag / NatureQuest-AI

An open-source AI app that generates personalized outdoor nature missions.

NatureQuest-AI 🌿

Discover Nature in Your Everyday Surroundings
An AI-powered, mindful nature discovery and micro-ecology platform that transforms everyday strolls, balconies, and urban streets into immersive outdoor discoveries.

🌟 Key Features

AI Nature Discovery Engine (Multi-Tier)
- Google Gemini Integration: Cloud inference generating structured observation guides tailored to precise duration, micro-habitat, and language.
- Local Gemma via Ollama: Optional, fully private offline neural inference on your local machine.
- Curated Offline Recommendation Engine: 100% reliable fallback with 20+ rich archetypes, smart scoring, and multilingual support (English, Hindi, Hinglish). Never blocked by missing API keys or internet downtime.
Honest Source Attribution & Safety
- Plans explicitly display their source: Gemini AI, Local Gemma via Ollama, or Offline recommendation engine.
- Built-in conservation rules: strictly non-destructive observation guidelines that protect urban wildlife and plant life.
Curated Explore Library
- 20+ diverse, scientifically grounded quests (Leaf Venation Architecture, Solar Shadow Drift, Acoustic Soundscape…

View on GitHub

Repository Highlights

100% Python-Powered: Built with Streamlit, Pydantic v2, and clean modular architecture.
Extensive Test Suite: 38 automated unit tests covering storage concurrency, Pydantic schema validation, duplicate prevention, and AI provider fallback probes.
Accessible Design System: Custom nature-inspired palette (Warm Ivory #FBF9F5, Deep Forest Green #1B3B2B, Sage #5C8374, and Plus Jakarta Sans typography).

How I Built It

NatureQuest-AI was engineered from the ground up around open-weight models, local inference, and a transparent multi-tier AI architecture.

                           ┌────────────────────────────┐
                           │   NatureQuest-AI App       │
                           │   (Streamlit + UI System)  │
                           └──────────────┬─────────────┘
                                          │
                            Provider Probe & Health Check
                                          │
              ┌───────────────────────────┼──────────────────────────┐
              ▼                           ▼                          ▼
    ┌───────────────────┐       ┌───────────────────┐      ┌───────────────────┐
    │   Google Gemini   │       │    Local Gemma    │      │  Curated Offline  │
    │   (Cloud API)     │       │   (Ollama Open)   │      │ Recommendation    │
    │  gemini-1.5-flash │       │     gemma2:2b     │      │      Engine       │
    └───────────────────┘       └───────────────────┘      └───────────────────┘

1. Open-Weight Local Inference with Gemma 2 & Ollama

When stepping outdoors, internet connectivity can be spotty or completely unavailable on park trails and nature walks. To ensure genuine accessibility and privacy, NatureQuest-AI natively supports Gemma 2 (2B / 9B) via Ollama.

Local & On-Device: Connects to http://localhost:11434 to run Gemma locally without sending a single byte of observation or prompt data over the internet.
Strict Schema Enforcement: Prompts are constrained to return strictly validated JSON matching our NaturePlan schema, parsed and verified through Pydantic v2.

2. Multi-Tier Provider Manager with Transparent Attribution

In NatureQuest-AI, we believe in radical transparency:

If a quest is generated by Google Gemini (1.5 Flash), the UI clearly displays ✨ Source: Google Gemini AI.
If generated by Local Gemma, it shows ⚡ Source: Local Gemma via Ollama.
If generated without any AI connection, it proudly displays 📘 Source: Offline recommendation engine.

3. Curated Offline Recommendation Engine (Zero-Failure Guarantee)

Technology should never be the barrier that stops someone from touching grass. If you don't have an API key or don't have Ollama installed, NatureQuest-AI automatically falls back to an internal knowledge engine featuring 20+ rich micro-ecology archetypes with smart habitat matching and multilingual adaptation (English, Hindi, Hinglish).

4. Local-First & Atomic Data Persistence

All personal notes, field observations, and completed quests are saved locally in data/ using atomic file writes and thread locks. Your private reflections never leave your machine.

Why Does Open Innovation Matter?

The very philosophy of "Touch Grass" is rooted in grounding, personal sovereignty, and stepping away from monopolistic walled gardens.

Here is why open innovation and open-weight models are vital for this project:

Nature Doesn't Have Wi-Fi (Offline Resilience):
The best moments of nature observation happen away from cellular towers—in deep woods, shaded canyons, or quiet park groves. Closed cloud APIs become useless the moment your signal drops. Open-weight models like Gemma 2 running locally on consumer hardware allow anyone to take intelligent, context-aware observation companions directly into the wilderness.
Absolute Data Sovereignty for Personal Reflections:
A field journal is an intimate record of your thoughts, quiet moments, and mental health. Users shouldn't have to surrender their private reflections or location patterns to closed corporate servers to enjoy AI assistance. Open-source AI makes local-first privacy an everyday reality.
No Financial Paywalls for Outdoor Wellness:
Connecting with the natural world should be free and accessible to everyone. Closed commercial APIs impose ongoing per-token costs and subscription walls. Open models give students, educators, community centers, and curious individuals unrestricted access to AI-powered discovery without credit cards.
Transparent, Community-Auditable Prompts:
With open innovation, our prompt templates, conservation guardrails, and observation mechanics are fully visible and community-auditable. There are no hidden biases or opaque filters dictating how people experience their physical environment.

My Agent Session

During the development of NatureQuest-AI, pair programming and agentic workflows were leveraged to build the component library, establish Pydantic v2 data models, write 38 automated test cases, and solve real-world UI edge cases (such as preventing Markdown indentation code block triggers in Streamlit when rendering rich HTML quest cards).

Prize Categories

Primary Track: Touch Grass — Designed from the ground up to disconnect users from digital feeds and immerse them in everyday outdoor micro-ecology.
Open-Source AI / Open Weights — Native integration with Google's open-weight Gemma 2 running locally and privately via Ollama.