I Built a Feedback Intelligence System That Remembers What Users Said
User feedback is everywhere: reviews, complaints, feature requests, surveys, ratings, and support conversations.
The difficult part isn't collecting that feedback.
The difficult part is understanding what it means over time.
While building our User Feedback Synthesizer, we wanted to create a system that could collect feedback, analyze it, identify patterns, and let users interact with those insights through an AI agent.
But we also wanted to solve a more interesting problem:
Could the AI connect what users are saying now with what they said before?
That question led us to add long-term memory using Hindsight.
Our Approach
Our system combines several components into one feedback intelligence workflow:
User Feedback
↓
FastAPI Backend
↓
┌─────────────────────────┐
│ PostgreSQL │ → Structured feedback
│ Hindsight │ → Historical memory
│ AI / LLM │ → Analysis & reasoning
└─────────────────────────┘
↓
Combined Context
↓
AI Insights / Analytics / Chat
↓
React + Vite Interface
The frontend provides the dashboard, feedback exploration, analytics, AI insights, and chat experience.
The FastAPI backend connects the application components and handles the API layer.
PostgreSQL provides structured and persistent storage for feedback.
The AI layer analyzes feedback for things such as sentiment, themes, summaries, priorities, and important signals.
Hindsight adds another layer: memory.
Instead of treating every feedback entry as an isolated record, the system can retain useful information and later recall relevant historical context.
Why Memory Matters
Consider three feedback entries:
January
"Payment sometimes fails during checkout."
February
"The payment page is slow and occasionally fails."
March
"Payment failed again after the latest update."
Individually, these are three complaints.
Together, they may point toward a recurring payment-related problem.
A feedback intelligence system should be able to make that historical connection.
That is where memory becomes useful.
RETAIN → RECALL
We implemented a simple memory flow:
New Feedback
↓
RETAIN
↓
Hindsight Memory
↓
RECALL
↓
Historical Context
↓
AI Agent
↓
Contextual Insight
When useful feedback is received, we retain it in a Hindsight memory bank.
When a new question or feedback item requires historical context, we recall relevant memories and use them as input for the AI agent.
According to Hindsight's documentation, retain() is used to process and store information as searchable memories, while recall() retrieves relevant memories for a query.
The Core Implementation
This is the main part of our implementation:
def retain_feedback(feedback: str, user_id: str = "anonymous"):
client = get_client()
content = (
f"User ID: {user_id}\n"
f"Feedback: {feedback}"
)
client.retain(
bank_id=BANK_ID,
content=content
)
client.close()
def recall_feedback(query: str):
client = get_client()
result = client.recall(
bank_id=BANK_ID,
query=query
)
return [
{
"type": memory.type,
"text": memory.text
}
for memory in result.results
]
The important part isn't simply saving feedback.
It's being able to bring relevant information back when it becomes useful.
From Feedback to AI Insight
Memory is only one part of the system.
The complete workflow starts when feedback enters the application.
The backend processes it and stores the structured information. The AI analyzes the feedback and extracts useful signals such as sentiment and themes.
Relevant information can also be retained in Hindsight.
Later, when a user asks something through the AI interface, the system can combine:
Current Question
+
Structured Feedback
+
Relevant Historical Context
↓
AI Agent
↓
AI Insight
The AI can then use that context to generate an insight.
This allows the system to move beyond simply answering:
"What did users say?"
toward questions such as:
"Is this issue appearing repeatedly?"
or:
"Does this feedback connect to something users reported earlier?"
Before vs. After Memory
| Before Memory | After Memory |
|---|---|
| The agent mainly depended on the information available in the current interaction. | Relevant historical information can be recalled when needed. |
| Historical feedback existed but wasn't necessarily part of the agent's immediate context. | Historical context can be supplied to the AI during analysis. |
| Each interaction could be treated independently. | Current questions can be connected with relevant previous information. |
For example, if users previously reported problems with a particular feature, a later question about that feature can bring those earlier concerns into the context.
The goal isn't to make the AI remember everything.
The goal is to make relevant history available when it matters.
What the User Sees
All of this complexity stays behind the application interface.
From the user's perspective, they can:
- Explore the feedback dashboard
- View feedback records
- Analyze sentiment and themes
- Explore trends and important issues
- View AI-generated insights
- Ask questions through the AI chat
The project connects these experiences into one workflow:
Feedback
↓
Analysis
↓
Memory
↓
Context
↓
AI Insight
Our interface is built with React and Vite, while FastAPI connects the frontend with the backend services and data layer.
The overall project architecture combines these components with PostgreSQL and Hindsight.
The Engineering Challenge
One of the most interesting parts of adding memory was realizing that memory is not just storage.
The real questions are:
- What information is worth retaining?
- What information should be recalled for a particular query?
- How much historical context should reach the AI?
- How do we avoid irrelevant memories creating noise?
If everything is treated as equally important, the memory layer can become less useful.
That means memory needs to be considered as part of the application's architecture, not simply as another API call.
What I Learned
This project changed the way I think about AI agents.
Before working on this, it was easy to think of an AI agent mainly as:
Input
↓
AI Model
↓
Response
With memory, the architecture becomes more interesting:
Input
↓
Retrieve Relevant History
↓
Combine Context
↓
AI
↓
Response
That additional layer can change how an agent interacts with information over time.
I also learned that different technologies have different responsibilities:
| Technology | Responsibility |
|---|---|
| React / Vite | User experience and interface |
| FastAPI | Application and API layer |
| PostgreSQL | Structured feedback storage |
| AI / LLM | Feedback analysis and insight generation |
| Hindsight | Long-term retention and recall |
| Git / GitHub | Version control and project collaboration |
The value comes from making these pieces work together rather than treating them as isolated technologies.
One Important Lesson
We deliberately did not add accuracy percentages or performance claims that we had not measured.
For a project like this, it is tempting to say that memory makes the system "X% better."
But without a proper evaluation setup, that would just be a number.
Instead, we focused on demonstrating the actual workflow:
Feedback
↓
Analysis
↓
Retention
↓
Historical Recall
↓
Context
↓
AI Insight
That made the result much more meaningful to us.
Final Takeaway
The central idea behind our User Feedback Synthesizer is simple:
Feedback shouldn't have to start from zero every time.
A complaint received today may be related to something users reported weeks earlier.
By combining structured feedback, AI analysis, and long-term memory, we built a system that can connect current information with relevant historical context.
For me, the most interesting part wasn't simply integrating another AI service.
It was understanding how memory changes the architecture of an AI application.
The journey became:
Collect
↓
Analyze
↓
Retain
↓
Recall
↓
Understand
And that is what turns a collection of feedback records into something much closer to context-aware feedback intelligence.
Technologies Used
React • Vite • FastAPI • PostgreSQL • Python • AI/LLM • Hindsight • Git/GitHub
Top comments (0)