DEV Community: Archita Sharma

# Anima Memory Vault: Keeping Family Stories Alive with a Local Spirit Guardian

Archita Sharma — Sun, 01 Nov 2026 06:31:01 +0000

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

What I Built

Anima Memory Vault is a Día de los Muertos-inspired family memory application that preserves oral history through an interactive digital ofrenda.

Users can:

Add memories, recipes, traditions, and family stories.
Store them in MongoDB Atlas.
Ask questions about their family history.
Retrieve relevant memories using vector search.
Receive answers from a warm ancestor-spirit persona.
Listen to responses through ElevenLabs narration or the browser's local speech synthesis.

I interpreted “Ghost in the Machine” as a gentle presence of memory: not a frightening ghost, but a spirit guardian that helps keep family voices, traditions, and stories alive.

Demo

Code

Check Github Code

How I Built It

The application uses:

React with Vite for the frontend.
Node.js and Express for the backend.
MongoDB Atlas Vector Search for memory retrieval.
Ollama for local AI inference.
gemma2:2b for generating ancestor-spirit responses.
nomic-embed-text for converting memories and questions into embeddings.
ElevenLabs for optional voice narration.
The browser Web Speech API as an offline narration fallback.

The RAG flow works like this:

Family memory
    ↓
nomic-embed-text creates an embedding
    ↓
Embedding is stored in MongoDB Atlas
    ↓
User asks a question
    ↓
The question is embedded
    ↓
MongoDB Vector Search retrieves related memories
    ↓
Retrieved memories are provided to gemma2:2b
    ↓
The spirit guardian generates a grounded answer

The application also supports a local in-memory fallback when MongoDB is not configured, allowing the project to run completely locally during development.

One important design decision was to instruct the model not to invent family history:

If the retrieved memories do not contain the answer, the spirit guardian should say so gently instead of creating facts.

This keeps the responses respectful and grounded in the memories that users actually provided.

Why Does Open Innovation Matter?

Open innovation made it possible to build a private, meaningful memory experience using local models instead of sending family stories to a closed AI service by default.

Using Ollama means the core generation and embedding workflow can run locally:

Family memories can remain on the user's machine during development.
The project can work without a paid AI API.
Developers can experiment with different open-weight models.
The retrieval and generation pipeline is transparent and customizable.
The application can fall back gracefully when cloud services are unavailable.
MongoDB Atlas adds persistent vector search, while the local Ollama models provide the intelligence behind the experience.

ElevenLabs is an optional enhancement for more natural narration. If it is unavailable, the application falls back to the browser's native speech synthesis.

The Spirit of It

The most meaningful part of the project is that the “ghost” is not treated as something scary.

The spirit guardian represents the way family memories continue to speak through recipes, songs, sayings, places, and small traditions. A question such as:
What did Abuela Rosa prepare every November?

can bring a stored memory back into the conversation and make the family story feel present again.

Anima Memory Vault is designed to feel like lighting a candle: a small act of remembrance that keeps someone’s story from disappearing.

LocalList AI: A Local AI Listing Generator for Small Sellers

Archita Sharma — Sat, 17 Oct 2026 05:59:42 +0000

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

What I Built

LocalList AI is a simple, AI-powered product listing generator designed for small online sellers, thrift stores, Instagram businesses, and people who sell products through social media.

Creating an attractive product listing takes time. Sellers need to write a catchy title, describe the product clearly, and find relevant hashtags to reach potential customers. For someone managing dozens of products, doing this manually can become repetitive and exhausting.

LocalList AI makes this process easier. Sellers enter basic product information, such as the product name, price, condition, and additional details. The application uses AI to generate a product title, description, and five relevant hashtags that sellers can review, edit, and copy for their listings.

The goal is to help small sellers spend less time writing listings and more time running their businesses.

Who would pay for it?

Independent sellers, thrift stores, resellers, and small businesses that regularly list products online could benefit from a tool like this. A future version could offer additional features for frequent sellers, bulk listing generation, and platform-specific descriptions.

Demo

Here's a short video demonstrating LocalList AI in action, from entering product details to generating an AI-powered product title, description, and hashtags.

Code

View code on Github

The project is built as a lightweight web application, with a frontend for entering product information and viewing generated listings, and a backend that communicates with a locally running Ollama model.

How I Built It

I built LocalList AI using a lightweight web stack and open-source AI.

Frontend: HTML, CSS, and JavaScript for the user interface and interactions.

Backend: Node.js and Express to handle requests and communicate with the AI model.

AI runtime: Ollama for running the model locally.

AI model: gemma4:e4b, used to generate product titles, descriptions, and hashtags.

Development: GitHub Copilot helped me accelerate the implementation of the application.

The workflow is straightforward:

The seller enters the product details.

The frontend sends the information to the backend.

The backend sends a prompt to the locally running Gemma model through Ollama's API.

The model generates the listing content.

The application displays the result for the seller to review and copy.

One of my priorities was to keep the project simple and avoid depending on a paid, hosted AI API for every generation request.

