DEV Community: Debosman Dasgupta

👻 GhostVault: The Haunted Digital Memory Keeper — Some Memories Deserve to Live Forever

Debosman Dasgupta — Fri, 30 Oct 2026 15:03:22 +0000

What I Built

What if an AI could help us preserve the memories we fear losing, without asking us to hand those memories over to someone else?

That's the question behind GhostVault, an AI-powered digital memory archive that I'm planning to build using open-weight AI models and local inference.

The idea came from the themes of Halloween and Día de los Muertos. Halloween makes us think about ghosts, forgotten places, and things that linger long after they've disappeared. Día de los Muertos reminds us that photographs, stories, traditions, and memories can keep the people we love close to us.

I wanted to bring these two ideas together into something that is both a little spooky and genuinely meaningful.

Meet GhostVault: a haunted digital archive where forgotten photographs, old letters, personal stories, and cherished memories come back to life through an AI companion called The Ghost. 👻

But there's a twist.

The Ghost won't simply be another chatbot that generates random spooky stories. It will be able to search a user's personal archive, retrieve relevant memories, and weave them into interactive narratives.

Imagine uploading an old photograph of your childhood home and adding a note about the summers you spent there.

A few days later, you ask:

Ghost, what do you remember about my childhood home?

Instead of returning a generic answer, GhostVault will retrieve your saved memories and use them to create a personalized response.

It might say:

"Ah, the old house... You told me about the summers you spent there, the familiar rooms, and the moments that seemed ordinary at the time. Funny how the smallest details become the memories we treasure most. Shall we uncover another fragment of that story?"

The response will be generated from the information you actually saved, rather than pretending the AI has supernatural knowledge or memories of its own.

The goal is to create an experience that feels like exploring a forgotten archive with an intelligent, mysterious companion.

🕯️ The Features I Plan to Build

1. The Ghost — An AI Memory Companion

This will be the heart of GhostVault.

Users will be able to interact with their personal archives using natural language.

For example:

"Tell me a story about my childhood."
"What memories have I saved about my grandfather?"
"Find the happiest memory I've shared."
"What do my photographs tell me about my college days?"
"Help me turn this old photograph into a mysterious story."

I'll use a retrieval-augmented generation (RAG) pipeline so that The Ghost can search saved memories and use the relevant information when generating responses.

The idea is to make the AI feel personal without allowing it to invent facts about someone's life.

2. The Haunted Photo Archive 📸

A photograph can hold an entire story, even when its original context has been forgotten.

GhostVault will allow users to upload photographs and attach descriptions, dates, locations, and personal notes.

Users will be able to browse their collection and search for memories using natural language.

For example, searching for "the family gathering during Durga Puja" should retrieve relevant photographs and stories if that information exists in the archive.

I'll begin with manually entered descriptions and metadata. Later, I plan to experiment with open-weight vision-language models to help describe photographs and connect them with existing memories.

The photographs and associated information will be stored locally in the privacy-focused version of the application.

3. The Memory Séance 🕯️

This is where the Halloween side of the project comes alive.

Users will be able to select a photograph, letter, or saved memory and ask The Ghost to turn it into a story.

I'll introduce different storytelling modes:

👻 Haunted Mode: Transform a memory into an eerie, atmospheric narrative.

🌼 Remembrance Mode: Create a warm, reflective story celebrating a cherished memory or loved one.

📜 Historical Mode: Construct a narrative grounded in the available facts, clearly identifying missing information.

🌑 Fiction Mode: Create a supernatural fictional story inspired by the user's archive.

For example, a photograph of an abandoned house accompanied by the note "My grandfather grew up here" could inspire a mysterious story about the house and the generations that once lived in it.

The application will distinguish fictional storytelling from factual recollections, so users can enjoy the atmosphere without confusing invented details with real memories.

4. Forgotten Fragments 🔍

Sometimes, we save something with the intention of returning to it later, only to forget about it entirely.

This feature will help users rediscover unfinished stories and incomplete memories.

GhostVault will identify photographs without descriptions, stories that need additional context, and recurring people or places across saved memories.

It might ask:

"You saved three photographs from your first college trip, but none has a description. Do you remember where these were taken?"

Instead of merely storing information, GhostVault will help users gradually build a richer personal archive.

5. The Digital Ofrenda 🌼

Inspired by Día de los Muertos, this feature will allow users to create a digital remembrance space for someone important to them.

An ofrenda is a place for honoring and remembering loved ones. I want to bring that spirit into a digital experience without reducing it to a spooky gimmick.

Users will be able to add photographs, personal anecdotes, favorite foods, songs, important dates, and letters.

The AI will help organize these materials into a remembrance narrative that celebrates the person's life and preserves the stories associated with them.

Users will remain in control of what they save, edit, share, or delete.

The result will be a personal digital memorial that can help preserve stories for future generations.

Demo

I'll initially focus on building a working local version of GhostVault.

The demonstration will showcase:

Creating a personal memory and adding a photograph.
Asking The Ghost a question about saved information.
Retrieving relevant memories using semantic search.
Generating a spooky story inspired by an archived photograph.
Switching between Haunted and Remembrance modes.
Creating a digital ofrenda.
Demonstrating that the core AI workflow can function without an internet connection after the required models and dependencies have been installed.

