Meet Mind

Tejashwini Dathurka — Tue, 29 Sep 2026 17:27:03 +0000

Introduction

Have you ever entered a meeting and struggled to remember what was discussed in the previous conversation?

Important details such as requirements, concerns, preferences, and follow-ups can easily get lost between meetings. Even when that information exists somewhere, finding the right context at the right time can be difficult.

That problem inspired me to build MeetMind, an AI-powered meeting assistant that uses persistent memory to help users prepare for meetings.

For this hackathon, I wanted to explore a simple question:

What if an AI assistant could remember previous conversations and use that memory to prepare you for the next meeting?

MeetMind combines Hindsight for persistent memory, Groq for AI generation, FastAPI for the backend, and a web frontend to create this workflow.

Instead of starting every meeting from scratch, MeetMind retrieves relevant memories about a contact and turns them into a structured meeting brief.

The Problem

Meetings often depend on information from previous conversations.

For example, during a previous discussion, a customer might mention:

A specific requirement
A concern about implementation
A preferred approach
A question they want answered later

When the next meeting arrives, remembering all of these details can be difficult.

Users may have to search through old notes, messages, or documents before the meeting even begins.

I wanted to solve this problem by giving the application a persistent memory layer.

The Idea

MeetMind is a memory-powered AI meeting assistant.

The workflow is:

Previous Conversations
↓
Persistent Memory
↓
Relevant Memories Retrieved
↓
AI Generates Meeting Context
↓
Structured Meeting Brief
↓
User Prepares for Meeting

The important part is that the AI isn't generating a meeting brief from nothing. It first receives relevant information retrieved from previous conversations.

How MeetMind Works

The application has three main stages.

Store Memories

Meeting information is retained using Hindsight.

For example:

Met with Sarah Connor regarding a security audit.
She requested a follow-up on quantum encryption algorithms next week.

This information can later be associated with the contact and recalled when needed.

Recall Memories

When a user wants to prepare for a meeting, they select a contact.

MeetMind then requests the relevant memories for that contact from Hindsight.

This gives the application context about previous conversations.

Generate the Meeting Brief

The recalled memories are passed to Groq.

The model generates a structured brief containing:

Previous Discussions
Important Concerns
Preferences
Requirements
Open Follow-ups
Suggested Talking Points

This makes the information easier to understand before the meeting.

Technology Stack
Hindsight

Hindsight is used as the persistent memory layer.

It allows MeetMind to retain and recall information from previous interactions.

Groq

Groq is used for the LLM generation layer.

The recalled memories are provided as context, and the model generates the structured meeting brief.

FastAPI

FastAPI is used as the backend framework.

It connects the frontend with Hindsight and Groq and handles the meeting preparation workflow.

Frontend

The frontend provides the interface for viewing contacts, exploring memories, selecting a contact, and generating a meeting brief.

Architecture

The basic architecture is:

User
↓
MeetMind Frontend
↓
FastAPI Backend
↓
Hindsight
↓
Recall Relevant Memories
↓
Groq
↓
Generate Meeting Brief
↓
Frontend
↓
User

Hindsight and Groq have separate responsibilities.

Hindsight provides the memory.

Groq uses that memory to generate the meeting brief.

FastAPI connects the different parts of the application.

Keeping the AI Grounded

One of the biggest challenges I encountered was hallucination.

An LLM can sometimes generate information that sounds reasonable even when that information wasn't actually present in the source context.

For a meeting assistant, this can be problematic.

If a customer never mentioned a particular requirement, the system shouldn't present that requirement as something the customer actually said.

Because of this, I designed the generation prompt to keep the output grounded in the recalled Hindsight memories.

The model is instructed not to invent, assume, or add facts that aren't present in the retrieved context.

If there isn't enough information for a particular section, the application can return:

No specific information found in memory.

This was one of the most important lessons from the project.

A useful AI application isn't only about generating good text. It also needs to control what the model is allowed to claim.

The User Interface

MeetMind includes a Contacts & Memory interface where users can view memories associated with contacts.

Each memory can display information such as:

Memory type
Memory content
Date information
Tags

The goal was to make the memory layer visible and understandable instead of hiding everything behind the API.

After selecting a contact, the user can generate a meeting brief using the available memories.

Example

Suppose a previous conversation contains information about a customer's implementation requirements.

MeetMind can transform the available memory into a structured preparation brief:

Meeting Brief

Previous Discussions

Discussed implementation timeline
Discussed onboarding and support

Important Concerns

Onboarding complexity
Support requirements

Preferences

Annual billing
Simple onboarding process

Requirements

Enterprise support information

Open Follow-ups

Provide additional support information

Suggested Talking Points

Confirm onboarding process
Review implementation timeline
Discuss support options

The key principle is that these sections should be supported by the information actually available in memory.

Backend Structure

The backend is organized into separate components:

backend/
│
├── main.py
├── hindsight_service.py
├── groq_service.py
├── requirements.txt
└── .env

main.py contains the FastAPI application and API endpoints.

hindsight_service.py handles communication with Hindsight for storing and recalling memories.

groq_service.py handles communication with Groq and generates the meeting brief.

Environment variables are used for API credentials so that keys aren't hard-coded into the application.

Challenges

The project involved several challenges.

The first was connecting multiple services into one reliable workflow.

The application needs to move information through:

Frontend
↓
FastAPI
↓
Hindsight
↓
Memory Retrieval
↓
Groq
↓
Generated Brief
↓
Frontend

Another challenge was making sure the AI output remained grounded in the retrieved information.

I also spent time improving the interface so that raw memories and generated meeting briefs were easier to understand.

What I Learned

This project taught me that building an AI application isn't only about choosing an LLM.

The overall system depends on:

Data
↓
Memory
↓
Retrieval
↓
Context
↓
Prompt
↓
LLM
↓
User Interface

Every part affects the final result.

I also learned how important persistent memory can be for applications that need information from previous interactions.

Most importantly, I learned that grounding matters.

An answer that sounds convincing isn't necessarily an accurate answer. For applications involving requirements, follow-ups, and previous conversations, the system needs to distinguish between information that is actually known and information that has simply been generated by the model.

Future Improvements

There are several features I would like to explore next:

Automatic meeting transcript ingestion
Calendar integration
Automatic post-meeting memory creation
Follow-up reminders
Contact timelines
Better memory retrieval based on meeting topics
User controls for correcting or removing memories
More detailed meeting history

The longer-term workflow could look like:

Before Meeting
↓
Recall Relevant Context
↓
Generate Meeting Preparation
↓
Have Meeting
↓
Capture New Information
↓
Store New Memories
↓
Next Meeting
↓
Better Context

This creates a continuous memory loop where each meeting can provide useful context for future meetings.

Conclusion

MeetMind started with a simple question:

What if your meeting assistant could actually remember?

By combining persistent memory through Hindsight with LLM-powered generation through Groq, I built a prototype that can retrieve previous conversation context and turn it into structured meeting preparation.

The biggest lesson I took from this project is that good AI isn't only about generating good answers.

It is also about providing the right context, retrieving useful information, keeping the model grounded, and presenting the result in a way that helps the user.

MeetMind is my exploration of what a memory-powered AI assistant could look like in a practical meeting workflow.

DEV Community: Tejashwini Dathurka

Meet Mind