MemoryMate — An AI Memory Assistant Built for a Friend

Himanshu Gangwar — Sat, 03 Oct 2026 05:47:30 +0000

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

What I Built

I built MemoryMate, a personal AI memory assistant designed for a friend who often forgets small but important details about people, conversations, events, and shared experiences.

The idea came from a simple problem: we remember major moments, but the small details that make relationships meaningful are often the easiest to forget.

MemoryMate gives users one place to store those details and interact with them through an AI-powered interface.

It can help users:

Save and organize personal memories
Store information about important people
Keep track of events and meaningful dates
Explore memories through a timeline
Ask questions about their stored memories through AI
View insights from their memories
Find information without manually searching through scattered notes

The goal isn't to replace human memory. It's to create a digital extension of memory that helps people remember the details that matter.

Demo

Live Demo:
Watch the MemoryMate Demo

https://memorymate-frontend.onrender.com

The application is deployed as a full-stack application:

React Frontend → FastAPI Backend → MongoDB Atlas

Code

GitHub Repository:
https://github.com/himanshugangwar5752-demo/MemoryMate

Project Structure

MemoryMate/
│
├── frontend/
│   ├── src/
│   │   ├── components/
│   │   ├── pages/
│   │   ├── context/
│   │   └── services/
│   ├── package.json
│   └── vite.config.js
│
├── backend/
│   ├── app/
│   │   ├── api/
│   │   ├── core/
│   │   ├── database/
│   │   ├── schemas/
│   │   └── main.py
│   ├── tests/
│   └── requirements.txt
│
└── README.md

A small example of the backend API

from fastapi import APIRouter

router = APIRouter()

@router.get("/health")
async def health_check():
    return {
        "status": "healthy",
        "service": "MemoryMate"
    }

And the frontend communicates with the backend through a centralized API service:

const API_BASE_URL = import.meta.env.VITE_API_BASE_URL;

export const api = async (endpoint, options = {}) => {
  const response = await fetch(
    `${API_BASE_URL}${endpoint}`,
    {
      ...options,
      headers: {
        "Content-Type": "application/json",
        ...options.headers,
      },
    }
  );

  return response.json();
};

This separation keeps the frontend, backend, and AI functionality modular and makes the application easier to extend.

How I Built It

MemoryMate is a full-stack application built with:

Frontend

React
Vite
JavaScript
React Router

The frontend contains the main MemoryMate experience, including the dashboard, AI chat, memories, people, events, timeline, analytics, settings, and profile sections.

Backend

Python
FastAPI
Pydantic
REST APIs for application functionality and authentication

Database

MongoDB Atlas

MongoDB stores the persistent application data so memories aren't limited to a user's browser session.

AI

The AI component uses Gemma, an open-weight model.

Instead of treating the AI as a separate chatbot, MemoryMate is designed around the idea of connecting AI with the user's stored memories.

A simplified version of the concept looks like:

User
  ↓
MemoryMate UI
  ↓
FastAPI API
  ↓
Memory / Context Retrieval
  ↓
Gemma
  ↓
AI Response
  ↓
User

This architecture allows the AI experience to be built around the actual purpose of the application: helping users interact with their own memories.

Deployment

I deployed the project using:

Render → React frontend
Render → FastAPI backend
MongoDB Atlas → Database

Why Does Open Innovation Matter?

Open innovation mattered to this project because I wanted to understand what happens when AI is treated as a component that can be experimented with and adapted rather than simply calling a closed AI API.

Using an open-weight model such as Gemma gave me the opportunity to explore how an AI model can be integrated into a product built around a specific problem.

For MemoryMate, this is particularly interesting because the application deals with personal information.

Open models create possibilities for developers to experiment with:

Different inference providers
Custom AI workflows
Memory retrieval strategies
Prompt and context design
Future local or self-hosted inference

A closed API can make AI integration convenient, but open innovation gives developers more freedom to understand and control the technology underneath the application.

For me, the biggest takeaway was:

AI becomes much more interesting when it is built around a real human problem instead of being added just because a project needs AI.

My Agent Session

I used AI-assisted development throughout the project for:

Exploring the application architecture
Debugging frontend and backend issues
Improving the UI
Working through deployment problems
Iterating on features
Reviewing implementation decisions

Prize Categories

Render

MemoryMate is deployed on Render:

React frontend → Render Static Site
FastAPI backend → Render Web Service

The application uses MongoDB Atlas as its persistent database.

Final Thoughts

MemoryMate started with a simple question:

What if an AI assistant could help us remember the small things about the people and experiences that matter to us?

We already have tools for remembering tasks, passwords, appointments, and files.

MemoryMate explores a different kind of memory — human memory.

It's still an evolving project, but building it taught me that the most meaningful AI applications don't necessarily need to solve huge problems.

Sometimes, solving one small problem for one person is enough to build something worth sharing.

*Built for a friend. Built around memory. Built with open innovation. *

DEV Community: Himanshu Gangwar