Demo link: I'll add the deployed application or demonstration video here once it's available.

The initial version will use sample memories so that anyone can explore the application without uploading personal photographs or private stories.

For deployment, I plan to explore a public web demo alongside a local version. The local version will be the primary demonstration of privacy and offline inference; the hosted demo will use fictional sample data rather than promising that a public server offers the same privacy guarantees.

Code

I'll publish the source code on GitHub so that developers can explore the implementation, run the application locally, and contribute improvements.

GitHub repository: I'll add the repository link here once it's created.

The repository will include the frontend, backend, AI integration, local storage implementation, setup instructions, and sample data for testing.

I'm also planning to document how to configure the local model, initialize the memory database, and run GhostVault on a personal computer.

My goal is to make the project approachable for developers who want to experiment with open-weight AI without needing a paid AI API.

How I Built It

The central design decision behind GhostVault is that the AI should be able to work with personal memories without requiring those memories to leave the user's computer.

Rather than making a hosted AI API the foundation of the application, I'll build the core workflow around local inference and open-source components.

The Technology Stack

Here's the stack I'm planning to use:

Component	Technology	Purpose
Frontend	React + Vite	Build the interactive archive and chat interface
Styling	Tailwind CSS	Create the dark, atmospheric visual experience
Backend	Python + FastAPI	Handle memory management, retrieval, and AI requests
Local AI runtime	Ollama	Run compatible open-weight language models
Language model	A suitable instruction-tuned open-weight model	Power The Ghost's conversations and storytelling
Embeddings	Sentence Transformers	Convert memories into numerical representations for semantic search
Vector database	ChromaDB	Retrieve memories relevant to a user's question
Metadata database	SQLite	Store memory descriptions, dates, tags, and archive metadata
File storage	Local filesystem	Store photographs and other uploaded files

I'll choose the language model based on its quality, hardware requirements, license, and performance on my machine.

The first version will prioritize a reliable local text-based memory assistant. Vision-language models and additional features can be integrated once the core workflow works well.

How The Ghost Will Work

The main AI workflow will follow a retrieval-augmented generation architecture.

Here's the planned pipeline:

Step 1: Save a memory

A user uploads a photograph and adds a description.

For example:

"My family celebrated Durga Puja at my grandmother's house every year when I was a child."

GhostVault stores the photograph locally and saves its description and associated metadata in the database.

Step 2: Create an embedding

The application uses a local embedding model to convert the memory description into a numerical representation.

This representation captures semantic information, allowing the system to find related memories even when a user's query doesn't contain exactly the same words.

Step 3: Ask The Ghost a question

The user asks:

"Where did my family celebrate Durga Puja when I was younger?"

Step 4: Retrieve relevant memories

The backend searches the stored embeddings and retrieves relevant descriptions.

The Ghost receives the question along with the matching records.

Step 5: Generate a response

Ollama passes the relevant context to the selected local language model, which generates a natural-language response.

The model will be instructed to prioritize retrieved information, distinguish known facts from fictional details, and admit when the archive doesn't contain enough information to answer a question.

Step 6: Preserve the result

The user can save the generated story alongside the original memory, creating a growing archive of personal narratives.

The complete process can run locally, without a mandatory external AI API.

A Simplified Architecture

The application will follow this structure:

                 GHOSTVAULT
                     |
             React + Tailwind
                     |
                FastAPI
                     |
         +-----------+-----------+
         |           |           |
     Memory       Story       Archive
     Retrieval    Engine      Manager
         |           |           |
      ChromaDB    Ollama      SQLite
         |           |
   Local Embeddings  |
         |           |
         +-----+-----+
               |
      Open-Weight LLM
               |
       Generated Response

The architecture will separate the user interface, memory retrieval, AI generation, and storage layers.

This will make it easier to replace the language model, change the embedding model, or experiment with alternative retrieval strategies without rewriting the entire application.

Building the Haunted Experience

I also want GhostVault to feel like an interactive digital archive rather than a conventional productivity application.

The interface will use a dark, gothic-inspired design with aged-paper textures, muted colors, candlelight-inspired accents, and subtle animations.

The landing page will introduce the experience with a simple message:

"Every memory leaves a trace."

The main dashboard will have three central areas:

The Archive: Browse photographs, letters, and personal stories.
The Ghost: Ask questions and generate personalized narratives.
The Ofrenda: Build a digital remembrance space.

I'll keep the animations lightweight and make sure that the interface remains functional even on modest hardware.

The AI model will run independently of the visual effects, so users won't need a powerful GPU simply to navigate the archive.

Development Roadmap

I'll approach the project incrementally.

Phase 1 — Bring The Ghost to Life

Set up the React frontend and FastAPI backend.
Integrate Ollama with a compatible open-weight language model.
Create the Ghost persona and conversation interface.
Implement basic local conversation handling.

Phase 2 — Give The Ghost a Memory

Implement memory creation and retrieval.
Add local embedding generation.
Integrate ChromaDB and SQLite.
Build the RAG pipeline.
Test whether responses are grounded in retrieved memories.

Phase 3 — Build the Haunted Archive

Implement photograph uploads and metadata management.
Create the haunted storytelling interface.
Add Haunted, Remembrance, Historical, and Fiction modes.
Allow users to save generated stories.

