DEV Community: chirag kumar chouhan

Ofrenda — A Local Memory Archive | Hacktoberfest Week 4

chirag kumar chouhan — Tue, 27 Oct 2026 10:24:53 +0000

What if AI could bring memories back to life — without sending them to the cloud?

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

What I Built

Ofrenda is a privacy-focused, local AI memory archive that transforms personal memories into meaningful digital keepsakes.

We all have little things we never want to forget: a grandparent's favorite song, a childhood story, a familiar place, or a moment that still makes us smile. But over time, these details can fade.

I wanted to explore a different use of AI — not just to improve productivity, but to help preserve the stories that make life meaningful.

Ofrenda brings that idea to life through:

Create Remembrances: Transform personal stories into meaningful remembrances, quotes, key details, and themes.

Ghost Mode: Reimagine a memory as a fictional, supernatural-style story inspired by the original.

Personal Archive: Save, search, revisit, and delete stored memories.

Privacy-Focused Experience: Keep saved memories in browser storage while running AI generation locally.

JSON Export: Export archived memories for personal backup or further use.

I interpreted Ghost in the Machine as the presence of stories and memories within a digital experience — something that makes technology feel a little more human.

Demo

Watch the project demo:

https://youtu.be/pvAgikN2AIo

The video walks through Ofrenda's interface and demonstrates how memories can become remembrances, how Ghost Mode reimagines them, and how users can save their stories in a personal archive.

Code

GitHub Repository:

https://github.com/ChiragKumarChouhan/Ofrenda-

The project is open source, and the repository contains the implementation for the application.

How I Built It

Ofrenda combines a modern web interface with locally running open-source AI.

Technology stac

React + Vite — frontend and responsive user interface.

Node.js + Express — backend API.

Ollama — runs the AI model locally.

Gemma 3 (gemma3:1b) — generates memory-based content.

Browser localStorage — saves the user's archive locally.

JSON — supports exporting saved memories.

When someone enters a memory, the frontend sends it to the Express backend. The backend communicates with the locally running Ollama model, which generates structured content for the application.

Ghost Mode uses the local AI setup to create a fictional, supernatural-style interpretation inspired by the original memory.

I also worked on validating AI responses and adding retry handling to improve reliability.

My aim was to build more than a visual prototype. Ofrenda brings together the interface, backend, local model integration, memory archive, and export functionality into one experience.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with AI on my own terms.

By using Ollama and Gemma 3, I could run inference locally, integrate an open-weight model into my application, and explore an architecture that does not depend on a proprietary cloud AI API for generation.

Open tools give developers the freedom to experiment, customize model interactions, understand how different components fit together, and build applications that reflect their own ideas.

That freedom matters especially for a project involving personal memories. Local inference offers an alternative to sending stories to an external AI service, while browser-based storage keeps the saved archive on the user's device.

Of course, local AI is only one part of privacy: how data is handled, transmitted, and stored still matters. That is why I wanted privacy to be a core design consideration rather than an afterthought.

Open innovation is about more than using a model. It is about having the freedom to build something meaningful with it.

My Agent Session

I used AI-assisted development while building and debugging Ofrenda.

DevRelay agent session: Add your saved session link here, if available.

This section is optional. If you haven't saved a session, you can remove it.

The Spirit of It

The heart of Ofrenda is a simple question:

What if the smallest details we remember about someone could become stories we revisit?

Imagine entering a favorite song, a familiar place, or a small story someone used to tell. Ofrenda turns those details into a remembrance, while Ghost Mode explores a more mysterious, fictional interpretation of the memory.

The goal isn't to recreate a person or replace the act of remembering. It is to use AI as a creative tool for preserving and reimagining the stories that matter to us.

I wanted to build something different from the usual productivity-focused AI application: something personal, creative, and human.

Because sometimes, the smallest memories leave the biggest shadows.

Prize Categories

I'll select the categories that match the project's actual implementation and the challenge's official eligibility rules.

I will only list partner categories for tools or technologies that genuinely apply to Ofrenda.

Built with open-source tools, local AI, and a little ghostly inspiration.

Ofrenda — Keep the little things from disappearing.

Hacktoberfest #OpenSourceAI #Ollama #Gemma #React #OpenSource

SlothBrief: Less Reading, More Doing with Local AI

chirag kumar chouhan — Thu, 22 Oct 2026 17:04:20 +0000

What I Built

Meet SlothBrief, a local-first AI note summarizer that turns lengthy notes into concise summaries, key points, and actionable tasks.

