Saarthi: A Local AI Companion That Remembers What Matters

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

What I Built

I built Saarthi, a local AI companion that remembers what matters to you and uses that context to help you decide what to do next.

I built it for a close friend who often has a lot going on at the same time: exams, projects, personal goals, things they want to learn, and deadlines they don't want to forget.

The problem wasn't that they needed another chatbot.

They needed something that actually understood their context.

With Saarthi, they can naturally tell it things like:

"I have my DBMS exam on Friday and normalization is really confusing me."

Instead of simply replying to that message, Saarthi can understand that:

• There is an upcoming DBMS exam.
• Normalization is a weak area.
• The exam should probably become a high-priority task.

The user gets to decide whether Saarthi should remember that information.

Once remembered, MongoDB becomes Saarthi's long-term memory.

Later, asking:

"What should I focus on today?"

can produce a personalized answer based on those memories.

Saarthi can also:

• Identify useful information from natural conversations
• Ask before permanently remembering inferred information
• Track goals, weaknesses, preferences and upcoming events
• Detect when something changes
• Update existing memories instead of creating duplicates
• Show why a particular recommendation was made
• Generate a personalized plan for the day
• Show the context that influenced an AI response
• Visualize the user's context through a timeline and context graph

The idea is simple:

Saarthi doesn't just remember what you said. It uses what it remembers to understand what matters next.

Demo

Live Demo: https://saarthi-gb4r.onrender.com/

One of the main things I demonstrate in the video is Saarthi running with the internet disconnected.

The flow is:

Tell Saarthi something
        ↓
Gemma understands it
        ↓
User approves the memory
        ↓
MongoDB stores it
        ↓
Saarthi uses that context later
        ↓
Gemma provides a personalized recommendation

Code

GitHub: https://github.com/Abhishek-IITP/Saarthi

The project is built around a deliberately simple architecture:

Next.js
   │
   ├── MongoDB
   │      └── Personal Context / Memories
   │
   └── Ollama
          └── Gemma

There is no complicated microservice architecture behind the prototype.

The goal was to keep the product small while making the AI behavior meaningful.

How I Built It

The core of Saarthi is Gemma running locally through Ollama.

When a user sends a message, Saarthi can pass it to Gemma to identify useful information that could become part of the user's long-term context.

For example:

"I have my DBMS exam on Friday and
normalization is really confusing me."

can become structured context such as:

DBMS exam → Friday
Normalization → Weakness

The user can then approve or reject what should be remembered.

MongoDB stores that context along with information such as:

category
importance
confidence
source
status
createdAt
updatedAt

This lets Saarthi distinguish between something the user explicitly said and something the AI inferred.

When the user asks a question, relevant context is retrieved from MongoDB and provided to Gemma.

For example:

User:
"What should I focus on today?"

        ↓

MongoDB

DBMS exam → Friday
Normalization → Weakness
Placement preparation → Goal
Night study → Preference

        ↓

Gemma

        ↓

Personalized recommendation

I also added a "Why this?" interaction so Saarthi can show which memories influenced its recommendation.

For example:

Why this?

• Your DBMS exam is Friday
• You identified normalization as difficult
• You prefer studying at night

This makes the connection between memory and AI reasoning visible instead of hiding it behind a black box.

Another part I wanted to explore was changing context.

If a user initially says:

"My project submission is tomorrow."

and later says:

"My project submission is finally done."

Saarthi shouldn't create two unrelated memories.

It should understand that the existing event has changed:

Project submission

Upcoming
    ↓
Completed

That allows the assistant's priorities to change as the user's situation changes.

The main technologies are:

• Next.js for the application
• TypeScript for the implementation
• MongoDB for persistent personal context
• Gemma for local AI reasoning and memory extraction
• Ollama for running Gemma locally
• Tailwind CSS for the interface
• Framer Motion for subtle interactions

I intentionally avoided adding a large agent framework or complicated infrastructure.

The interesting part of the project is the interaction between memory, context and local AI, not the number of technologies used.

Why Does Open Innovation Matter?

Personal context is exactly the kind of information I don't want to blindly send to a third-party AI provider.

Saarthi uses Gemma locally through Ollama, which means the AI inference can happen directly on the user's machine.

That gives the user more control.

They can:

• Run the model locally
• Use Saarthi without an internet connection
• Change the model
• Modify the prompts
• Change how memories are extracted
• Change how the assistant prioritizes information
• Experiment with the AI behavior without depending on a proprietary API

The open approach also changed what I could build.

With a closed API, I could have made:

Question → API → Answer

Instead, I could build the AI into the actual product behavior:

Conversation
     ↓
Memory extraction
     ↓
User approval
     ↓
Persistent context
     ↓
Context updates
     ↓
Prioritization
     ↓
Planning
     ↓
Personalized answer

Gemma isn't just being used to generate text.

It is part of the application's memory and reasoning system.

That's what made open innovation particularly useful for Saarthi.

And the most satisfying part is being able to turn off the internet and still have the core AI experience work.

Prize Categories

• Build for a Friend
• Open-source AI / Open-weight AI

Saarthi was built specifically around a real person's needs rather than as a generic AI demo.

The project also relies on locally running open-weight AI through Gemma and Ollama as a core part of its functionality.