Phase 4 — Preserve the Past

Implement the digital ofrenda.
Add tools for organizing and completing forgotten fragments.
Improve the interface and accessibility.
Test the core workflow with the internet disconnected.
Document installation and local deployment.

The priority will be to deliver a working core application before experimenting with more advanced AI features.

Why Does Open Innovation Matter?

For GhostVault, open innovation isn't simply a way to avoid paying for API calls.

It's a fundamental part of the product's philosophy.

I'm building an application around photographs, personal stories, family traditions, and memories of people who may no longer be with us.

These aren't ordinary pieces of data.

They can be deeply personal, and users should have meaningful control over where that information goes.

That's why I want the default experience to run locally.

1. Privacy Should Be a Design Decision

A conventional implementation built around a hosted AI API could send personal memories to an external service for processing.

GhostVault will instead use a local model for its core AI workflow.

Photographs, saved stories, embeddings, and generated narratives can remain on the user's machine when the application is configured for local operation.

This doesn't automatically make every deployment private. The application will still need to avoid unnecessary external requests, handle local files securely, and document its storage behavior.

But the architecture gives us the ability to build privacy into the product instead of treating it as an afterthought.

2. A Personal Archive Shouldn't Depend on a Single Provider

Imagine spending years collecting photographs, writing family stories, and organizing personal memories in an application.

Now imagine losing access because a company changes its pricing, discontinues its service, or removes a feature.

I want GhostVault to avoid making its core functionality dependent on a single hosted AI provider.

By separating the model runtime from the application logic, I'll be able to experiment with compatible models and maintain the archive independently of the AI engine.

The database and original photographs will remain separate from generated responses, making the underlying memories easier to preserve even if the language model changes.

The archive belongs to the user. The AI is a tool that helps them explore it.

3. Offline AI Makes the Experience More Resilient

Once the necessary models and dependencies are installed, GhostVault's core local workflow should be usable without an internet connection.

Users will be able to browse their archives, retrieve memories, and generate stories without depending on a remote inference endpoint.

This is particularly important for a personal archive: its basic functionality shouldn't disappear just because an external service is unavailable.

The main limitations will be the computer's available memory, processing power, and storage.

4. Experimentation Without a Closed AI API

Using an open-weight model will give me more flexibility to experiment with the application's behavior.

I want to compare models on their ability to:

Retrieve and accurately summarize personal memories.
Produce compelling but grounded narratives.
Maintain a consistent character and storytelling style.
Distinguish between recorded facts and fictional additions.
Run efficiently on ordinary consumer hardware.

I'll also be able to experiment with different system prompts, retrieval strategies, embedding models, and context sizes.

This flexibility is especially useful for a project like GhostVault because its quality depends on more than producing fluent text. The system must retrieve the right information and handle missing context responsibly.

A closed API could certainly provide similar functionality, but local inference gives me greater control over the execution environment and removes mandatory per-request API charges.

5. Open Innovation Makes the Project Easier to Extend

I want developers to be able to modify GhostVault rather than simply use it as a finished product.

Someone might want to add a different language model, improve semantic search, introduce multilingual storytelling, or integrate local speech recognition.

Another developer might want to adapt the archive for oral histories, historical research, or preserving endangered languages.

By keeping the system modular and publishing its implementation, I'll make these experiments easier to pursue.

I'll also document the licenses of the models and libraries I use, because an open-weight model and an open-source application are not automatically the same thing.

Ultimately, open innovation gives me the freedom to build an application whose core capabilities are not tied to a single provider's pricing, infrastructure, or product decisions.

My Agent Session

I plan to use an AI coding assistant during development to help implement and refine GhostVault.

The work will involve building the application architecture, integrating local inference, developing the retrieval pipeline, and testing how the AI responds when relevant information is missing.

I'll document the development process and, if I use DevRelay to capture a suitable agent session, include it here using the submission format requested by the challenge.

Agent session: I'll add the link here if I capture one.

I want the final project to demonstrate not just the generated experience, but also how open-source AI can be integrated into a practical application.

The Spirit of It

There's something unsettling about an old photograph.

You recognize the faces, the room, perhaps even the exact moment it was taken.

But the sounds are gone.

The conversations have faded.

And sometimes, the people who could explain the photograph are no longer around to tell you the story.

GhostVault is my attempt to build something that helps preserve those missing fragments.

Imagine finding an old photograph of your grandfather and asking The Ghost to help you organize everything you remember about it.

The AI won't actually know what happened that day. It won't recover memories that were never recorded.

But it can help you connect the information you have, ask questions you hadn't considered, and turn scattered notes into a story worth preserving.

And perhaps that's enough.

Not every ghost needs to be frightening. Sometimes, the most meaningful ghosts are the memories we don't want to lose.

With the digital ofrenda, I also want to honor the spirit of Día de los Muertos: remembering the people who shaped our lives and preserving the stories that connect generations.

GhostVault isn't about bringing the dead back. It's about making sure their stories don't disappear.

And by building it with open-weight AI and local inference, I want those stories to remain with the people who own them.

Because some memories deserve to live forever. 🕯️

Prize Categories

I'll review the challenge's official partner categories and list the ones that genuinely apply to the completed project.

