Building Advaita AI: My First Hackathon, First Time Coding Seriously

I'm a CS student. Before this hackathon, I knew a little Python — enough to follow a tutorial, not enough to build something on my own.

I didn't own a laptop; I was working on a borrowed one, which meant every install, every command, came with a small voice in my head saying don't break anything.

When I saw the "Hangover Part AI: Where's My Context?" hackathon by WeMakeDevs, the idea hooked me immediately — AI forgets everything the moment a conversation ends, and Cognee exists to fix that.

I decided to build something for myself: a personal assistant that actually remembers
what I tell it.

The First Attempt: Voilora AI

My first version was called Voilora AI. I got a basic chatbot working with Cognee and Groq, and for a few hours it worked beautifully — it remembered my name, recalled it later, even picked up on my mood.
I thought I was done.

Then it broke. Badly.

A storage mismatch error started appearing every time I restarted the app —
File not found, over and over, no matter how many times I cleared the cache or deleted folders.

I spent hours chasing it, and eventually understood the real cause: Cognee's metadata database and its file storage had gone out of sync after too many restarts during testing.

By the time I found the fix, I had also hit an "event loop" error from mixing async code with Streamlit's rerun behavior, and separately, Groq's daily free-tier token limit ran out mid-testing.

At some point, frustrated, I made a decision: start over, cleanly, with everything I'd just learned.

Starting Over: Advaita AI

The name changed for a reason. Advaita means "non-duality" — the idea that nothing is truly separate, everything is one continuous thread.

It felt like the right name for an AI that doesn't treat every conversation as a blank slate.

This time I built it in layers, testing each piece before adding the next:

• Backend: Cognee for memory (add, search, cognify, prune), Groq for fast responses, FastEmbed for local embeddings so I didn't need another paid API.
• Frontend: Streamlit, styled to feel less like a demo and more like a real product — a dark theme, custom chat bubbles, a sidebar showing Cognee's memory lifecycle.
• Extras: voice input (transcribed with Whisper via Groq), document upload, mood detection, and a memory summary feature — small additions that made the project feel like mine, not just a copy of the example.

What Actually Broke (and What I Learned)

• Event loops: Streamlit reruns your whole script on every interaction.
  If you create a new asyncio event loop each time, anything Cognee is holding onto from a previous loop breaks. The fix was running each async call in its own thread with a fresh loop — not elegant, but it worked.

• Metadata drift: cognee.prune.prune_data() alone isn't enough to reset memory cleanly. You need prune_system(metadata=True) too, or ghost references to old files stick around and throw errors later.

• Rate limits are real: Groq's free tier has a daily token cap. I hit it in the middle of testing, right when I needed the app most. The fix was as simple as a second API key, but it taught me to always have a backup plan for external services.

• Speed vs. reliability: Calling cognee.search() before every reply
  made responses accurate but slow. Skipping it made replies instant but sometimes wrong. I ended up finding a middle ground — reply fast, but index immediately after, so the next question is answered correctly.

None of these were things I could have anticipated. I learned them by breaking the app, reading error messages I didn't understand at first, and slowly making sense of them one at a time.

Why This Mattered to Me

I'll be honest about my motivation: I don't own a laptop, and winning this hackathon would mean I finally could.

But somewhere in the process of fixing the fortieth error, the goal changed a little.

I stopped just wanting to win, and started wanting to understand what I was building — why an async loop breaks, why a database needs its metadata cleared, why a production app needs error handling instead of a silent except: pass.

That shift is the actual result of this hackathon, prize or no prize.

What Advaita AI Does

• remember() — stores text, voice notes, and documents into Cognee's knowledge graph
• recall() — answers questions using Cognee's hybrid graph-vector search
• improve() — runs Cognee's cognify() to enrich memory connections
• forget() — fully clears memory, including metadata
• A memory summary feature, mood detection, and voice/document input on top of the core lifecycle

It's not polished like a commercial product. But it's mine — built,broken, and rebuilt over two days, mostly from a borrowed laptop and a lot of stubbornness.

GitHub: https://github.com/komalsahu-codes/Advaita-AI

Thanks for reading — and thanks to WeMakeDevs and Cognee for the reason to finally sit down and actually learn to build something.

Comments

[FromZeroToShip]

The sentence that matters most here is the quiet one in the middle: you stopped wanting to win and started wanting to understand. That switch is the actual prize — laptops depreciate, that doesn't. I build tools without a developer background, and my experience matches yours exactly: understanding never arrived before building. It showed up mid-debug, somewhere between the async loop breaking and figuring out why. The borrowed-laptop detail makes this even better. Constraints have a way of filtering out everyone who was only in it for the demo. Whatever you build next, keep writing it up like this — the failure details are the useful part, and most people edit them out.