MITRA

MITRA — Remember What Matters

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built MITRA, a personal AI memory companion for a friend who kept losing important information inside scattered conversations, voice notes, screenshots, and notes.

The problem wasn't that they couldn't remember.

The problem was that important information was scattered everywhere.

MITRA lets them tell it something naturally, such as:

"I talked to Rahul today. His internship application closes Friday and I promised to review his resume tonight."

Instead of simply saving that sentence, MITRA uses Gemma to understand it and extract structured information:

• Person: Rahul
• Topic: Internship
• Deadline: Friday
• Action: Review resume
• Source: Text or voice

The user reviews the extracted memory before saving it.

Later, they can ask:

"What did Rahul tell me about his internship?"

MITRA retrieves the relevant memory and responds:

You told me this before.

It then shows the source memory used to support the answer.

That was the experience I wanted to build: not another chatbot that talks confidently, but a system that can remember something useful and show me where that memory came from.

If MITRA doesn't have a supporting memory, it refuses to invent one.

---

Demo

Live Demo: mitra-lilac-seven.vercel.app

The public demo includes clearly labelled DEMO DATA, so judges can experience the complete product without installing a local AI model.

The main flow is:

Tell → Understand → Review → Remember → Ask → Retrieve → Source → Connect

Try the 60-second demo to see the complete experience.

---

Code

GitHub: [https://github.com/Shubhupadhyay23/mitra-memory.git]

The repository contains the Next.js frontend, FastAPI backend, memory pipeline, Gemma/Ollama integration, database layer, and documentation.

---

How I Built It

The core architecture is:

text
Human thought
      ↓
   MITRA UI
      ↓
     Gemma
      ↓
Structured memory
      ↓
 Persistent storage
      ↓
   Retrieval
      ↓
Gemma grounded response
      ↓
  Source memories
### Stack

- **Next.js + TypeScript** — frontend
- **FastAPI + Python** — backend
- **SQLAlchemy + SQLite** — persistent memory
- **Ollama + Gemma** — local AI reasoning and memory extraction
- **Tailwind CSS** — interface
- **Antigravity** — agent-assisted development

Gemma isn't just an AI button sitting beside the application.

It is part of the memory pipeline.

When a user gives MITRA information, Gemma helps turn unstructured human language into structured memory. When the user asks a question later, MITRA retrieves relevant stored memories and uses that context to produce a grounded answer.

The important part is the boundary between **memory and generation**.

If there is no supporting memory, MITRA should not confidently manufacture an answer.

---

## Why Does Open Innovation Matter?

For MITRA, open-source AI changed what I could build.

A conventional closed API would make it easy to send a prompt somewhere and receive a response.

But MITRA is fundamentally about **personal memory**.

I wanted the AI responsible for interpreting those memories to be replaceable, inspectable, and capable of running locally.

Using **Gemma through Ollama** allowed me to build the core intelligence around a locally runnable model instead of making the entire product dependent on a proprietary hosted model.

That gives MITRA an important property:

**The user's memories don't have to belong to an AI provider.**

The architecture can evolve as better open models become available without rebuilding the entire application around one closed API.

Open innovation also made experimentation much easier. I could change the model, adjust the extraction process, test the retrieval behaviour, and keep the surrounding application under my control.

For a product dealing with personal memories, that control matters.

---

## What I Learned

The hardest part wasn't making an AI chatbot.

It was making the AI **not say things it doesn't know**.

Memory systems create a different problem from normal chat applications. A convincing wrong answer is worse than saying:

> "I don't have a memory supporting that."

That led me to build MITRA around three principles:

1. **Extract before storing**
2. **Retrieve before answering**
3. **Show the memory behind the answer**

The result is less about having a clever conversation and more about building a trustworthy memory layer.

---

## Limitations

MITRA is still a prototype.

The strongest local-AI experience currently comes from running Gemma through Ollama, while the public demo uses labelled demo data so judges can experience the application without configuring a local model.

The memory system also needs much more real-world testing. In particular, I want to measure:

- memory extraction accuracy
- retrieval accuracy
- incorrect-memory resistance
- refusal behaviour
- long-term memory usefulness

I don't want to call MITRA a solved memory system yet.

I want to make it one.

---

## What's Next?

The next version would focus on real-world use rather than adding more features.

I would like to test MITRA with actual daily memories, measure which memories are useful later, improve retrieval, and make the system increasingly reliable at distinguishing between something I actually told it and something it merely thinks might be true.

The goal is simple:

**Remember less for me. Remember the right things.**

---

## Prize Categories

**Best Use of Gemma**

Gemma is used as a core part of MITRA's memory-understanding pipeline rather than being included as a superficial chatbot feature.