Potential areas of alignment include open-weight AI, local inference, and open-source development, depending on the challenge's actual category requirements.

I'll update this section before submitting the final post.

GhostVault is currently a planned project. I'll update this post with the repository, working demo, implementation details, and actual model choices as development progresses.

ReceiptPilot: Your Private, Local-First AI Expense Organizer 🧾

Debosman Dasgupta — Sun, 18 Oct 2026 06:17:13 +0000

What I Built

Freelancers spend hours organizing receipts, categorizing expenses, and preparing monthly financial reports. When you're juggling multiple clients and projects, keeping track of every transaction becomes another job in itself.

That's why I'm building ReceiptPilot — an AI-powered expense organizer that turns messy receipts and invoices into structured, searchable financial records, without requiring users to upload their financial documents to a third-party AI service.

Here's what ReceiptPilot aims to do:

📄 Smart Receipt Extraction: Extract merchant names, transaction dates, totals, taxes, and other relevant details from receipt images and PDFs.
🧠 Automatic Expense Categorization: Classify transactions into categories such as travel, software subscriptions, office supplies, food, and utilities.
📊 Expense Dashboard: View spending patterns, category-wise breakdowns, and monthly summaries.
📁 Exportable Reports: Export organized expenses to CSV for spreadsheets and bookkeeping workflows.
🔒 Privacy-First Processing: Run the AI pipeline locally so sensitive financial documents can stay on the user's machine.

The target audience is freelancers, independent developers, consultants, and small business owners who need a simpler way to manage expenses without adopting an expensive accounting platform.

The side-hustle angle is simple: save people time on repetitive administrative work, and build a product they can justify paying for.

Demo

Live Demo: Coming soon.

Video Demo: Coming soon.

The demo will show a user uploading a receipt, reviewing the extracted information, correcting any mistakes, and watching the transaction appear in their expense dashboard.

Code

GitHub Repository: Coming soon.

The project will be built with a modular architecture so that the receipt-processing pipeline, AI model, expense categorization logic, and frontend can evolve independently.

How I Built It

ReceiptPilot is designed around open-source tools and open-weight AI models rather than a proprietary, usage-based LLM API.

Planned Tech Stack

Frontend: React + Tailwind CSS for a responsive expense dashboard.
Backend: Python + FastAPI for document processing and expense-management endpoints.
OCR: Tesseract OCR to extract text from receipt images, with PDF text extraction for digitally generated invoices.
Open-Weight LLM: Ollama to run a compatible instruction-following model locally for normalizing extracted text, identifying transaction fields, and categorizing expenses.
Data Processing: Python, Pandas, and Pydantic for structured data validation and expense reporting.
Storage: SQLite for a lightweight local database.
Visualization: Recharts for category-wise spending and monthly expense trends.

How the Pipeline Works

Upload: The user imports a receipt image or invoice PDF.
Extract: OCR or PDF parsing retrieves the available text.
Structure: The local language model converts the extracted text into structured fields, such as merchant, date, currency, subtotal, tax, and total.
Validate: Python checks field formats, required values, and basic arithmetic consistency. Uncertain fields are flagged for user review instead of being silently accepted.
Categorize: The model suggests an expense category, which the user can confirm or correct.
Store: The reviewed transaction is saved in SQLite.
Analyze: The dashboard calculates spending summaries and exports the records to CSV.

An important design decision is that the language model will not be responsible for financial arithmetic. Python will calculate totals, aggregate spending, and generate reports deterministically. The model will handle the messy language and categorization tasks where it is most useful.

The first version will focus on a small, reliable workflow rather than trying to replace a complete accounting system.

Why Does Open Innovation Matter?

For ReceiptPilot, open innovation isn't just a technology choice. It directly shapes the product's privacy, cost structure, and flexibility.

1. Financial privacy by design

Receipts and invoices can contain personal information, client details, addresses, and transaction histories.

By running OCR and the language model locally, ReceiptPilot can process these documents without sending their contents to an external AI inference API. The initial version will be designed for local use, with documents and extracted records stored on the user's machine.

2. No per-receipt AI API bill

A freelancer shouldn't have to worry about an AI API charge every time they organize another receipt.

Local inference can eliminate per-request model API fees, making repeated processing more predictable. There are still costs associated with hardware, electricity, development, and maintenance, but the economics can be attractive for frequent users with compatible hardware.

3. Freedom to change models

Different models can have different strengths when handling noisy OCR text, inconsistent receipt formats, and expense categories.

Using Ollama with compatible open-weight models makes it possible to experiment with different models without rebuilding the entire application around one proprietary provider. The chosen model's license will also be checked for commercial-use compatibility.

4. Customization for real-world workflows

A freelancer's expenses may look very different from those of a consultant or a small design agency.

An open-based architecture makes it easier to experiment with custom categories, user-defined rules, domain-specific prompts, and potentially fine-tuned models as suitable training data becomes available.

5. A product that can work without constant internet access

Once the required models and dependencies are installed, the core local processing pipeline can work offline. That means users can organize documents even when they don't have a reliable internet connection.

The trade-off is that local inference requires sufficient memory and processing power, so the model must be selected with real-world hardware limitations in mind.

The bigger idea: Open AI makes it possible to build a useful, privacy-conscious productivity tool without making every transaction dependent on an external AI provider.

