DEV Community: Nikhil Pradhan

LazyDesk AI: The Sloth-Approved, 100% Local Desktop Organizer & PDF Synthesizer Powered by Gemma 3

Nikhil Pradhan — Mon, 26 Oct 2026 06:24:21 +0000

What I Built
The Philosophy of the Sloth: Conserving Energy by Automating Dreaded Chores

The Hacktoberfest Week 3 challenge arrived with an inspiring observation: Sloths have life figured out. They move at their own pace, conserve energy, and refuse to waste effort on tasks that don't serve them.

When the challenge organizers brainstormed ideas for this theme, one suggestion stood out immediately:

"A file and inbox tidier that automatically sorts, renames, and archives the clutter you keep putting off."

We all have that folder. The Downloads or Desktop directory overflowing with hundreds of unfiled items: invoices named Invoice_Final_v2(1).pdf, spreadsheets from three quarters ago, code snippets, compressed archives, and 30-page documents we promised ourselves we’d read later. Cleaning it takes mental energy we'd rather conserve. Yet, uploading these files to cloud-based AI tools presents a massive privacy breach: our desktops harbor tax forms, medical PDFs, confidential contracts, and personal photos.

LazyDesk AI was built to solve this dilemma. It is a 100% local-first, privacy-guaranteed desktop productivity assistant that sorts chaotic files, uncovers duplicate documents, and extracts structured insights from multi-page PDFs—all running directly on your computer using Google's open-weight Gemma 3 4B via Ollama.

What Effort Does It Save?

LazyDesk AI turns hours of tedious computer chores into effortless, single-click operations:

Automated, Non-Destructive File Sorting: Categorizes files into 8 clean directories (Documents, Spreadsheets, Images, Videos, Audio, Code, Archives, and Other). It generates an interactive Move Preview, handles filename collisions automatically (report_1.pdf) so nothing is ever overwritten, supports a Dry-Run mode, and provides 1-click undo history if you ever change your mind.
Cryptographic Duplicate Discovery (Report-Only): Employs a two-stage filter (exact byte-size grouping + streaming 64 KB chunked SHA-256 hashes) to find duplicate files with different names. It shows reclaimable disk space and never deletes your files automatically.
Instant 5-Part Executive Summaries with Gemma 3 4B: Instead of wading through dense 20-page PDFs, PyMuPDF extracts the text in milliseconds and local Gemma 3 4B synthesizes:
Executive Overview: High-level context and objectives.
Key Points & Insights: Crucial arguments and takeaways.
Important Dates, Deadlines & Entities: Concrete milestones and organizations.
Action Items & Next Steps: Immediate tasks extracted from the text.
Document Notes & Uncertainties: Transparent flags for ambiguities or gaps.
Strictly Grounded Document Q&A: Query your document in natural language. Gemma 3 4B answers based strictly on the document's verified text, cites page numbers, and explicitly declines to answer if information is absent—eliminating hallucination.
Who Gets to Be a Little Lazier Because of It?
Developers & Tech Workers who let daily installers, scripts, and logs turn their folders into digital junkyards.
Students & Researchers juggling stacks of academic papers who need instant takeaways, deadlines, and citations without reading 40 pages per document.
Freelancers & Business Owners handling private client invoices, contracts, and receipts who demand complete privacy without cloud subscription fees.
Demo

LazyDesk AI features a dark, muted-neutral dashboard built in Streamlit with slate and indigo styling. It includes a built-in, completely isolated demo sandbox so you can explore all features safely without touching your real files.

