What If Your Meeting Assistant Could Remember What You Forgot?

Debasmita Sahoo — Mon, 28 Sep 2026 14:50:42 +0000

When a meeting ends, the conversation is usually easy to forget.
The difficult part is remembering what was promised, what remained unresolved, what a client cared about, and what should matter when the same project comes up again.
Most meeting tools can summarize what happened. But a summary is only useful if someone goes back and reads it. When the next meeting arrives, people still have to search through previous discussions, remember pending tasks, and figure out what deserves attention.
That led us to a simple question:
What if a meeting assistant could actually remember what mattered from previous meetings and use that memory to prepare you for the next one?
That is the idea behind RecallMeet.
RecallMeet is an AI-powered meeting memory and preparation assistant that analyzes meetings, extracts commitments and unresolved issues, maintains project context, generates preparation briefings, and learns from user feedback using long-term memory.

The Problem: Meetings Don't Exist in Isolation
A meeting rarely exists as a standalone conversation.
A discussion today can create commitments for next week, raise concerns that need to be revisited, or leave important questions unanswered.
For example, during an API integration meeting, a team might discuss:
• Authentication testing
• Budget constraints
• Project scope
• Rollout timelines
• API documentation
• Client concerns
A normal meeting summary might tell you that these topics were discussed.
But before the next meeting, you need more than a summary.
You need to know:
What is still pending?
Who is responsible?
What concerns should be addressed?
What questions should I ask?
What did I previously tell the AI to prioritize?
This is where conventional meeting summarization falls short.

From Meeting Summaries to Meeting Memory
We designed RecallMeet around a continuous workflow:
Meeting → Remember → Prepare → Feedback → Learn → Prepare Better
Instead of treating every meeting as a new conversation, RecallMeet maintains project-level context.
The system analyzes a meeting and extracts useful information such as commitments, unresolved issues, and client concerns. That information becomes part of the project's context.
When the user needs to prepare for another meeting, RecallMeet retrieves the relevant information and generates a personalized briefing.
The user can then provide feedback about what was useful or what needed more attention.
That feedback becomes long-term memory and can influence future preparation.
The goal is simple: the assistant should become more relevant to the user over time.

How RecallMeet Works
The system can be understood through four major stages.

Analyze the Meeting The first step is converting an unstructured meeting transcript into useful project information. For our Apollo API Integration demonstration, the meeting discussion contained topics such as authentication testing, budget constraints, scope alignment, rollout timelines, and client concerns. RecallMeet's AI analysis extracted actionable information from the discussion. It identified commitments such as: • Sending the complete API documentation • Following up with the client about budget constraints and rollout timelines It also identified unresolved issues including: • Client budget confirmation • Scope alignment • Authentication testing • Rollout timeline • Implementation support and documentation This turns a long conversation into structured information that can be reused later.

Figure 1. AI-generated analysis of the Apollo API Integration Kickoff meeting, showing the meeting summary, extracted commitments, and unresolved issues.

Maintain Project Memory
Once meeting information has been extracted, it needs to remain available for future interactions.
RecallMeet organizes meeting information around projects. This allows the system to connect previous meetings, commitments, and unresolved issues rather than treating every meeting independently.
The application uses PostgreSQL for structured application data such as users, projects, meetings, participants, commitments, issues, and feedback.
For long-term contextual memory, RecallMeet integrates Hindsight.
This separation is useful because structured application information and long-term contextual memory serve different purposes.
PostgreSQL manages the application's persistent data, while Hindsight helps retain information that can influence future AI interactions.
Prepare Me: Turning Memory Into Action
Remembering information is useful, but the real purpose of memory is to make the next interaction better.
RecallMeet provides a Prepare Me feature that combines information from previous meetings, pending commitments, unresolved issues, project context, and long-term memory.
Instead of asking the user to manually review everything from the previous meeting, the system generates a personalized briefing.
The preparation includes information such as:
• Meeting context
• Key things to know
• Open issues
• Commitments to follow up
• Client concerns
• Questions to ask
• Recommended areas of focus
For the Apollo project, the initial briefing highlighted authentication testing, budget constraints, scope alignment, rollout timeline, documentation, and client concerns.

Figure 2. AI-generated personalized meeting preparation for the Apollo project, synthesizing previous meeting context, commitments, and unresolved issues.

Teaching the Assistant What Matters This is where RecallMeet becomes more than a meeting summarizer. After reading the preparation, the user can provide feedback. For our Apollo demonstration, the user indicated that the client's budget concern and project scope required greater emphasis. The feedback was not simply stored as temporary information. It was saved in PostgreSQL and committed into Hindsight long-term memory. This means that the feedback could influence the next preparation generated for the same project.

