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.
Top comments (0)