DEV Community: PRUTHVI RAJ G

👻 WRAITH: Resurrecting Lost Memories with Local Gemma 4 — The Ghost in the Machine

PRUTHVI RAJ G — Wed, 28 Oct 2026 13:13:54 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine.

What if an old diary could tell its story again? What if forgotten letters could preserve not only the facts they contain, but also the emotions and mysteries hidden between their lines?

Meet WRAITH — a local-first AI memory archive that transforms historical letters, diary entries, and personal recollections into atmospheric gothic stories while keeping factual information separate from creative interpretation.

🔗 GitHub Repository: https://github.com/PruthviRajG25/Hacktoberfest-Week4

Every Memory Leaves a Shadow.

🕯️ What I Built

WRAITH is a privacy-focused archival and storytelling application powered by Google DeepMind's Gemma 4, running locally through Ollama.

It explores an interesting question: can AI help us preserve the emotional depth of personal memories without losing sight of the original facts?

WRAITH approaches this through two complementary layers:

The Verified Ledger: Extracts explicitly mentioned people, dates, events, and other details from the source text.
The Haunted Chronicle: Uses the mood, imagery, and emotional themes of the original text to create an atmospheric gothic ghost story.

The goal is to make historical preservation more engaging while clearly distinguishing information found in the source from AI-generated fiction.

🎯 The Problem

Personal diaries, handwritten letters, and family archives can hold irreplaceable memories. However, preserving and exploring them with modern AI introduces several challenges.

Privacy concerns: Uploading intimate family records to cloud-based AI services may expose sensitive information to third-party systems.
Historical accuracy: Generative AI can invent details or mix fictional elements with real events.
Accessibility: Some AI solutions depend on cloud services, paid APIs, or hardware that may not be available to everyone.

WRAITH explores a local-first alternative that prioritizes privacy, separates facts from fiction, and makes archival storytelling accessible through a web interface.

👻 How WRAITH Interprets “Ghost in the Machine”

Rather than treating the ghost as a literal supernatural presence, I approached the theme metaphorically.

What if the machine became a medium through which forgotten memories could speak again?

A diary entry becomes the starting point. The AI identifies the details present in the original text and then creates a fictional narrative inspired by its atmosphere.

The result is an experience that combines archival organization with creative storytelling—without presenting invented supernatural events as historical facts.

🚀 Demo

🕯️ Interactive Presentation

WRAITH also includes a standalone interactive experience in poster.html.

It features:

Atmospheric soundscape: Procedurally generated ambient audio using the Web Audio API.
Interactive ghost lantern: A cursor-based flashlight effect that reveals hidden visual details.
Interactive séance simulator: A typewriter-style presentation that illustrates the AI analysis experience.
Print-ready presentation: A dedicated layout for sharing the project during demonstrations and judging.

These elements bring the project's theme to life beyond its core AI functionality.

⚡ Run WRAITH Locally

You will need Node.js, npm, and Ollama installed.

1. Download the model

ollama pull gemma4:e2b

2. Clone the repository

git clone https://github.com/PruthviRajG25/Hacktoberfest-Week4.git
cd Hacktoberfest-Week4

3. Install dependencies

npm run install:all

4. Start the application

npm run dev

Open http://localhost:3000 in your browser, assuming the application is configured to use that port.

You can also open poster.html to explore the standalone presentation.

Note: Model availability, hardware requirements, and startup commands depend on the installed Ollama version and the repository configuration. Check the README if you encounter any issues.

🏗️ Technical Architecture

WRAITH uses a lightweight web architecture that connects a browser-based interface to a locally running AI model.

┌────────────────────────────────────┐
│           React + Vite             │
│       User Interface               │
│  Input · Results · Local Storage    │
└──────────────────┬─────────────────┘
                   │
                   ▼
┌────────────────────────────────────┐
│       Node.js + Express             │
│                                    │
│  Input Validation & Sanitization   │
│  API Routes & Structured Responses │
└──────────────────┬─────────────────┘
                   │
                   ▼
┌────────────────────────────────────┐
│            Ollama                  │
│       Local Model Runtime          │
└──────────────────┬─────────────────┘
                   │
                   ▼