We all collect notes, meeting details, study material, and long blocks of text. The difficult part is often not writing them down — it is finding the important information and deciding what to do next.

SlothBrief aims to make that process simpler.

With SlothBrief, you can:

Turn lengthy notes into concise summaries.

Extract important points and actionable tasks.

Mark action items as completed.

Copy or download summaries for later use.

Save and revisit previous briefs through local browser history.

Switch between light and dark themes.

The idea is simple: spend less time processing information and more time acting on it.

Demo

Watch SlothBrief in action: https://youtu.be/5DubSUPCUNc

The demo walks through the summarization workflow, generated results, action items, and brief history.

Code

GitHub repository: https://github.com/ChiragKumarChouhan/SlothBrief

The project is built with a React frontend and an Express backend, with Ollama providing local access to the AI model.

Contributions, feedback, and suggestions for improvement are welcome.

How I Built It

I built SlothBrief using an open-source-oriented stack:

React + Vite for the interactive user interface.

Node.js + Express for the backend API.

Ollama to run AI inference locally.

Gemma (gemma3:1b) as the language model.

The workflow is straightforward:

The user enters notes or provides a supported text file.

The frontend sends the content to the Express backend.

The backend communicates with the locally running Ollama model.

Gemma generates a structured summary and actionable items.

The interface displays the result and allows the user to interact with it.

Successful summaries can be saved in the browser's local history for future reference.

One of my priorities was making the application feel like a practical productivity tool rather than just a prompt box connected to an AI model.

I focused on a clean interface, useful actions, readable results, and a simple workflow.

Why Does Open Innovation Matter?

Open innovation made it possible to build an AI-powered productivity tool around a model that can run locally.

Using Ollama with Gemma gives **SlothBrief **an alternative to relying entirely on a hosted, closed AI API. It also gives developers more control over their inference environment and makes experimentation with models more accessible.

This approach has practical advantages:

More control: AI inference can run on the user's own machine.

Privacy-conscious design: Note content can be processed locally instead of being sent to a third-party AI inference service, provided the application is configured to use only the local endpoint.

Accessibility: Developers can experiment with AI without needing a paid hosted-model API.

Flexibility: The model and prompts can be adjusted as the project evolves.

Local inference does not automatically make every part of an application private. **SlothBrief **still depends on how its backend, browser storage, and any external services are configured. The goal is to keep the AI workflow local and minimize unnecessary data sharing.

For me, open innovation is about making useful technology easier to experiment with, understand, and improve.

The Lazy Payoff

SlothBrief is designed to reduce the effort involved in turning unstructured notes into something actionable.

Instead of manually rewriting long notes, users can generate a summary, review the key points, and work through the action items in one place.

I have focused on building the workflow and its supporting features first. I have not yet measured time savings through a formal user test, so I won't claim a specific number of minutes saved.

The next step is to test it with real notes and compare the time required to process them manually against the SlothBrief workflow.

Prize Categories

Select the partner categories that the project actually qualifies for according to the official challenge rules.

Open-Source AI / local inference, if eligible under the challenge's listed categories.

Final Thoughts

Building SlothBrief has been an opportunity to explore how open AI models can power a focused, useful application without making the experience unnecessarily complicated.

The goal isn't to add AI to everything. It's to use AI where it removes friction from a real task.

SlothBrief — less reading, more doing.

Thanks for checking out my project. Feedback and contributions are welcome.

MarginMitra: An Open-Source AI Profit Copilot for Small Online Sellers

chirag kumar chouhan — Sat, 17 Oct 2026 11:05:30 +0000

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

What I Built

I built MarginMitra, an AI-powered profit copilot designed to help small online sellers understand their profitability and make better business decisions.

Many sellers focus on revenue but overlook product costs and profit margins. MarginMitra helps them analyze product performance, identify low-margin products, and prioritize actions to improve profitability.

Key features include:

Profit Analytics: Track revenue, estimated costs, profit, and product margins.

Smart Recommendations: Prioritize products that need pricing or cost reviews.
AI Business Chat: Ask business questions and get insights based on available business data.
CSV Import: Analyze sales data using uploaded CSV files.
Listing Generator: Generate product listing content for online selling.

The goal is to give small sellers access to practical business intelligence without requiring expensive analytics tools.

Demo

Video Demo: https://youtu.be/uWpVqRjvt1Y

The demo showcases the dashboard, product profitability analysis, prioritized recommendations, AI business chat, and listing generator.

Code

GitHub Repository: https://github.com/ChiragKumarChouhan/marginmitra