Running inference locally also means that product details can remain on the user's machine during normal local use, rather than needing to be sent to an external AI provider. This depends on how the application is deployed and configured.

Why Does Open Innovation Matter?

Open innovation made this project possible without requiring me to build an AI model from scratch or pay for a hosted model API.

Using an open-weight model with Ollama gave me a practical way to experiment with AI-powered product generation on my own computer. It allowed me to connect an AI model to a real application, test its outputs, and build around it without making a paid API the foundation of the project.

It also makes the project more accessible to developers and small-business owners who want to experiment with AI while keeping recurring infrastructure costs low.

For small sellers, accessibility matters. A useful AI tool should not require an expensive subscription just to perform a repetitive task.

LocalList AI is my small example of how open AI tools can turn a simple idea into a practical application that people could use in their everyday work.

Prize Categories

Best Use of Gemma — LocalList AI uses Google's Gemma open-weight model through Ollama to generate product listings locally.

Best Use of GitHub Copilot — I used GitHub Copilot Agent Mode to help implement and develop the application.

Nature Bingo — Touch Grass 🌿

Archita Sharma — Sun, 11 Oct 2026 16:20:56 +0000

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

What I Built

What if a bingo game could give you a reason to put your phone down and notice the world around you?

That’s the idea behind Nature Bingo — Touch Grass, a 45-minute outdoor exploration game designed to make spending time in nature more engaging, mindful, and interactive.

The app presents a 5×5 bingo board containing 25 nature-observation challenges across five categories: Flora, Fauna, Senses, Earth, and Sky. Instead of completing ordinary tasks on a screen, players are encouraged to step outside, observe their surroundings, and record what they discover.

Challenges include identifying a leaf edge, observing an insect at work, listening to birdsong, noticing contrasting natural textures, and watching cloud formations. Depending on the challenge, players can record evidence using photos, audio, GPS, timed observation, or an honour-based completion option.

The goal is simple: complete five challenges in a horizontal, vertical, or diagonal line to win.

I also wanted the experience to feel like an outdoor exploration journal rather than another generic productivity app. The botanical visual style, earthy colours, and nature-inspired details are designed to make the experience inviting while keeping the focus on real-world exploration.

The principle behind it: use technology to encourage people to spend more time experiencing the world beyond their screens.

Demo

🌿 Try the live application:

Try Nature Bingo

🎥 Watch the project walkthrough:

The video demonstrates the application, its bingo board, and the features shown in the walkthrough.

Screenshots

Nature Bingo Landing Page

Nature Bingo Game Play

Nature Bingo Evidence Collection

Nature Bingo Session Completion

Me collecting evidence!!

And confirming completion!!

Code

💻 GitHub repository:

View the source code on GitHub

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

How I Built It

I built Nature Bingo using a React and Vite frontend with a Node.js and Express backend.

The frontend handles the bingo board and player interactions, while the backend provides API endpoints for challenge delivery and related functionality. The application also includes challenge evidence options and logic for tracking completed cells and identifying bingo lines.

Tech stack

Frontend: React, Vite, CSS
Backend: Node.js, Express
AI experimentation: Gemma 4 (open-weight model) through Ollama
Deployment: Vercel for the frontend and Render for the backend

Exploring open-weight AI

One of the learning goals for this project was to explore how open-weight AI models could fit into a practical application.

I experimented with running Gemma locally through Ollama and explored using the model to generate nature-based challenges. This introduced me to the practical side of local inference, including model availability, hardware constraints, response time, and integration with an application backend.

The deployed application uses curated fallback challenges when the local model is unavailable on the hosting server. This keeps the core game playable without depending on a running local model in production.

This distinction was important to me: experimenting with AI is valuable, but the application should still provide a usable experience when the model is unavailable.

Why Does Open Innovation Matter?

For me, this project was an opportunity to move beyond simply calling a hosted AI API and explore what working with an open-weight model actually involves.

Open innovation makes it possible to experiment with models such as Gemma, explore local inference through tools such as Ollama, and learn how AI systems can be integrated into applications without relying exclusively on a closed, hosted model.

It also exposes the engineering trade-offs that can be easy to overlook when using an API: hardware requirements, inference latency, deployment constraints, and reliable fallback behaviour.

Nature Bingo taught me that incorporating AI is not just about generating an impressive response. It is about deciding where AI adds value, understanding its limitations, and designing the surrounding system so that the experience remains useful.

The project is still an exploration, but that is part of what made building it worthwhile: learning by experimenting, testing, and making the application work under real constraints.

Ultimately, I wanted to build something that connects technology with an offline experience—and use open-source tools to learn along the way.

Prize Categories

I’m submitting Nature Bingo for the Best Use of Gemma category, based on my experiments with the open-weight Gemma model through Ollama to explore nature-challenge generation.

The deployed version currently uses curated fallback challenges when the local model is unavailable in production.

Thanks for checking out Nature Bingo! 🌱

devchallenge #hf26challenge

General

Archita Sharma — Tue, 06 Oct 2026 08:08:24 +0000

I am new to the community. Happy to be a part of Hacktoberfest