┌────────────────────────────────────┐
│          Gemma 4                   │
│   Fact Extraction & Storytelling   │
└────────────────────────────────────┘

Technology Stack

Frontend: React 18, Vite, custom CSS, responsive interface.
Backend: Node.js and Express for API handling, input sanitization, and response validation.
AI: Google DeepMind's Gemma 4 through Ollama for local inference.
Data storage: Browser localStorage for locally saved records.
Export: Markdown files with YAML frontmatter for use with tools such as Obsidian and Logseq.
Interactive experience: HTML, CSS, JavaScript, and the Web Audio API.

Why a Backend?

The Express backend is an important part of WRAITH, not just a connection layer.

It handles incoming requests, validates and sanitizes user input, communicates with the local model runtime, and returns structured responses to the frontend. This creates a clear separation between the user interface and AI processing.

Keeping this logic behind a backend also provides a foundation for adding stronger validation, error handling, testing, and more advanced archival features in the future.

🧠 How I Built It

1. Running an Open-Weight Model Locally

WRAITH uses Gemma 4 through Ollama rather than relying on a hosted AI API for its core inference workflow.

This design aims to keep personal archival text on the user's device during local processing, reducing the need to send sensitive content to an external AI provider.

Local execution also provides an opportunity to experiment with open-weight AI while learning how model runtimes integrate with a full-stack application.

2. Separating Facts from Fiction

One of the most important design decisions was to avoid mixing extracted historical details with generated storytelling.

The backend sends structured instructions to the model and requests a JSON response.

For example, the model is instructed to:

Extract only names, dates, and events explicitly supported by the input.
Return empty arrays when the source contains no relevant information.
Keep factual extraction separate from creative storytelling.
Generate a short gothic narrative inspired by the source text.
Return the results in a consistent JSON structure.

Here is a simplified example of the response format:

{
  "title": "The Forgotten Attic",
  "summary": "A mysterious memory preserved in an old diary.",
  "people": [],
  "dates": [],
  "facts": [],
  "story": "The house stood silent beneath the winter sky..."
}

The example above illustrates the response structure, not a verified output from a specific test.

Structured output makes the results easier for the frontend to display and helps maintain a clear boundary between source-supported information and generated fiction. However, model outputs still require validation, and factual extraction is not guaranteed to be error-free.

🌍 Why Open Innovation Matters

For a project dealing with personal memories, privacy and accessibility are important design considerations.

🔐 1. Privacy by Design

Personal letters and diaries can contain deeply sensitive information. Running inference locally can reduce exposure to third-party AI services, provided the application is configured to keep processing and storage local.

WRAITH is designed around this principle: the user's memories should remain under their control.

💻 2. Accessible AI

Local inference offers an alternative to applications that depend entirely on paid cloud APIs.

The practical hardware requirements depend on the selected model, quantization, available memory, and system configuration, but the approach makes experimentation with open-weight AI possible without requiring a dedicated cloud inference service.

📚 3. Long-Term Preservation

A local-first architecture gives users more control over their archives. Markdown export also makes records easier to move between compatible applications and personal knowledge-management systems.

The aim is not to promise that software will work forever, but to make preserved information portable and less dependent on a single hosted service.

🛠️ My Development Process

Building WRAITH brought together several areas of full-stack development:

AI integration: Connecting a locally hosted model to a web application.
Prompt engineering: Designing instructions that separate source-based extraction from creative generation.
Backend development: Building API routes, validating input, and handling structured model responses.
Frontend development: Creating a responsive interface with a consistent gothic visual identity.
Creative interaction design: Using CSS animations, cursor effects, and procedural audio to reinforce the theme.
Developer experience: Organizing installation and startup commands to simplify local setup.

The biggest design challenge was balancing two very different goals: preserving the integrity of historical information and creating an engaging fictional experience.

Keeping those outputs separate became the foundation of the project.

🕰️ The Experience: When a Memory Becomes a Story

Imagine opening an old diary and finding a fragment about a locked attic, a brass key, and a ticking pocket watch.