Interactive Workflow:
Launch App: Run python -m streamlit run app.py (opens on http://localhost:8501).
One-Click Demo Sandbox: In the sidebar, click "📂 Load Demo Sandbox Path" to populate realistic sample data (invoices, spreadsheets, code, duplicate files, and a multi-page PDF spec).
Inspect the Dashboard: View volume metrics, category breakdowns, and searchable file tables.
Preview & Organize: Test Dry Run Mode, review proposed moves, and watch conflict renaming in action.
Detect Duplicates: Identify identical invoice copies and inspect exact reclaimable bytes.
Synthesize PDFs: Upload LazyDesk_Product_Specification.pdf and watch Gemma 3 4B deliver an executive summary with action items in seconds.
One-Click Rollback: Test the Operation History & Undo tab to restore all files to their original directories.
+--------------------------------------------------------------------------+
| [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 |
+--------------------------------------------------------------------------+

(Walkthrough repository and screenshots: https://github.com/your-username/lazydesk-ai
)

Code

LazyDesk AI is open-source, modular, and built on Python 3.13+:

text
lazydesk-ai/
├── app.py ├── .streamlit/config.toml ├── modules/
│ ├── config.py │ ├── file_scanner.py │ ├── organizer.py │ ├── duplicate_detector.py │ ├── pdf_processor.py │ ├── local_ai.py │ └── operation_history.py ├── sample_data/ │ ├── create_demo_data.py │ └── demo_sandbox/ ├── tests/ │ ├── test_file_scanner.py │ ├── test_organizer.py │ ├── test_duplicate_detector.py │ ├── test_pdf_processor.py │ ├── test_local_ai.py │ └── test_operation_history.py ├── requirements.txt ├── ARCHITECTURE.md └── README.md GitHub Repository # Streamlit productivity dashboard & navigation
# Dark muted-neutral theme configuration
# Category mappings, exclusions, AI defaults
# Direct-file scanner & metric aggregation
# Conflict resolution, preview, move & rollback
# Size pre-filter + SHA-256 chunked hashing
# PyMuPDF text engine & scanned PDF detector
# Ollama REST API client (Gemma 3 4B)
# JSON audit history logger for undo support
# Isolated test files (never touches real data)
# Demo sandbox generator
# Sample PDFs, CSVs, scripts, and duplicates
# 30 automated unit tests (100% green)
# Categorization, paths, edge cases
# Previews, dry runs, safe moves, undo
# Content hashing, size pre-filtering
# PyMuPDF extraction, scanned detection
# Mocked Ollama endpoints, timeouts, errors
# Audit logging & persistence
# Dependencies (PyMuPDF, Streamlit, Ollama client)
# System architecture documentation
# Complete Windows/Linux setup instructions

🔗 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 extracted document text strictly to the local Ollama instance."""
clean_text = document_text.strip()
if not clean_text:
return AISummaryResult(
success=False,
summary_markdown="",
model_used=model,
error_message="Document text is empty.",
)
prompt = build_summarization_prompt(clean_text, filename)
endpoint = f"{base_url.rstrip('/')}/api/generate"
payload = {
"model": model,
"prompt": prompt,
"stream": False,
"options": {
"temperature": 0.2, # Low temperature for strict factual fidelity
"top_p": 0.9,
},
}
# Pure localhost communication: Zero bytes leave your machine
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 around a guiding engineering principle: Use deterministic algorithms where they shine, and open-weight AI where qualitative intelligence is needed.

Local Open-Weight AI: Google's Gemma 3 4B via Ollama

Rather than an external chatbot wrapper, Gemma 3 4B powers real document intelligence:

Parameter Efficiency: Gemma 3 4B delivers crisp logical synthesis and structured extraction within a compact memory footprint that runs smoothly on standard laptops (CPU or modest GPU).
Zero Cloud Egress: Communicates exclusively with http://localhost:11434/api/generate. No remote tokens, tracking, or telemetry.
Robust Error Handling: The UI detects whether Ollama is online, checks if gemma3:4b is installed, and provides copy-pasteable terminal commands if setup is needed.

High-Performance PDF Extraction: PyMuPDF (fitz)

Text is parsed using PyMuPDF, providing sub-second text extraction and page indexing.

Scanned PDF Guard: If a user uploads an image-only scanned document without an OCR layer, LazyDesk AI detects the lack of digital characters and explicitly warns the user that OCR is required—preventing the AI from hallucinating or claiming it read an unreadable file.
Context Protection: Caps extraction to prevent context window blowout on resource-constrained hardware.

Defensive File Operations & Reversibility Preview & Dry Run: Users inspect a full table of proposed moves before touching disk. Conflict Avoidance: If invoice.pdf exists at the destination, the organizer renames the new file to invoice_1.pdf. Overwriting is physically impossible. Transaction History: Every batch operation is saved with original paths, destination paths, and timestamps to ~/.lazydesk/operations_history.json. Clicking "Undo Operation" restores everything and prunes newly emptied folders.
Rigorous Quality Assurance (30 Passing Tests)

To guarantee stability, a complete pytest suite covers all modules:

text
============================= test session starts =============================
platform win32 -- Python 3.14.6, pytest-9.1.1
collected 30 items
tests/test_duplicate_detector.py::test_calculate_sha256 PASSED [ 3%]
tests/test_duplicate_detector.py::test_detect_duplicates_with_identical_content PASSED [ 6%]
tests/test_duplicate_detector.py::test_no_duplicates_when_files_differ_in_content PASSED [ 10%]
tests/test_file_scanner.py::test_categorize_extension PASSED [ 13%]
tests/test_file_scanner.py::test_format_bytes PASSED [ 16%]
tests/test_file_scanner.py::test_scan_nonexistent_directory PASSED [ 20%]
tests/test_file_scanner.py::test_scan_file_instead_of_directory PASSED [ 23%]
tests/test_file_scanner.py::test_scan_empty_directory PASSED [ 26%]
tests/test_file_scanner.py::test_scan_populated_directory PASSED [ 30%]
tests/test_local_ai.py::test_build_summarization_prompt PASSED [ 33%]
tests/test_local_ai.py::test_check_ollama_status_connected_with_model PASSED [ 36%]
tests/test_local_ai.py::test_check_ollama_status_connected_without_model PASSED [ 40%]
tests/test_local_ai.py::test_check_ollama_status_connection_error PASSED [ 43%]
tests/test_local_ai.py::test_check_ollama_status_timeout PASSED [ 46%]
tests/test_local_ai.py::test_generate_summary_empty_text PASSED [ 50%]
tests/test_local_ai.py::test_generate_summary_success PASSED [ 53%]
tests/test_local_ai.py::test_generate_summary_timeout PASSED [ 56%]
tests/test_local_ai.py::test_answer_document_question_success PASSED [ 60%]
tests/test_local_ai.py::test_answer_document_question_empty_query PASSED [ 63%]
tests/test_operation_history.py::test_create_new_batch_id PASSED [ 66%]
tests/test_operation_history.py::test_save_and_retrieve_history PASSED [ 70%]
tests/test_organizer.py::test_resolve_filename_conflict PASSED [ 73%]
tests/test_organizer.py::test_preview_organization PASSED [ 76%]
tests/test_organizer.py::test_execute_organization_dry_run PASSED [ 80%]
tests/test_organizer.py::test_execute_and_undo_organization PASSED [ 83%]
tests/test_pdf_processor.py::test_extract_valid_pdf_bytes PASSED [ 86%]
tests/test_pdf_processor.py::test_extract_pdf_file_path PASSED [ 90%]
tests/test_pdf_processor.py::test_detect_empty_or_scanned_pdf PASSED [ 93%]
tests/test_pdf_processor.py::test_pdf_character_truncation PASSED [ 96%]
tests/test_pdf_processor.py::test_invalid_pdf_data PASSED [100%]
============================= 30 passed in 0.67s ==============================
Why Does Open Innovation Matter?

When an AI tool interacts with your personal computer, open innovation isn't just an ideological preference—it is the only architecture that makes technical sense.

Absolute Data Sovereignty

Your Downloads folder holds bank statements, proprietary source code, tax filings, and personal medical receipts. Feeding this directory into a closed cloud API requires transmitting your files to third-party servers where they risk inclusion in model training logs. With open weights like Gemma 3 running locally, your private data never leaves your RAM and SSD.

Predictable, Zero-Cost Operation

Closed APIs charge per thousand tokens. When sorting through folders or summarizing dozens of documents a week, metered API bills create hesitation. With open-weight AI, running inference is as free as running a calculator. You can be as lazy as you want without worrying about monthly subscriptions or token limits.

Offline Resilience

Whether you are on an airplane, commuting on a train, or experiencing an internet outage, LazyDesk AI works identically. Cloud APIs fail the moment Wi-Fi drops; local open-weight AI remains completely functional.

True User Agency & Model Swapping

Closed ecosystems trap you in vendor lock-in. Because LazyDesk AI connects to standard Ollama endpoints, users can effortlessly swap between models (gemma3:4b, llama3.2, mistral, phi3) with a single click in the Settings tab.

My Agent Session

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

The agent served as architect, QA engineer, and implementation partner:

Modular Scaffolding: Structured the system into 6 decoupled modules adhering to single-responsibility principles.
Defensive Engineering: Caught real-world edge cases early (e.g., Python dataclass default argument ordering, multi-line PyMuPDF bounding-box text placement, and Streamlit CSRF configuration).
Automated Sandbox Generation: Wrote create_demo_data.py to ensure all tests and interactive walkthroughs run in an isolated environment without ever touching personal files.
Verification: Executed the test suite autonomously and ensured the live Streamlit server returned healthy HTTP 200 responses before declaring completion.

The full development session transcript, tool calls, and test execution logs are preserved in the project's repository under the .system_generated audit logs, showcasing the complete agentic development journey from architecture design to passing unit tests.

The Lazy Payoff

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

Task The Hard Way (Manual / Cloud API) The LazyDesk AI Way Time & Effort Saved
Cleaning a 200-file Downloads folder 45 minutes of dragging files, creating folders, and checking extensions. 3 seconds: Click Preview, Click Confirm. Files are categorized. 45 minutes saved
Hunting down duplicate files Manually opening files, comparing file dates, checking byte sizes. Instant: Automated SHA-256 scan shows duplicate groups and reclaimable bytes. Zero mental fatigue
Extracting action items from a 30-page PDF 30 minutes of skimming for dates, deliverables, and names. 15 seconds: Gemma 3 4B extracts exact deadlines, named entities, and action items. 29 minutes saved
Regretting a move operation Frantically digging through folders trying to remember where files used to be. 1 click: Click "Undo Operation" in History to restore original file locations. Zero panic
Prize Categories
🌟 Featured Partner Category: Best Use of Gemma ($200 USD)

"Use Gemma, Google's open-weight model, in building your project: run it locally, fine-tune it, or serve it through Google Cloud or another provider."

Why LazyDesk AI Qualifies: LazyDesk AI places Google's open-weight Gemma 3 4B at the very center of its application architecture. Gemma 3 4B runs 100% locally on the user's computer via Ollama, performing real, high-value document synthesis and grounded Q&A tasks. The application is specifically tuned with prompts that leverage Gemma's instruction-following strengths to extract executive summaries, action items, and temporal entities without hallucination.

🏆 Main Challenge Category: Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

"Build something with open-weight models or open-source AI that rewards laziness."

Why LazyDesk AI Qualifies: Directly inspired by the challenge theme and International Sloth Day, LazyDesk AI automates the dreaded chore of desktop decluttering, duplicate finding, and document reading. It is fully open-source, local-first, rigorously tested, and lets you be lazy without compromising your privacy.

Built with ❤️ for Hacktoberfest 2026. Keep your desktop clean, your AI open, and your data local.

Ledge-Layer

Nikhil Pradhan — Mon, 19 Oct 2026 06:59:29 +0000

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

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

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

Nikhil Pradhan — Mon, 12 Oct 2026 06:54:19 +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.