My Agent Session

Coming soon.

I'll share a DevRelay agent session once the implementation workflow is available to capture, including the model integration, receipt-processing pipeline, and validation logic.

My First User

I'm looking for a freelancer or independent developer willing to test ReceiptPilot with a small batch of sample receipts.

The goal is to find out whether the extracted fields are accurate enough, how often users need to correct the results, and how much time the workflow actually saves.

I'll also ask what they would value most in a paid version: bulk processing, recurring expense reports, custom categories, or integrations with their existing bookkeeping workflow.

Rather than assuming people will pay for it, I want to validate that with a real user and improve the product based on their feedback.

Prize Categories

Open-source AI
Local AI / open-weight models
Side Hustle

ReceiptPilot is an experiment in turning open AI into something practical: a tool that helps independent workers spend less time organizing paperwork and more time doing the work they actually get paid for.

The goal isn't to put AI everywhere. It's to use it where it saves time, keep the processing under the user's control, and make the product useful enough that someone would choose to pay for it.

Let's build something useful. 🚀

🌿 WildLens: Your Offline AI Companion for Exploring Nature

Debosman Dasgupta — Sun, 11 Oct 2026 18:18:40 +0000

What if AI could help us spend less time staring at screens and more time discovering the world around us?

That question inspired me to come up with WildLens, an open-source, AI-powered nature companion designed to make exploring the outdoors more fun, educational, and accessible.

Instead of using AI to keep people glued to their phones, I want to build something that encourages them to put their phones down, step outside, and discover the little things they might otherwise overlook. 🌱

What I Built

WildLens is an AI-powered nature exploration companion that helps people identify and learn about the natural world around them.

Imagine walking through a park, hearing an unfamiliar bird call, or discovering a plant you've never seen before. Instead of spending several minutes searching the internet, WildLens helps you identify what you've found and learn something interesting about it.

Here's what I plan to build:

🐦 Bird Identification: Capture a bird's photograph or record its call to get a likely identification and learn about its characteristics.
🌿 Plant and Tree Recognition: Use an image to identify plants and trees, along with useful information about their habitat and features.
🐞 Insect Discovery: Explore the smaller inhabitants of your surroundings and learn about their role in the ecosystem.
🧠 Nature Facts: Get concise, easy-to-understand explanations about the species you encounter.
🎯 Nature Challenges: Complete small outdoor missions, such as spotting three different leaves, observing a bird without disturbing it, or finding different flower shapes.
📱 Offline Exploration: Make previously downloaded species information and supported identification features available without an internet connection.

WildLens is intended for nature enthusiasts, students, families, hikers, birdwatchers, and anyone who wants to reconnect with the world outside their screens.

The goal is simple: the phone helps you discover something, but the real experience happens outdoors.

Demo

The project is currently in the building/planning stage, and I plan to share a working demo as the implementation progresses.

The intended demo will show the complete experience:

Open WildLens and select a discovery mode.
Photograph a plant or record a bird call.
Get a predicted identification and relevant nature facts.
Save the discovery to a personal nature journal.
Receive a small outdoor challenge and continue exploring.

I'd also love to take WildLens outside and test it in a local park, documenting how it performs with real-world observations.

Demo link: To be added when the first working version is available.

Code

WildLens is intended to be an open-source project, with the code, setup instructions, model information, and contribution guidelines published on GitHub.

I want the project to be something other developers can experiment with, improve, and extend—not just another application that hides its AI implementation behind an API.

How I Built It

My approach is to build WildLens around open-source tools and open-weight AI models rather than making a closed, hosted AI API the core of the application.

Here's the planned architecture.

1. Open-weight AI for nature identification

For visual recognition, I'll explore an open-weight vision model that can identify likely plant, bird, or insect species from photographs. Depending on its performance and hardware requirements, I'll evaluate models such as a suitable vision-language model or a specialized image classifier.

For bird calls, I'll investigate a lightweight audio-classification model trained for bird-sound recognition.

These are separate ML tasks, so I'll select models suited to each rather than expecting one general-purpose language model to solve everything.

2. Local inference with Ollama

I'll explore Ollama for running a compatible open-weight language model locally.

The language model can turn identification results into useful, readable explanations, generate nature challenges, and answer questions about a discovery using trusted species information.

For example, after identifying a bird, WildLens could explain its typical habitat, diet, and interesting behavior in simple language.

The identification system and language model will have separate responsibilities. The language model should not invent a species identification when the vision or audio model is uncertain.

3. A practical technology stack

The initial implementation will use the following tools:

Frontend: React and Tailwind CSS for a responsive, mobile-friendly interface.
Backend: Python and FastAPI for model orchestration and application logic.
Vision AI: An appropriate open-weight vision model or lightweight image classifier.
Audio AI: An open-source bird-call classification model.
Local language model: Ollama with a compatible open-weight model for explanations and challenge generation.
Storage: SQLite for local discovery history and saved observations.
Nature knowledge: A curated species database, with appropriate open datasets and attribution.

I'll begin with image-based identification and the nature journal, then add audio recognition and improve offline functionality.

4. Designing for offline exploration

Offline support is one of the most important parts of WildLens.

My plan is to cache species information, save discoveries locally, and make supported models available on the device before users head outside.