WRAITH's goal is to preserve the details that the text actually mentions while creating a separate fictional narrative inspired by its atmosphere.

The historical record remains the starting point. The story becomes an interpretation—not a replacement for the original memory.

That distinction is what makes this project meaningful to me. AI does not need to rewrite the past to help us explore it. Sometimes, it can simply give forgotten words a new way to be experienced.

That is the ghost in the machine: not a ghost living inside the model, but the echoes of human memories brought to life through technology.

🔗 Explore WRAITH

Source code: https://github.com/PruthviRajG25/Hacktoberfest-Week4
Interactive poster: https://github.com/PruthviRajG25/Hacktoberfest-Week4/blob/main/poster.html
Challenge: https://dev.to/challenges/hacktoberfest-week4-2026-10-26

I'd love to hear your thoughts!

If you could preserve one memory, letter, or story using AI, what would it be? 🕯️

devchallenge #hf26challenge #webdev #opensource

SlothStack: Slow Down. Automate More. 🦥

PRUTHVI RAJ G — Thu, 22 Oct 2026 16:01:14 +0000

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

What I Built

Meet SlothStack — a local-first AI productivity assistant designed to handle repetitive digital work so you can focus on what actually matters.

We spend too much time organizing files, searching through documents, tracking deadlines, renaming downloads, and turning scattered information into actionable tasks. These small jobs may seem harmless, but together they consume a surprising amount of time and attention.

SlothStack aims to make that busywork easier by using AI agents to help organize your digital workspace.

Here's what it is designed to do:

📂 Smart File Organization: Categorize documents and suggest meaningful filenames.
✅ Task Extraction: Identify action items, deadlines, and follow-ups from supported documents.
🔎 Duplicate Detection: Help identify potentially duplicated files and reduce clutter.
🧠 Action Planning: Turn unstructured information into clear, actionable next steps.
🛡️ Human-Approved Automation: Preview proposed file operations before approving changes.
🔒 Local-First AI: Use locally running open-weight models to keep document processing on your machine.

The goal is simple: less repetitive work, less context switching, and more time for meaningful work.

SlothStack is intended for students, developers, researchers, and anyone whose digital workspace has become a second job.

Demo

The ideal demo walks through one complete workflow:

Upload a sample document.
Let a locally running model analyze its contents.
Review extracted tasks and suggested file organization.
Preview the proposed actions.
Approve an action and inspect the activity log.

The important part isn't just generating an AI response. It's demonstrating how an AI agent can turn information into useful, reviewable actions.

Live Demo:https://frontend-seven-mocha-i9ejtz56kz.vercel.app

Code

PruthviRajG25 / Hacktoberfest-Week3

Sloth Stack is a local-first productivity workspace

Sloth Stack

Do less. Let your local AI handle the busywork.

Sloth Stack is a local-first productivity workspace that turns inbox exports documents, and visual notes into useful, reviewable work. Upload a mail export analyze it with Ollama, review extracted tasks and deadlines, then approve safe file actions. Your data stays in the local SQLite database and upload directory.

What it does

Workspace	Purpose
Dashboard	Content-grounded daily briefing, workload counters, and priorities
Files	Upload mail exports and documents, then start local AI analysis
Tasks	Review extracted mail tasks, complete them, or create custom deadline-aware todos
Action plans	Approve or reject safe proposed actions and use the interactive planning notebook
Activity	Inspect the local audit trail
Settings	Configure Ollama and open Gmail, WhatsApp Web, or Slack

Import a mailbox or message export

Download the safe demo file from frontend/public/sloth-stack-inbox-sample.txt upload it from Files, and select Analyze. The analyzer…

View on GitHub

GitHub Repository: .

SlothStack is being designed with open-source contributions in mind. The architecture separates the frontend, backend, AI integration, document processing, and safe action execution so contributors can improve individual components without needing to understand the entire codebase first.

Potential contribution areas include:

Adding document parsers and file formats.
Improving task extraction and categorization.
Supporting additional Ollama-compatible models.
Writing tests for agent workflows.
Improving accessibility and the dashboard experience.
Adding security checks and documentation.