The project is built with a React and Vite frontend, a Node.js and Express backend, and an AI integration using a locally running Ollama model.

How I Built It

I built MarginMitra using open-source technologies and a local AI workflow.

Tech stack:
Frontend: React, Vite, JavaScript, and Tailwind CSS
Backend: Node.js and Express
AI: Ollama with the Gemma 3 1B model
Data analysis: JavaScript-based calculations for revenue, costs, profit, and margins
Data input: CSV import for sales data

The application calculates product-level metrics and uses them to generate prioritized recommendations. The AI business chat receives business context so it can answer questions relevant to the available data.

Running the model locally also lets me experiment with AI features without depending entirely on a paid, hosted AI API.

Why Does Open Innovation Matter?

Open innovation made it possible to build and experiment with AI features using accessible tools and open-weight models.

Using Ollama and Gemma allowed me to explore local inference, keep the AI workflow under my control, and reduce dependence on paid API services. It also gave me the opportunity to learn how an AI model can work alongside deterministic business calculations rather than replacing them.

For a project aimed at small sellers, accessible technology matters. The goal is to make useful business insights more affordable and easier to experiment with.

My Agent Session

Optional: I will add my agent session here if available.

Prize Categories

Open-Source AI
Side Hustle

TouchGrass AI: An AI-Powered Outdoor Mission Planner Using Gemma 3 1B

chirag kumar chouhan — Fri, 09 Oct 2026 10:25:32 +0000

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

What I Built

I built TouchGrass AI, a web application that encourages people to take a break from their screens and spend more time outdoors.

The idea behind the project is simple: sometimes, we want to go outside but don't know what to do or where to start. TouchGrass AI helps solve this by generating personalized outdoor missions based on a user's preferences, available time, and difficulty level.

Users can generate a mission, follow its steps, mark tasks as completed, and track their progress.

I built this project to combine AI with a practical idea that encourages people to spend more time away from their screens.

Demo

Here is a short video demonstration of TouchGrass AI.

Demo Video: https://youtu.be/ALmuc2VEnUU

The video shows the application and how it generates outdoor missions.

Code

GitHub Repository: https://github.com/ChiragKumarChouhan/touchgrass-ai

The repository contains the frontend, backend, and setup instructions for running the project locally.

How I Built It

I built TouchGrass AI using React for the frontend and Node.js with Express for the backend.

For the AI functionality, I used Gemma 3 1B, an open-weight language model, running locally through Ollama.

The application sends requests from the frontend to the Express backend, which communicates with the local Ollama API to generate outdoor missions. The generated results are then displayed in the interface.

The main technologies I used are:

React and Vite: Frontend development

Node.js and Express: Backend API

Gemma 3 1B: AI-powered mission generation

Ollama: Running the language model locally

Browser localStorage: Saving progress locally

Working on this project helped me understand how a local language model can be integrated into a full-stack web application.

Why Does Open Innovation Matter?

Open innovation matters because it gives developers the opportunity to experiment, learn, and build useful applications without depending entirely on closed AI APIs.

Using an open-weight model through Ollama allowed me to explore local AI inference and understand how a language model can become part of a real application.

It also gave me more control over the development environment and helped me learn about the connection between AI models, backend APIs, and frontend interfaces.

For me, this challenge is an opportunity to learn by building something practical and share it with the open-source community.

My Agent Session

I don't have a DevRelay agent session to share for this submission, so I'm leaving this section out.

Prize Categories

I'll update this section based on the eligible partner prize categories listed on the official challenge page.

Final Thoughts

TouchGrass AI started with a simple idea: use AI to help people spend a little less time in front of a screen and a little more time outdoors.

Building it has been a learning experience in full-stack development and local AI integration. I'm looking forward to improving the project and learning from the open-source community.

Thanks for checking out my submission!

My Development as a Developer: DSA and Full Stack Web Development

chirag kumar chouhan — Fri, 09 Oct 2026 08:10:02 +0000

Right now, I am trying to get better as a developer.

Here are some of the things that I am currently doing:

C++ and DSA - Problem solving with LeetCode to develop logic.

Frontend Development – Learning React.js, JavaScript and Tailwind CSS.

Backend Development – Trying out Node.js, Express.js, and PostgreSQL.

Projects - Building projects using these frameworks in order to apply my learnings to build practical web apps.

It is a work in progress and consistency always beats perfection in any task. The aim here is to polish up my fundamentals while building some cool projects.

Keep reading for more details regarding my journey so far.