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.