The goal is to make SlothStack useful not just as a personal productivity tool, but as a project other developers can learn from and extend.

How I Built It

SlothStack is designed around a local-first architecture with a React frontend, a Python backend, and open-weight language models served through Ollama.

Technology stack

Frontend: React, TypeScript, Vite, and Tailwind CSS.
Backend: Python and FastAPI.
Data Layer: SQLite, SQLAlchemy, and Alembic migrations.
AI Inference: Ollama with locally running open-weight models.
Validation: Pydantic for structured data and validated agent outputs.
Testing: Pytest for backend tests and Vitest for frontend tests.

Rather than treating the AI as a chatbot that merely describes what to do, SlothStack is designed around controlled agent workflows.

For example, a document-processing workflow can:

Read an uploaded file in a supported format.
Extract its text using the appropriate parser.
Send relevant content to a locally running model.
Request structured results, such as categories, tasks, deadlines, and suggested actions.
Validate the model's response before using it.
Present the proposed action plan to the user.
Execute only explicitly approved operations.
Record the outcome in an activity log.

The supported document formats are intended to include TXT, Markdown, PDF, JSON, and CSV.

Safety is part of the architecture, not an afterthought. The model should not have unrestricted filesystem access or be allowed to execute arbitrary shell commands or Python code. File operations should be restricted to authorized directories, paths should be validated, and potentially destructive actions should require explicit approval.

SlothStack also aims to defend against prompt injection in document contents, enforce file-size limits, and handle invalid model outputs safely.

This design makes the agent more than a demo that works only with a carefully prepared prompt. It provides a foundation for repeatable workflows that users can inspect and control.

Why Does Open Innovation Matter?

A productivity assistant may handle personal notes, private documents, project plans, research, and other sensitive information. Sending all of that content to a remote AI service isn't always appropriate.

Open innovation makes a different approach possible.

With open-weight models and local inference, users can run supported models on their own machines, experiment with different models, and adapt SlothStack to their workflows without making a closed API the foundation of the entire product.

It also creates opportunities for community-driven development:

Model Freedom: Experiment with different compatible models rather than being tied to one provider.
Privacy-Conscious Processing: Keep inference local when using a locally configured model and local services.
Transparency: Inspect the code, review how actions are performed, and improve security.
Accessibility: Let contributors improve the application without requiring every feature to depend on a paid API.
Community Ownership: Build new parsers, integrations, workflows, and tests together.

Local inference doesn't automatically guarantee security or privacy; the application, model configuration, and surrounding services still matter. But it gives users more control over where their information is processed.

For me, open source is about making useful automation more accessible, understandable, and adaptable.

The Lazy Payoff 🦥

The real payoff isn't having AI do everything. It's eliminating the small, repetitive tasks that interrupt our concentration throughout the day.

Imagine finishing a study session or a development task and having a clear list of follow-ups, useful filenames for your documents, and an organized workspace instead of another pile of downloads and notes.

That's the idea behind SlothStack:

Automate the boring parts. Keep humans in control. Make meaningful work easier to start.

I won't claim a specific number of minutes saved without measuring it. A meaningful next step is to compare the time needed to organize a representative set of documents manually against the time needed with SlothStack, including review and approval.

The best automation is not the one that performs the most actions. It's the one that removes unnecessary effort without creating more work to clean up afterward.

Open List: AI Product Listing Generator for Small Sellers & Artisans (Powered by Gemma & MongoDB Atlas)

PRUTHVI RAJ G — Fri, 16 Oct 2026 16:40:22 +0000

What I Built 🛍️✨

Selling handmade crafts, vintage goods, or boutique items online is exciting, but writing product listings is exhausting.

Independent creators on Etsy, eBay, and Instagram spend 20 to 30 minutes on every single item trying to write:

🔍 SEO-friendly product titles
✍️ Engaging story descriptions
📌 Bullet points for materials, dimensions, and specs
🏷️ Search tags (like Etsy's 13-tag limit)
📱 Social media captions with hashtags

Most commercial AI tools charge expensive monthly subscriptions or make up fake facts like false certifications and fake materials.

To fix this, I built Open List: an AI listing generator created specifically for small business owners and side hustlers.

You simply type in basic product notes (or pick a sample preset), and Open List turns them into a complete, professional listing in just 3 seconds.

Core Features 🌟

🛡️ Zero Hallucinations: The AI strictly sticks to the facts and materials you enter.
🎯 Multi-Channel Ready: Formats listings for Etsy, eBay, Instagram, WhatsApp, or standard online stores.
🎨 Brand Voice: Lets you set your shop tone (like "Warm & Artisanal" or "Playful") and ban words you dislike.
🔎 Smart Similarity Search: Uses MongoDB Atlas Vector Search so you can find similar past listings instantly.
✏️ Edit & Export Anywhere: Edit any section on the spot and download as Text (.txt), Spreadsheet (.csv), or JSON.

Demo 🚀📱

Experience Open List in action:

💻 Local Development URL: http://127.0.0.1:8000
📖 Interactive API Docs: http://127.0.0.1:8000/docs
⚡ 1-Click Presets Included: Comes with ready-to-test items (Handmade Ceramic Mug, Soy Candle, Leather Wallet, Bamboo Matcha Whisk) so anyone can test it with zero typing!

Code 💻📦

You can view the full source code and setup instructions on GitHub:

🔗 GitHub Repository: https://github.com/PruthviRajG25/Hacktoberfest-Week2

PruthviRajG25 / Hacktoberfest-Week2

AI-Powered Ecommerce Listing Generator Powered by Open-Weight Models & MongoDB Atlas

Open List 🛍️✨

AI-Powered Ecommerce Listing Generator Powered by Open-Weight Models & MongoDB Atlas

Open List is a modern, production-minded web application engineered for small businesses, independent artisans, Etsy/eBay sellers, Instagram boutiques, and local retailers. It transforms basic product specifications into SEO-optimized ecommerce listings, targeted search keywords, bullet-point highlights, and engaging social media captions using open-weight AI (Gemma 3 1B via Ollama) and MongoDB Atlas.

🏗️ System Architecture

<div class="js-render-enrichment-target" data-json='{"data":"flowchart TD\n subgraph Client[\"Frontend Client (React + TypeScript + Vite)\"]\n UI[\"Dashboard & Form Interfaces\"]\n Editable[\"Editable Listing Sections\"]\n Export[\"Export Engine (TXT, CSV, JSON)\"]\n end\n\n subgraph Service[\"Unified Backend (FastAPI + Uvicorn)\"]\n Static[\"Static Vite Asset Server (SPA Fallback)\"]\n API[\"REST API (/api/)\"]\n Router[\"Health / Listings / Brand / Search\"]\n Guard[\"Factual Anti-Hallucination Guardrails\"]\n end\n\n subgraph AI[\"Open-Weight Inference Layer\"]\n Ollama[\"Local Ollama Service (gemma3:1b)\"]\n Hosted[\"Hosted Open-Weight Endpoint (vLLM / Groq / Together)\"]\n end\n\n subgraph DB[\"Database & Search (MongoDB Atlas)\"]\n Atlas[\"MongoDB Atlas Cluster (open_list_db)\"]\n Vector[\"Atlas $vectorSearch Index (vector_index)\"]\n Fallback[\"Resilient In-Memory Fallback\"]\n end\n\n UI --> API\n Editable --> API\n Export --> UI\n Static -.-> UI\n API --> Guard\n Guard --> Ollama\n Guard -.-> Hosted\n API --> Atlas\n Atlas --> Vector\n Atlas -.-> Fallback\n"}' data-plain='flowchart TD
subgraph Client["Frontend Client (React + TypeScript + Vite)"]
UI["Dashboard & Form Interfaces"]
Editable["Editable Listing Sections"]
Export["Export Engine (TXT, CSV, JSON)"]
end
subgraph Service["Unified Backend (FastAPI + Uvicorn)"]
Static["Static Vite Asset Server (SPA Fallback)"]
API["REST API (/api/)"]
Router["Health / Listings / Brand / Search"]
Guard["Factual Anti-Hallucination Guardrails"]
end

subgraph AI["Open-Weight Inference Layer"]
    Ollama["Local Ollama Service (gemma3:1b)"]
    Hosted["Hosted Open-Weight Endpoint (vLLM / Groq / Together)"]
end

subgraph DB["Database &amp; Search (MongoDB Atlas)"]
    Atlas["MongoDB Atlas Cluster (open_list_db)"]
    Vector["Atlas $vectorSearch Index (vector_index)"]
    Fallback["Resilient In-Memory Fallback"]
end

UI --&gt; API
Editable --&gt; API
Export --&gt; UI
Static -.-&gt; UI
API --&gt; Guard
Guard --&gt; Ollama
Guard -.-&gt; Hosted
API --&gt; Atlas
Atlas --&gt; Vector
Atlas -.-&gt; Fallback

' dir="auto">

flowchart TD

    subgraph Client["Frontend Client (React + TypeScript + Vite)"]

        UI["Dashboard & Form Interfaces"]

        Editable["Editable Listing Sections"]

        Export["Export Engine (TXT, CSV, JSON)"]

    end

    subgraph Service["Unified Backend (FastAPI + Uvicorn)"]

        Static["Static Vite Asset Server (SPA Fallback)"]

        API["REST API (/api/*)"]

        Router["Health / Listings / Brand / Search"]

        Guard["Factual Anti-Hallucination Guardrails"]

    end

    subgraph AI["Open-Weight Inference Layer"]

        Ollama["Local Ollama Service (gemma3:1b)"]

        Hosted["Hosted Open-Weight Endpoint (vLLM / Groq / Together)"]

    end

subgraph DB["Database &amp; Search (MongoDB Atlas)"]
    Atlas["MongoDB Atlas Cluster (open_list_db)"]
    Vector["Atlas $vectorSearch Index (vector_index)"]</pre>…</div>

View on GitHub

Built with:

🐍 Backend: FastAPI (Python 3.11+) with Pydantic validation
⚛️ Frontend: React, TypeScript, Tailwind CSS, Vite
🍃 Database: MongoDB Atlas with Vector Search ($vectorSearch)
☁️ Deployment: Render Blueprint (render.yaml)

How I Built It 🛠️🧠

Open List is built around open-weight AI so it runs fast and free:

🦙 Google Gemma 3 1B with Ollama:
Runs locally on an ordinary 8 GB RAM laptop. It is fast, lightweight (~800 MB), and costs $0 in cloud API bills. For cloud deployments, it also connects to hosted Gemma 2 9B.
🛡️ Anti-Hallucination Guardrails:
Product details are isolated inside protected tags. The AI is strictly instructed never to invent unverified materials, fake warranties, or medical claims.
🍃 MongoDB Atlas & Vector Search:
Saves your listing history and brand profile. When searching past products, MongoDB Atlas Vector Search calculates cosine similarity across embeddings to surface relevant listings immediately.
🚀 Unified Single-Service on Render:
FastAPI serves both the backend API and the compiled React frontend together as a single service, making deployment on Render simple and zero-maintenance.

Why Does Open Innovation Matter? 🌍💡

Open innovation makes this project possible for real side hustles:

💸 $0 Cost for Solopreneurs: Proprietary AI APIs charge per token. A maker listing hundreds of items would get hit with unpredictable bills. With open-weight Gemma running locally, generation costs nothing.
🔒 100% Privacy: Proprietary scent formulas, secret craft methods, and supplier pricing never leave the creator's computer.
📴 Works Completely Offline: Artisans can draft listings in craft workshops, basements, or outdoor flea markets without an internet connection.
🔓 No Vendor Lock-in: No surprise pricing hikes or discontinued APIs. You own your software and model forever.

My Agent Session 🤖🤝

During the build, I used Antigravity and Gemini-powered pair programming to:

📐 Architect the unified FastAPI + React Vite project.
🛡️ Create strict Pydantic anti-hallucination validation filters.
🍃 Wire up MongoDB Atlas Vector Search and resilient fallback search.
🧪 Write automated tests using pytest to verify health probes and listing generators.

My First User 👩‍🎨🕯️

I tested Open List with a friend who runs a handmade scented soy candle business on Etsy.

The Test:

He previously spent 25 minutes writing each listing. I entered her candle notes: 100% soy wax, cotton wick, lavender scent, 45-hour burn time, and 8 oz glass jar.

The Result:

In 3 seconds, Open List generated:

A clean Etsy title with holiday keywords
5 bullet points with exact burn specifications
13 ready-to-paste Etsy search tags
An Instagram caption with hashtags and a call-to-action

What He Said:

"I dread writing listings on Sunday nights. This did in 5 seconds what takes me half an hour, and it didn't invent fake ingredients! I would gladly pay $10 to $15 a month just for the time this saves me."

His feedback inspired the 1-click title swap and section-by-section rewrite buttons!

Prize Categories 🏆🎯

Entering the following partner categories:

💎 Best Use of Gemma: Built directly around Google's open-weight Gemma 3 1B (via Ollama) and Gemma 2 9B.
🍃 Best Use of MongoDB Atlas: Uses MongoDB Atlas for listing storage and MongoDB Atlas Vector Search ($vectorSearch) for semantic catalog discovery.

Conclusion ✨🎉

Building Open List proved something important: AI doesn't need to replace human craftsmanship. It should remove the boring, repetitive chores so creators can focus on what they actually love doing.

For an independent artist, every hour saved on marketing copy is an extra hour spent making art, pouring candles, or fulfilling orders. By combining Google Gemma, MongoDB Atlas, and Render, solo entrepreneurs can have the marketing power of big brands at zero extra cost.

What's Next? 🔮

📦 1-Click direct publishing to Etsy and Shopify stores
📷 AI image-to-specs extraction from product photos
🌐 Multi-language translations for global buyers

Give it a spin, run it locally, and let me know your thoughts in the comments!

Happy Hacktoberfest and happy hacking! 🎃💻✨

🌿 Touch Grass AI: Offline Outdoor Companion & Open-Source Species Identifier

PRUTHVI RAJ G — Sat, 10 Oct 2026 06:46:10 +0000

🍃 What I Built

Touch Grass AI is an open-source, offline-first outdoor companion designed to help people reconnect with nature while reducing unnecessary screen time.

Whether you're hiking on remote trails without cellular service, identifying plants in your local park, or recording bird calls in your backyard, Touch Grass AI aims to bring nature exploration and AI-powered identification together in one accessible platform.

The goal is simple: use technology to help people spend more time outdoors, not more time on their screens.

👥 Who Is It For?

🥾 Hikers & Trail Runners: Explore outdoor routes, discover nature, and generate GPX routes for offline use.
🌱 Gardeners & Foragers: Identify plant species, maintain species logs, and explore local frost and microclimate information.
🐦 Birdwatchers & Nature Enthusiasts: Analyze audio spectrograms and explore AI-powered bird-call recognition.

⏱️ Designed to Reduce Screen Time

Unlike traditional apps designed to maximize engagement, Touch Grass AI encourages short, purposeful interactions.

Its 15-Minute Outdoor Micro-Quest feature encourages users to complete a nature-based activity, put their phones away, and engage with the environment around them.

The idea is to make technology a companion to outdoor exploration rather than a distraction from it.

🚀 Live Demo

🌐 Live Application:

https://hacktoberfest-week1.onrender.com

🩺 API Health Endpoint:

https://hacktoberfest-week1.onrender.com/api/health

💻 GitHub Repository:

https://github.com/PruthviRajG25/Hacktoberfest-Week1

⚡ Test the API

You can check the deployed backend directly from your terminal using the following command:

curl -X GET https://hacktoberfest-week1.onrender.com/api/health

The expected response is:

{
  "status": "online",
  "appName": "Touch Grass AI",
  "openAIWeights": "Pre-Warmed Ultra-Fast ViT & AST Neural Engine (<15ms)",
  "offlineModeSupported": true,
  "timestamp": "2026-10-10T08:00:00.000Z"
}

Note: This is the expected response format provided for the project. Actual values and service availability may vary.

🏗️ How I Built It

Touch Grass AI combines a web-based outdoor experience with AI-assisted image and audio classification, interactive mapping, and local data storage.

The application is organized into two main parts:

1. Client-side experience

📸 Image capture and plant-species identification.
🎙️ Audio recording and spectrogram-based analysis.
🗺️ Interactive maps and outdoor route exploration.
💾 Local storage for an offline-friendly species journal.

2. Backend inference and APIs

⚡ Express.js REST API.
🩺 API health monitoring.
🌿 Image classification endpoint.
🎵 Audio classification endpoint.

🔄 System Architecture

flowchart TD
    A["👤 Explorer / Hiker"] --> B["📱 Web Client / PWA"]

    subgraph Frontend["Client-Side Features"]
        B --> C["🗺️ Leaflet Route Builder"]
        B --> D["🎙️ Audio Recorder"]
        B --> E["💾 Offline Species Journal"]
    end

    subgraph Backend["Express.js Backend"]
        B -->|REST API| F["⚡ Express Server"]
        F --> G["🟢 GET /api/health"]
        F --> H["📸 POST /api/classify-image"]
        F --> I["🎵 POST /api/classify-audio"]
        H --> J["🌿 Vision Classification"]
        I --> K["🐦 Audio Classification"]
    end

🛠️ Technology Stack & AI Models

🌿 Vision Identification

Vision Transformer (ViT) and MobileNetV3 are the proposed vision models for classifying plant-related images, including leaves and trees.

The objective is to make species identification accessible without depending entirely on proprietary cloud AI services.

🐦 Audio Identification

The Audio Spectrogram Transformer (AST) is used in the planned audio-classification pipeline for analyzing recorded sounds and supporting bird-call recognition.

🗺️ Interactive Maps

Leaflet.js: Interactive map rendering and outdoor route visualization.
OpenStreetMap: Open map data for exploring outdoor locations.
GPX export: Designed to support saving routes for use with compatible navigation applications.

⚙️ Backend & Deployment

Node.js: JavaScript runtime for the backend.
Express.js: REST API and backend routing.
Render: Application hosting and deployment.
Local storage and offline-friendly web capabilities: Intended to keep supported journal data accessible without a continuous internet connection.

🌐 Why Does Open Innovation Matter?

For outdoor applications, open innovation can make a meaningful difference in accessibility, privacy, and reliability.

1. 📶 Reliability Beyond Connectivity

Remote trails and forests often have limited network coverage. Local inference and offline-capable features can help users continue supported activities even when connectivity disappears.

2. 🔒 Privacy by Design

Processing supported photos, recordings, and location data locally can reduce the need to upload sensitive information to third-party services.

The long-term goal is to give users more control over their outdoor data and nature observations.

3. 💸 Lower Dependence on Paid APIs

Open-weight models can reduce reliance on metered AI services and recurring per-request charges. This creates opportunities to build accessible tools without making every identification dependent on a paid cloud API.

4. 🌍 Community-Driven Development

Open-source development allows contributors to improve classification, expand species coverage, refine offline support, and build features that benefit nature enthusiasts everywhere.

🤖 My AI Agent Development Workflow

AI-assisted development workflows supported the project's implementation, testing, and deployment process.

DevRelay CLI integration: The development session was logged and managed through DevRelay CLI tools.

The project also provides an opportunity to explore how AI-assisted engineering workflows can help developers prototype and iterate on practical, open-source applications.

🏆 Hacktoberfest Challenge Categories

🌿 Main Challenge: Hacktoberfest Week 1 — Touch Grass
🤖 Partner Category: Open-Weight AI
📱 Partner Category: Local / Offline Inference

🌱 What's Next?

Touch Grass AI is built around a simple idea: technology should help us discover more of the world beyond our screens.

Future improvements can focus on expanding species coverage, improving model performance, strengthening offline functionality, and making outdoor exploration more accessible.

If you're interested in open-source AI, nature exploration, offline-first applications, or contributing to projects that encourage healthier technology habits, check out the repository.

🔗 Explore the code: https://github.com/PruthviRajG25/Hacktoberfest-Week1

🚀Try the application: https://hacktoberfest-week1.onrender.com

🌿 Get outside, explore your surroundings, and go touch grass!