A fully offline experience will depend on the selected model, device memory, and storage capacity. Rather than promising that every feature will work offline immediately, I'll build and test offline support feature by feature.

The ideal experience is to prepare before a walk and then explore without needing a constant internet connection.

5. Keeping the experience outdoors-first

I don't want WildLens to become an endless AI chat interface.

The application will prioritize quick identification results, short explanations, saved observations, and outdoor challenges. Once users have what they need, the interface should encourage them to put the phone away and continue observing their surroundings.

I'll also prioritize responsible wildlife observation: users should maintain a safe distance from animals, avoid disturbing habitats, and treat uncertain model predictions as suggestions rather than definitive scientific identifications.

Why Does Open Innovation Matter?

For WildLens, open innovation isn't just a technical preference. It's what makes the project's approach possible.

🔓 Freedom to experiment

Using open-weight models gives me the flexibility to evaluate different vision, audio, and language models, compare their performance, and replace individual components without redesigning the entire application.

If a lightweight bird classifier works better for bird calls than a general-purpose model, I can use it.

🔒 Privacy through local inference

Nature photographs and recordings can contain more information than users intend to share. Running supported inference locally can reduce the need to upload those observations to an external service.

My goal is to keep personal discovery history on the user's device and make external services optional wherever practical.

🌐 Access beyond a constant internet connection

A hosted AI API makes an application dependent on network availability, service policies, and API costs.

Local models can help WildLens support exploration in parks, gardens, and trails where connectivity is unreliable. Once the required models and reference data are available locally, supported features can work without contacting a remote inference service.

🛠️ A project the community can improve

Open-source development means other contributors can improve model integration, add regional species information, optimize inference, support more languages, and build additional exploration features.

For example, someone could contribute a better bird-call classifier or a curated database of plants found in their region.

💚 A different relationship with AI

Many AI applications compete for more screen time. WildLens is designed around the opposite idea.

AI should help people become more curious about the real world, not replace their experience of it.

That's where I believe open innovation can make a meaningful difference: giving developers the freedom to build technology that is useful, privacy-conscious, adaptable, and accessible.

My Agent Session

I'll share an agent session or development walkthrough once I have a meaningful implementation to demonstrate.

I'd like to document the process of integrating the open-weight models, handling uncertain predictions, and making offline inference practical.

Prize Categories

WildLens is being developed for the Touch Grass theme, with open-source AI at the center of the project.

I'll confirm the applicable partner prize categories against the challenge rules once the final model and tooling choices are established.

What's Next?

My next milestones are:

[ ] Set up the repository and initial application structure.
[ ] Integrate an open-weight vision model for image-based nature identification.
[ ] Build the species information and nature journal features.
[ ] Add locally generated explanations and outdoor challenges.
[ ] Investigate and integrate bird-call recognition.
[ ] Test offline inference on supported hardware.
[ ] Take WildLens outdoors and document the results.

I'm excited to build this, learn from the open-source AI ecosystem, and hopefully help more people notice the amazing things happening just outside their doors.

Let's build AI that helps us touch grass. 🌿

#Hacktoberfest #OpenSource #AI #MachineLearning #TouchGrass #Ollama #BuildInPublic

Hacktoberfest Weekend Challenge: Build for a Friend

Debosman Dasgupta — Sun, 04 Oct 2026 16:03:57 +0000

What I Built

🧠 MindFlare: A Daily Brain Exercise App for My Mother

I built MindFlare, a simple daily brain-exercise app for my mother.

As our parents get older, it's normal to notice occasional forgetfulness, remembering a number, recalling a word, or keeping track of something they just saw. I wanted to build something that could turn a few minutes of everyday mental exercise into something simple, enjoyable, and engaging.

Instead of making another complicated productivity or health app, I wanted MindFlare to feel like a small daily game.

The app provides short exercises covering:

🔢 Mental Math: addition, subtraction, multiplication and everyday calculations
🧠 Memory Recall: remember numbers, words and objects
🧩 Pattern Puzzles: identify number and visual patterns
🔤 Word Memory: remember and identify words
👀 Visual Memory: remember objects and their positions
🎯 Adaptive Difficulty: gradually adjusts the challenge based on performance

The goal isn't to diagnose, treat, or prevent any medical condition. It's simply a fun way to encourage memory practice, attention, mental calculation, and problem-solving for a few minutes each day.

The interface is intentionally simple, with large buttons, readable text, minimal distractions, and encouraging feedback.

The idea is:

5 minutes a day. A few puzzles. A little mental exercise. ❤️

Demo

🚀 Live Demo:

The application is deployed on Render.

Code

💻 GitHub Repository:

The complete source code, setup instructions, and Ollama integration are available in the repository.

How I Built It

MindFlare is built around open-source AI using Ollama.

Tech Stack

Frontend: HTML, CSS, JavaScript / React
Backend: Python + FastAPI
AI: Ollama + open-weight LLM
Database: SQLite
Deployment: Render
Version Control: Git + GitHub

The core application doesn't depend on AI for everything. The actual game logic and answer validation are handled by the application itself.

Ollama is used where generative AI actually adds value.

🤖 What Ollama Does

The AI can generate:

New math questions
Memory exercises
Pattern puzzles
Word-based challenges
Difficulty-appropriate questions
Encouraging feedback
Personalized challenges based on previous performance

