This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
HomeCache - Your Household, Remembered
I built HomeCache, an AI-powered memory for your home.
The idea came from a simple problem I noticed with someone close to me. Important household information was everywhere - tucked away in invoices, warranty cards, service receipts, and product manuals.
And whenever we needed a simple answer, it usually turned into a little treasure hunt:
“When did we buy the washing machine?”
"Is the refrigerator still under warranty?"
"When was the AC last serviced?"
“Where did we keep the TV manual?”
The information was there. The real problem was remembering where it was and what it said.
So I built HomeCache to make that easier.
You can upload your household documents, and instead of digging through files one by one, you can simply ask questions about them in natural language.
For example:
When does my washing machine warranty expire?
HomeMemory finds the relevant information from your documents and uses an open-weight AI model to turn it into a simple, useful answer.
The goal is pretty simple: your home has a lot to remember, so let AI do the remembering.
What can HomeCache remember?
HomeCache is built to remember the everyday information you usually end up searching for around the house.
- 🧾 Purchase invoices
- 🛡️ Warranty documents
- 🛠️ Service receipts
- 📖 Product manuals
- 📄 Other important household records
Once you upload a document, HomeCache reads and processes it, breaks the information into smaller searchable pieces, and stores those memories in a vector database.
Then, when you ask a question, it searches through those memories to find the information that's actually relevant to your question. That information is then given to the AI model as context so it can answer you.
The important part is that HomeCache answers from your own documents, rather than relying only on what the AI already knows.
Think of it as giving your household its own memory - one that you can actually ask questions to.
Meet the Memory
I also built a Meet the Memory demo mode so someone seeing the project for the first time doesn't have to upload five documents before understanding what it does.
To show how HomeCache works, I created a fictional household with five documents:
- 🧺 LG Washing Machine Invoice
- 🧊 Samsung Refrigerator Warranty
- ❄️ Voltas AC Service Receipt
- 📺 TV User Manual
- 💧 Water Purifier Invoice
Once you click Meet the Memory, the household is ready to chat with.
You can ask simple questions like:
When does my washing machine warranty expire?
When should I service the AC again?
How much did the water purifier cost?
How do I factory reset the TV?
You can also ask questions that require HomeMemory to look across multiple documents and connect the information:
Which appliance has the latest warranty expiry date?
The idea is to make interacting with household documents feel less like searching through files and more like talking to someone who remembers everything for you.
All the information in this demo household is fictional and created specifically for demonstration purposes.
🌐 Live Application
HomeCache:
[https://home-cache.vercel.app/]
The recommended demo flow is:
Open HomeCache
↓
Meet the Memory
↓
Load fictional household
↓
Ask a question
↓
Retrieve relevant memories
↓
Gemma generates the answer
↓
View the supporting document
The goal was to make the value of the project understandable within the first minute.
Code
GitHub Repository
[https://github.com/Advi729/home-cache]
The repository contains both the React frontend and Node/Express backend:
HomeCache/
│
├── client/
│ └── React + TypeScript application
│
├── server/
│ └── Node + Express + TypeScript API
│
└── README.md
How I Built It
Under the hood, HomeCache uses a RAG (Retrieval-Augmented Generation) pipeline to turn household documents into something you can actually talk to.
Household Document
│
▼
Text Extraction
│
▼
Chunking
│
▼
Embeddings
│
▼
MongoDB Atlas Vector Search
│
▼
Relevant Memories
│
▼
Gemma-2-2B-IT
│
▼
Grounded Answer
1. Document ingestion
When you upload a document, HomeCache first extracts the text from it and breaks that text into smaller pieces.
Each piece becomes a small, searchable part of the household's memory.
2. Embeddings
Those chunks are then converted into embeddings - numerical representations that capture the meaning of the text.
This allows HomeCache to search based on meaning and context, rather than only looking for exact keyword matches.
3. MongoDB Atlas Vector Search
The document chunks and their embeddings are stored in MongoDB Atlas.
When you ask a question, your question is also converted into an embedding. MongoDB Atlas Vector Search then looks through the stored memories and finds the pieces of information that are most relevant to your question.
And this is one of the most important ideas behind HomeCache:
It's not just a chatbot sitting on top of a database.
The database is the memory.
4. Gemma
The relevant memories are then passed to Gemma-2-2B-IT, an open-weight model from Google.
The model receives something like:
User Question
+
Relevant Household Memories
↓
Final Answer
Instead of asking the model to simply answer from what it already knows, HomeCache gives it the relevant information retrieved from the household documents.
This is what makes the system a RAG architecture - the model generates its answer using information retrieved from the user's own documents.
5. Source-aware responses
HomeCache also keeps track of which documents were used to answer a question.
For example:
The washing machine warranty expires
on March 11, 2027.
For example:
The washing machine warranty expires
on March 11, 2027.
Source:
📄 LG Washing Machine Invoice
This makes the answers easier to verify and gives the user a clear idea of where the information came from. The goal is simple: you shouldn't just get an answer - you should be able to trust where that answer came from.
Technology Stack
Frontend
- React
- TypeScript
- Vite
- React Router
- Tailwind CSS
Backend
- Node.js
- Express
- TypeScript
- Mongoose
AI
- Gemma-2-2B-IT
- Embeddings
- Retrieval-Augmented Generation
Data
- MongoDB Atlas
- MongoDB Atlas Vector Search
Deployment
- Vercel — React frontend
- Render — Node/Express backend
- MongoDB Atlas — database and vector search
Why Does Open Innovation Matter?
This is probably the part of HomeCache that matters most to me.
Household documents can contain a lot of personal information.
A washing machine invoice might include someone's name, address, phone number, purchase details, and other information. Warranty cards and service records can reveal even more about a household.
That makes a household memory a little different from a typical chatbot.
I wanted the core AI behind HomeCache to be based on an open-weight model, rather than building the entire application around a proprietary model that I would always have to depend on.
That's why HomeCache uses Gemma-2-2B-IT.
Open weights change the future of the application
The version of HomeCache that's currently deployed uses hosted inference. For a weekend project, this makes things much easier to build, deploy, and share.
But that's not where the architecture has to end.
Because the model is open-weight, there's room to take the project further in the future - including adapting the system to run the model more directly within a user's own environment.
That opens up some interesting possibilities for a product like HomeCache, where privacy and control over personal household data matter just as much as the AI itself.
For me, that's what makes open innovation exciting: you're not just building something that works today. You're leaving yourself room to decide how it should work tomorrow.
The same application could eventually be adapted to run the model:
HomeCache
│
┌─────────────┴─────────────┐
│ │
▼ ▼
Cloud inference Local inference
│ │
▼ ▼
Easy deployment More privacy
A user could potentially run the AI locally on hardware capable of supporting the model.
And that matters because a personal memory system is exactly the kind of application where data ownership, privacy, and deployment flexibility are important.
Model choice becomes a decision, not a dependency
One of the things I like about using an open-weight model is that the AI layer doesn't have to stay fixed forever.
I can experiment with different approaches as the project evolves:
- Different open-weight models
- Local inference
- Self-hosting
- Fine-tuning
- Smaller models for edge devices
- Larger models when more reasoning capability is required
The important part is that the rest of the application doesn't have to be completely rebuilt every time the underlying model changes.
The model can evolve with the project.
The goal isn't to avoid every proprietary AI service. It's to make sure the application isn't permanently locked into one.
Why RAG + Open AI?
I could have built this as:
User
↓
Generic AI chatbot
↓
Answer
But simply giving a chatbot access to a database wouldn't automatically give it a reliable memory of the household.
Instead, HomeCache separates memory from reasoning:
MongoDB Atlas
│
│ "What does this household know?"
▼
Relevant memories
│
│
▼
Gemma
"What should I say about those memories?"
This separation is important.
MongoDB stores the household's knowledge.
Vector Search finds the information that's relevant to the question.
Gemma turns that knowledge into a useful answer.
The model isn't expected to magically remember everything.
The application gives it the right memories at the right time.
Building for a Friend
HomeCache didn't start with a detailed user persona or some big product idea.
It started with a much smaller problem:
Someone close to me kept having to look through household documents to answer simple questions.
That was enough of a reason to build something.
I wanted to see if I could take that small, everyday annoyance and turn it into something genuinely useful.
That little experiment eventually became HomeCache.
Instead of trying to build another general-purpose AI assistant, I decided to focus on one simple question:
What if your home could actually remember?
What I Learned
One of the biggest things I learned while building HomeCache is that the most interesting part of an AI application isn't necessarily the model itself.
The real value comes from putting a few pieces together in the right way:
Real problem
+
Good data
+
Retrieval
+
Model
+
Useful interface
A relatively small model can become surprisingly useful when you give it the right information at the right time.
Building the RAG pipeline also changed the way I think about what "AI memory" actually means.
Memory doesn't necessarily mean trying to put everything inside the model.
It can be much simpler:
Store information reliably, retrieve what matters, and give the model only what it needs.
That idea ended up being one of the most important lessons I took away from building HomeCache.
Partner Technology
One thing I wanted to make sure of while building HomeCache was that the challenge technologies weren't just added for the sake of checking a box.
HomeCache genuinely uses three of the challenge's partner technologies as important parts of the application.
🟢 Best Use of Gemma
Gemma-2-2B-IT is the core generative model behind HomeCache's household question-answering.
When a user asks a question, HomeCache retrieves the relevant memories from the household's documents and passes them to Gemma. Gemma then uses that context to generate the final answer.
So this isn't just an ornamental integration.
HomeCache actually depends on Gemma to turn retrieved household memories into useful, conversational answers.
🟢 Best Use of MongoDB Atlas
MongoDB Atlas is the data layer and memory store behind HomeCache.
The application uses MongoDB to store household documents and their processed chunks, while MongoDB Atlas Vector Search finds the memories that are most relevant to a user's question.
MongoDB isn't simply being used to store application data.
It is the memory layer of HomeCache.
Without it, there would be no reliable household memory for the AI to retrieve from.
🟢 Best Use of Render
The HomeCache backend is deployed on Render.
Render hosts the Node.js/Express API that brings the different pieces of the application together, including:
- Document ingestion
- RAG retrieval
- AI requests
- Demo memory creation
- Communication with MongoDB Atlas
Together, these technologies form the core of HomeCache - MongoDB provides the memory, Gemma provides the reasoning, and Render provides the infrastructure that connects everything together.
The deployed architecture is:
Vercel
React Frontend
│
│ HTTPS
▼
Render
Node + Express Backend
│
├──────────────► MongoDB Atlas
│ │
│ ▼
│ Vector Search
│
▼
Gemma-2-2B-IT
I chose Render because it let me get the complete AI application online quickly without having to spend time managing servers and infrastructure myself.
What I'd Build Next
HomeCache is intentionally small for now, but there are quite a few directions I'd love to take it in the future.
🔒 Local-first HomeCache
The biggest next step would be making it possible to run the complete AI pipeline locally.
That would mean sensitive household documents could stay on the user's own machine instead of having to leave their environment.
For something designed to remember personal household information, privacy should be a feature, not an afterthought.
📅 Household maintenance memory
HomeCache could go beyond answering questions and start identifying useful information automatically, such as:
- Warranty expiry dates
- Recommended service intervals
- Maintenance schedules
- Important renewal dates
That information could then be turned into a simple household maintenance calendar.
🔔 Proactive reminders
Right now, HomeCache waits for you to ask a question.
In the future, it could become more proactive.
Instead of waiting for someone to ask:
"Is my refrigerator warranty still valid?"
HomeCache could simply let you know:
Your refrigerator warranty expires in 30 days.
The goal would be to move from a system that only remembers when you ask to one that can remind you when it matters.
📱 Mobile
A mobile version would make adding new memories much easier.
For example, you could take a photo of a receipt or warranty card immediately after buying an appliance, upload it from your phone, and let HomeCache take care of the rest.
Over time, that could make building a household memory feel almost effortless.
Prize Categories
I am entering the following partner categories:
- Best Use of Render
- Best Use of Gemma
- Best Use of MongoDB Atlas
These technologies aren't just integrations added to satisfy a challenge requirement.
They're actually part of the application's core architecture and play a real role in how HomeCache works.
Final Thoughts
HomeCache started with a small, everyday problem:
"Where did we put that document, and what did it say again?"
The answers were already there.
They were sitting inside invoices, warranty cards, service receipts, and manuals.
The problem was that they weren't easy to remember.
So I built a memory for the home.
And by building it around open-weight AI, I wanted to explore a future where having an AI assistant doesn't necessarily mean sending every piece of personal information to a closed system.
A future where you have more control over what your AI knows and how that information is used.
Top comments (0)