Figure 3. Confirmation that user feedback was stored in Hindsight long-term memory for subsequent meeting preparation.

The Interesting Part: Prepare Again
After the feedback was stored, we generated the preparation again.
This time, the briefing placed stronger emphasis on the areas identified by the user.
The updated preparation highlighted:
• Client budget constraints
• Budget approval
• Scope alignment
• Possible scope adjustments
• Authentication testing
• Rollout timeline
• Implementation support and documentation
For example, the updated briefing included questions around whether features needed to be reduced or reprioritized to fit the client's budget.
This demonstrated the central idea behind RecallMeet:
The assistant doesn't just remember the meeting. It remembers what the user wants the assistant to pay attention to.

Figure 4. Updated AI-generated preparation after feedback, emphasizing budget constraints, scope alignment, client confirmation, and unresolved concerns.

How We Built It
RecallMeet was implemented as a web-based application using several technologies.
Frontend
The frontend provides the interface for:
• Authentication
• Project management
• Meeting management
• Meeting analysis
• Preparation generation
• Feedback
The frontend is deployed using Vercel.
Backend
The backend was implemented using Python and FastAPI.
It handles:
• Authentication
• Project and meeting operations
• AI analysis
• Preparation generation
• Feedback processing
• Database operations
• Hindsight interactions
The backend is deployed using Render.
Database
PostgreSQL is used for structured application data, including projects, meetings, commitments, issues, and feedback.
AI Layer
Groq provides the large language model layer used for meeting analysis and preparation generation.
Long-Term Memory
Hindsight provides the long-term memory layer.
It allows user feedback and relevant contextual information to be retained and used in future preparation.
The Architecture
At a high level, the system follows this flow:

The important part of the architecture is that the AI generation layer is not isolated from the application's stored context.
The preparation process can use both structured project information and long-term memory to generate a more relevant briefing.

What We Achieved
The Apollo demonstration allowed us to test the complete workflow from beginning to end.
First, RecallMeet analyzed the meeting and extracted commitments and unresolved issues.
Then, it generated an initial preparation briefing.
The user provided feedback indicating that budget and project scope needed greater emphasis.
That feedback was stored in Hindsight.
Finally, a new preparation was generated, and the system placed greater emphasis on budget, scope alignment, client confirmation, and unresolved concerns.
The important result was not simply that the AI generated another preparation.
The important result was that the preparation changed based on the user's previous feedback.
This demonstrated the intended memory-learning cycle:

Why This Matters
A meeting assistant does not become significantly more useful simply by producing longer summaries.
The more interesting challenge is continuity.
What happened before?
What is still unresolved?
What does the user care about?
What should receive more attention next time?
RecallMeet approaches this problem by connecting meeting analysis with persistent project context and long-term user feedback.
This creates a shift from:
“Here is what happened in your meeting.”
to:
“Here is what you need to remember and focus on before your next meeting.”

Potential Applications
The same approach can be extended beyond the current implementation.
Future versions of RecallMeet could include:
• Calendar integration
• Automatic meeting recording and transcription
• Zoom or Google Meet integration
• Automated email follow-ups
• Commitment reminders
• Deadline tracking
• Slack or Microsoft Teams integration
• Speaker identification
• Concern tracking
• Cross-project organizational memory
• Meeting-to-meeting progress tracking
These extensions could make the system useful for teams that conduct recurring meetings and need continuity across long-running projects.

Conclusion

RecallMeet was built around a simple idea: important meeting information should not disappear when the meeting ends.
The system combines AI-based meeting analysis, structured project data, personalized preparation, user feedback, and long-term memory to create a continuous meeting workflow.
The Apollo demonstration showed the complete cycle. A meeting was analyzed, a preparation briefing was generated, the user provided feedback, that feedback was stored in Hindsight, and a subsequent preparation placed greater emphasis on the areas identified by the user.
The project therefore moves beyond conventional meeting summarization toward a system that can remember context, learn from feedback, and use that memory to prepare users for what comes next.
And that brings us back to the original question:
What if your meeting assistant could remember what you forgot?
With RecallMeet, that's exactly what we set out to build.

See RecallMeet in Action
Watch the complete demo of RecallMeet:

https://youtu.be/xuQOZrfyWJU

The complete source code is available on GitHub:

https://github.com/Ho436-art/RecallMeet

DEV Community: Debasmita Sahoo

What If Your Meeting Assistant Could Remember What You Forgot?