For example, instead of repeatedly showing the same hardcoded questions, MindFlare can ask the local model to generate a new beginner-level arithmetic challenge.

The application can also use previous performance to determine whether the next set should be easier, similar, or slightly more challenging.

This gives the experience a more personalized feel without requiring a closed AI API for every question.

🧠 The Daily Challenge

One of the main features is the Today's 5-Minute Challenge.

A typical session might contain:

Memory → Math → Pattern → Word → Memory

At the end, the user gets a simple summary of their performance rather than a complicated analytics dashboard.

For example:

🎉 Today's Result

4 / 5 correct

Memory ⭐⭐⭐⭐

Math ⭐⭐⭐⭐⭐

Patterns ⭐⭐⭐⭐

Great job! See you tomorrow ❤️

The idea is to make the experience encouraging rather than competitive.

Why Does Open Innovation Matter?

This project is especially meaningful to me because I didn't want the AI component to simply be a black box API.

Using Ollama and an open-weight model gave me the opportunity to experiment with running an AI model through an open ecosystem and decide exactly where AI was useful in the application.

Open innovation makes experimentation much more accessible.

Instead of building around a proprietary API and sending every generated puzzle to a closed service, I could:

Experiment with different open-weight models
Run the model locally during development
Control the prompts and generation process
Customize the AI behavior for my specific use case
Build an application around an open AI stack
Learn how local inference actually fits into a real application

For a personal project like MindFlare, this matters because the app deals with a very personal use case.

The more control I have over the AI layer, the more comfortable I am experimenting with how the application handles the user's interactions and data.

Most importantly, open-source AI made this feel less like “calling an AI API” and more like actually building with AI.

My Agent Session

I used AI-assisted development during the project to help with things like application structure, debugging, prompt design, and iterating on the puzzle-generation workflow.

Agent Session:

Prize Categories

I'm submitting MindFlare for the applicable partner categories related to:

🤖 Open-source AI / AI
🧑‍💻 Developer Tools

- 🌐 Open Innovation

Why I Built This

This project started with a very simple thought:

I wanted to build something for someone I care about.

There are plenty of impressive AI applications that solve huge problems. But sometimes the most meaningful projects are much smaller.

For me, MindFlare isn't about building the world's most advanced brain-training platform.

It's about making something my mother can open every morning, spend five minutes on, smile when she gets an answer right, and hopefully come back to tomorrow.

And that's what Build for a Friend meant to me.

Technology doesn't always have to solve a huge problem. Sometimes it can simply make someone's everyday life a little better. ❤️

Hacktoberfest #BuildForAFriend #OpenSource #Ollama #AI #MachineLearning #Python #OpenInnovation #DevCommunity

Indian Elections Assistant: Empowering the Next Generation of Voters

Debosman Dasgupta — Sat, 02 May 2026 06:26:02 +0000

In a country as vast and diverse as India, democracy thrives on participation. Yet, for many young voters stepping into the electoral process for the first time, the system can feel overwhelming—full of procedures, terminology, and responsibilities that aren’t always easy to understand. That’s where Indian Elections Assistant comes in.

🌱 Why This App Matters

India is home to the world’s largest democracy, but awareness about how elections work is often limited, especially among first-time voters. Questions like:

How do I register to vote?
What is the role of the Election Commission?
How does voting actually happen on election day?

are surprisingly common.

The Indian Elections Assistant is designed to bridge this gap—turning confusion into clarity and curiosity into informed participation.

📱 What is Indian Elections Assistant?

Indian Elections Assistant is an educational app built specifically to guide young voters through every step of India’s electoral process. It simplifies complex concepts into easy-to-understand explanations, making civic education accessible, interactive, and engaging.

Whether you're preparing to vote for the first time or just want to understand how democracy functions behind the scenes, this app acts like a personal guide.

🚀 Key Features

Step-by-Step Voting Guide

The app walks users through the entire voting journey—from voter registration to casting their vote—ensuring no step feels intimidating.

Simplified Electoral Concepts

Terms like constituencies, EVMs, Model Code of Conduct, and NOTA are explained in a clear and relatable way.

Interactive Learning Experience

Instead of static content, the app uses structured guidance and intuitive flows to make learning feel natural and engaging.

Focused on First-Time Voters

The content is tailored specifically for young citizens who may not have prior exposure to civic processes.

🧠 The Idea Behind It

The motivation behind Indian Elections Assistant is simple:
An informed voter is a powerful voter.

By making electoral knowledge easily accessible, the app aims to:

Increase voter confidence
Encourage participation in elections
Promote responsible and informed decision-making
💡 Built with Purpose

Behind the scenes, the app leverages modern technologies and thoughtful design to ensure a smooth user experience. While the technical implementation includes standard development practices (like ignoring unnecessary build and dependency files for cleaner deployments ), the real focus remains on delivering value to the user.

🌍 Impact and Vision

India’s youth population is massive—and with that comes immense potential. If even a fraction of first-time voters become more informed and engaged, the ripple effect on democracy could be profound.

Indian Elections Assistant isn’t just an app—it’s a step toward:

Strengthening democratic participation
Building civic awareness
Empowering the next generation
✨ Final Thoughts

