Durga Bhavani Paleti

Posted on Sep 30

I Built FeedbackMind AI So Customer Feedback Wouldn’t Be Forgotten

#ai #buildinpublic #product #startup

Using Groq and Hindsight to turn scattered feedback into product memory

Introduction
When I started building FeedbackMind AI, I kept coming back to one simple problem: customer feedback is everywhere, but it is easy to forget what happened before.
A product team may receive one complaint today, another similar complaint next week, and a positive comment after a product change. If these messages are treated separately, it becomes difficult to understand the complete story.
I wanted to build a system that could remember this history and use it when a new question was asked.
That became FeedbackMind AI, a User Feedback Synthesizer built using Groq and Hindsight.
The main idea is simple: instead of treating every feedback item as an isolated message, the system gives customer feedback persistent memory.

The Problem I Wanted to Solve

Customer feedback can come in many forms: app reviews, support tickets, emails, surveys, and social media comments.

Analyzing one feedback item is relatively easy. The harder problem is understanding how different feedback items are connected across time.

For example, imagine a customer reports:

“The checkout page freezes when I try to pay using my mobile phone.”

By itself, this is one complaint.

But suppose there were several earlier complaints about checkout problems. A useful product intelligence system should be able to connect the new complaint with that historical information.

That was the problem I wanted to solve.

Instead of asking an AI system to analyze only the latest feedback, I wanted the application to remember previous feedback and bring relevant history back when needed.

What Is FeedbackMind AI?

FeedbackMind AI is a User Feedback Synthesizer that helps analyze customer feedback and identify patterns over time.

A feedback record can contain information such as:

Feedback message
Source
Product area
Rating
Date

The application analyzes feedback using Groq **and uses **Hindsight as the persistent agent memory layer.

The overall workflow is:

Customer Feedback → Groq Analysis → Hindsight RETAIN → Persistent Memory → Hindsight RECALL → Groq Reasoning → Product Insight

This allows the application to move from simply analyzing feedback to using historical feedback as context.

Why I Used Hindsight

The most important part of the project is the memory layer.

Hindsight allows the application to retain information and recall it later.

When new feedback is processed, important information can be stored using RETAIN.

Later, when a product-level question is asked, relevant information can be retrieved using RECALL.

This means the application does not have to treat every question as completely new.

For example:

Before persistent memory:

A question such as:

_“What are the most common problems customers are experiencing?”
_
would depend mainly on the information included in the current request.

After adding Hindsight:

The application can recall previously retained feedback and use that information when generating the answer.

The important change is not simply storing more information. It is making previous feedback useful for future questions.

How the Memory Flow Works

I kept the Hindsight integration on the server side so that API credentials are not exposed in the browser.

The core memory pattern in the application is:
_ await hindsight.retain({
bankId,
content: feedbackMemory
});

  const memories = await hindsight.recall({
     bankId,
     query: userQuestion
  });_

The recalled information is then provided to the language model so that the final response can be grounded in previous feedback.

Important: Before publishing, replace the short example above with the exact RETAIN/RECALL code from your current server/hindsight.ts if you want the article to show the verbatim project implementation.

Before Memory vs. After Memory

The difference becomes clearer with an example.

Suppose the system receives:

“The checkout page freezes when I try to pay using my mobile phone.”

The feedback can be analyzed as a **Mobile Checkout **issue and retained in Hindsight.

Later, a product manager asks:

“What are the most common problems customers are experiencing?”

Instead of looking only at the latest message, the application can recall relevant historical feedback.

The result can therefore contain a broader picture of recurring problems.

Before

New question → Analyze current information → Answer

After

New question → Hindsight RECALL → Historical feedback → Groq reasoning → Grounded answer

This was one of the most important differences I observed while building the project.

Asking the Product's Memory

One of the main features I built is Ask Product Memory.

Instead of asking the application to analyze one feedback message, users can ask product-level questions such as:
_

“What are the most common problems customers are experiencing?”
“Has checkout been a recurring problem?”
“What problems are emerging?”_

The application first recalls relevant information from Hindsight.

Groq then uses the recalled context to synthesize the response.

This creates a workflow where memory directly influences the reasoning process.

Emerging Issue Radar

FeedbackMind AI also includes an *Emerging Issue Radar.
*
Reading every feedback item individually can make it difficult to notice patterns.

The Emerging Issue Radar groups feedback into recurring themes and helps surface issues that are beginning to appear.

This gives the user another way to understand the feedback history without manually reading every record.

*Feedback Time Machine
*
Another feature is the *Feedback Time Machine.
*
Feedback becomes more useful when it can be connected with changes made to the product.

The Time Machine allows feedback to be viewed around product milestones so that users can compare what was happening before and after a change.

For example, if customers repeatedly reported a particular problem before a product update, historical feedback can provide context for understanding what happened around that change.

Making Hindsight Memory Visible

I also wanted the memory layer to be visible instead of hiding it completely behind the final AI answer.

For this reason, FeedbackMind AI includes a Memory Explorer.

It helps show how feedback moves through the system:

Feedback → Groq Analysis → Hindsight RETAIN → Persistent Memory → Hindsight RECALL → Related Context → Product Insight

This made it easier for me to understand what was happening inside the application and demonstrate why memory is important.

Data Used in the Demonstration

The current demonstration uses realistic synthetic feedback data rather than claiming to represent a real production customer dataset.

The project contains seeded feedback records and product milestones so that the application can demonstrate patterns across different points in time.

The current interface also provides different feedback source categories, but these are manual ingestion categories rather than live connections to every external feedback platform.

What I Learned

The biggest lesson I learned is that adding memory is not simply adding another database.

The important questions are:

What information should become memory?
and
When should that memory be recalled?

For FeedbackMind AI, Hindsight becomes useful when a new question depends on historical feedback.

I also learned the importance of keeping API keys on the server and using environment variables rather than exposing secrets in frontend code.

Another practical lesson was that the quality of the final insight depends on the quality and consistency of the feedback being retained.

Limitations and Next Steps

FeedbackMind AI is currently a prototype.

It does not directly pull live feedback from every app store, support system, email platform, or social network. The current version demonstrates the memory workflow using manually entered feedback categories and synthetic demonstration data.

If I continue developing the project, I would like to add:

Authenticated feedback-platform connectors
Better controls for reviewing retained memories
Stronger evaluation of recalled context
Richer product-event information
More tools for correcting or reviewing memory

Conclusion

FeedbackMind AI started with a simple question:

*What if customer feedback didn't have to be forgotten?
*
Groq handles the language analysis, while Hindsight provides the persistent memory layer.

With Hindsight RETAIN, important feedback becomes part of the application's memory. With Hindsight RECALL, relevant historical information can be brought back when a new product question is asked.

The result is a workflow that can connect feedback across time, identify recurring issues, and provide historical context for product decisions.

For me, the most interesting part of this project was seeing the difference between an AI system that simply analyzes feedback and an AI system that can remember feedback and use that history later.

That is the idea behind FeedbackMind AI.