My Roommate Sends Chaotic Grocery Messages. So I Built an AI for It.

What I Built

MessyList — Turn chaotic grocery messages into a shopping list

My roommate has a very particular way of asking me to buy groceries.

It's rarely:

"Buy 1 packet of milk, 1 brown bread, and 5kg of atta."

Instead, it looks more like:

"bhai milk le aana"
"bread bhi"
"brown wali"
"eggs bhi khatam hai"
"actually Rahul eggs la raha"
"atta bhi le aa"
"5kg wala"

And somehow, I'm supposed to remember all of that while standing in a grocery store. 😭

So I built MessyList, a personal AI grocery assistant that turns those chaotic conversations into a clean, actionable shopping list.

The idea is simple:

Messy messages → AI understands the context → Clean grocery list

But it isn't just extracting nouns from a message.

MessyList can understand things like:

"bread bhi" → add bread

"brown wali" → understand that it refers to the bread

"get 5kg atta" → understand quantity and unit

"actually Rahul is bringing eggs" → remove eggs from the list

"same milk as last time" → use a saved preference

corrections and conversational context

After the AI interprets the conversation, I can review and edit the result before saving it as a shopping list.

The app also remembers grocery preferences and previous lists, so it can become more useful over time.

I built this specifically around a real, everyday problem rather than trying to make another generic AI chatbot.

Demo

Try MessyList:
https://grocery-ai-indol.vercel.app/

The deployed app includes a demo flow so you can try the idea without having to prepare your own grocery messages.

A typical flow looks like:

1. Paste the messy messages

bhai milk le aana
bread bhi
brown wali
eggs khatam hai
actually Rahul eggs la raha
atta bhi 5kg wala

1. MessyList understands them

2. Review the AI's interpretation

3. Save the shopping list

4. Check items off while shopping

The goal was to make the interface simple enough that my roommate could actually use it instead of needing a tutorial.

Code

The complete source code is available on GitHub:

👉 https://github.com/CyborgX-hash/Grocery-ai

The repository contains the frontend, backend, Prisma database layer, AI integration, and demo mode.

How I Built It

The application is built as a full-stack web application.

Tech Stack

React

Node.js

Express.js

Prisma ORM

Database persistence

Open-weight AI / Gemma

Vercel for deployment

The important part of the architecture is the AI parsing layer.

The grocery conversation is sent to the AI with relevant context such as saved grocery preferences and previous purchases.

The model converts the natural language into structured data rather than simply generating a conversational response.

For example:

{
"items": [
{
"name": "Brown Bread",
"quantity": 1,
"unit": "pack",
"status": "active"
},
{
"name": "Eggs",
"status": "cancelled",
"notes": "Rahul is bringing them"
},
{
"name": "Atta",
"quantity": 5,
"unit": "kg",
"status": "active"
}
]
}

The application then validates that response and lets the user review it before saving anything.

I also added a development/demo mode so the application can still demonstrate the complete product flow without exposing or hardcoding AI credentials.

The data layer

I used Prisma ORM to manage the persistent data layer.

The application stores things like:

Grocery lists

Grocery items

Purchase status

Grocery preferences

Previous shopping history

This allows the AI to use relevant personal context instead of treating every grocery request as completely independent.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

A grocery list might not sound like sensitive information, but when you start giving an AI access to someone's messages, habits, preferences, purchases, and household information, privacy becomes important.

I wanted the architecture to be built around an open-weight model rather than making the application completely dependent on a closed AI provider.

Using an open model such as Gemma gives the project much more flexibility.

The model can potentially be:

self-hosted

swapped for another open model

adapted for a specific use case

run in a more private environment

changed without rebuilding the entire application around one proprietary API

That matters because the long-term idea behind MessyList isn't just:

"Send my messages to an AI and get a list."

It's:

"Give me a personal AI tool that I can actually control."

For a personal assistant dealing with someone's everyday messages and preferences, that distinction matters.

My Agent Session

I used an AI-assisted development workflow to build and iterate on the application, from the initial architecture and UI through the AI parsing flow and database integration.

Prize Categories

🏆 Best Use of Gemma

MessyList is built around an open-weight AI architecture using Gemma for understanding natural-language grocery conversations and converting them into structured grocery data.

I'm entering the Best Use of Gemma category.

What's Next?

MessyList started with one very specific problem: my roommate's chaotic grocery messages.

But there are a few directions I'd love to take it next:

Voice messages — turn voice notes into shopping lists.

WhatsApp integration — automatically process grocery conversations.

Receipt scanning — update purchase history from receipts.

Budget mode — build a grocery list around a spending limit.

Shared household lists — allow multiple roommates to contribute to the same list.

For now, though, I'm happy that a conversation that normally looks like this:

"milk le aana"
"bread bhi"
"wait don't get eggs"
"actually get eggs"

can become something a little more useful:

☐ Milk
☐ Brown Bread
☐ Atta — 5kg

And hopefully, a little less chaotic. 😄

Thanks for checking out MessyList!