Voting is more than just a right—it’s a responsibility. But responsibility should never come with confusion.

With Indian Elections Assistant, young voters now have a reliable companion to guide them through one of the most important civic duties in the country.

Because democracy works best when everyone understands their role in it.

🗳️ Building Electify — A Digital Guide for Young Voters in India

Debosman Dasgupta — Mon, 27 Apr 2026 16:35:10 +0000

In a country as diverse and democratic as India, voting is not just a right — it’s a responsibility. Yet, for many first-time and young voters, understanding the electoral process can often feel confusing and overwhelming.

That’s what inspired me to build Electify — an interactive web application designed to simplify and explain the electoral process in India in a clean, engaging, and beginner-friendly way.

From voter registration to election day and result declaration, Electify aims to guide young citizens through every stage of democracy.

In this blog, I’ll share:

The idea behind Electify
The technologies used
How I deployed the project on Google Cloud Run
Challenges faced during deployment
Key lessons learned along the way

🌟 What is Electify?

Electify is an interactive election guide web app created to help young and first-time voters understand how elections work in India.

The application presents the electoral journey in a simple and visually engaging timeline format, covering stages such as:

Voter registration
Election preparation
Voting process
Counting and results
Transition of governance

The goal was to make civic awareness:
✅ Easy to understand
✅ Accessible to everyone
✅ Visually engaging
✅ Mobile-friendly

At its core, Electify combines technology with civic education.

🎯 Why I Built This Project

Many young voters:

Don’t know how to register
Are unaware of election procedures
Find official information too complex
Lack awareness about the importance of participation in democracy

I wanted to create something minimalistic yet informative — a platform that explains the electoral process in a modern and interactive way.

Electify is my attempt to bridge the gap between technology and civic awareness.

🛠️ Tech Stack Used

Frontend

HTML5
CSS3
JavaScript

Backend

Python Flask

Deployment & DevOps

Docker
Google Cloud Build
Google Cloud Run

💡 Key Features of Electify

📱 Responsive User Interface

The application is optimized for both desktop and mobile users.

🗓️ Timeline-Based Learning

The electoral process is broken into easy-to-follow stages.

⚡ Interactive Experience

Users can explore different election phases dynamically.

☁️ Cloud Deployment

The app is deployed on Google Cloud Run for scalability and reliability.

📦 Containerizing the Application with Docker

To make deployment smoother and production-ready, I containerized the project using Docker.

Dockerfile

```dockerfile id="hyjlwm"
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

ENV PORT=8080

EXPOSE 8080

CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]




This setup ensured:

* Lightweight deployment
* Faster builds
* Consistent runtime environment
* Better scalability on Cloud Run

---

# ☁️ Deploying Electify on Google Cloud Run

I used Google Cloud Run because it provides:

* Serverless infrastructure
* Automatic scaling
* HTTPS support
* Container-based deployment
* Cost efficiency

## Step 1 — Build the Docker Image



```bash id="6g6e7k"
gcloud builds submit --tag gcr.io/PROJECT_ID/electify

Step 2 — Deploy the Application

```bash id="r00uj7"
gcloud run deploy electify \
--image gcr.io/PROJECT_ID/electify \
--platform managed \
--allow-unauthenticated \
--region asia-south1




Within minutes, Electify was live on the internet 🚀

---

# 🧩 Challenges Faced During Deployment

Like every real-world project, deployment came with its own challenges.

### ❌ Missing Dockerfile

Initially, Cloud Build failed because the Dockerfile wasn’t in the correct project directory.

### ❌ Wrong Build Context

At one point, Google Cloud Build detected “0 items” because the deployment command was executed from the wrong folder.

### ❌ Port Configuration Issues

Cloud Run requires applications to bind to the `PORT` environment variable dynamically.

I fixed this in Flask using:



```python id="o7rq2k"
port = int(os.environ.get('PORT', 8080))
app.run(host='0.0.0.0', port=port)

These debugging experiences taught me a lot about cloud-native deployment workflows.

📚 What I Learned

Building and deploying Electify helped me gain practical experience in:

Full-stack web development
Docker containerization
Google Cloud deployment
Cloud-native application hosting
Debugging production deployment issues
Designing user-focused interfaces

Most importantly, I learned how technology can be used to spread awareness and simplify important civic processes.

🚀 Future Improvements

I plan to expand Electify further by adding:

Election Commission API integration
Real-time election updates
Regional language support
AI-powered voter assistance
Interactive quizzes and learning modules
Accessibility improvements

The long-term vision is to make Electify a complete digital civic awareness platform for young Indian voters.

🇮🇳 Final Thoughts

India is the world’s largest democracy, and informed voters are its greatest strength.

Electify may be a small project, but it represents a larger idea — using technology to educate, empower, and encourage participation in democracy.

Building this project was not just a technical experience, but also a meaningful one.

It reminded me that technology is most impactful when it solves real-world problems and creates awareness among people.

💬 Conclusion

Electify combines:

Web development
Cloud computing
Civic awareness
Interactive design

into one meaningful project.

From designing the UI to deploying it on Google Cloud Run, the entire journey was a valuable learning experience that strengthened both my development and deployment skills.

I’m excited to continue improving the platform and exploring how technology can contribute positively to society.

Thanks for reading! 🚀🗳️