ResolveIQ.AI: Building an AI Customer Support Agent That Actually Remembers

AI Customer Support That Remembers — built for the Hackathon theme “AI Agents That Learn Using Hindsight."

Most customer-support chatbots have one major limitation: they forget.

A customer can explain the same problem multiple times, across different conversations, and the AI may still behave as if it is meeting them for the first time.

We wanted to build something different.

Meet ResolveIQ.AI — an AI-powered customer support agent designed to remember useful customer context across conversations, combine that memory with company knowledge, understand customer intent and sentiment, and involve a human agent when necessary.

The core idea is simple:

Chat + Memory + Knowledge + Analysis + Escalation

The Problem

Imagine a customer contacts support:

«“My payment failed while using UPI.”»

The AI helps troubleshoot the issue.

A few days later, the same customer returns:

«“I am having the payment problem again.”»

A conventional chatbot may ask:

«“Could you please explain your payment issue?”»

ResolveIQ takes a different approach.

It retrieves relevant information from the customer's previous interaction, such as:

• Previous payment issue
• UPI usage
• Previous troubleshooting attempts
• Customer environment
• Whether the previous issue was resolved

The AI can then respond using that context rather than starting from zero.

That persistent memory is the key idea behind ResolveIQ.

How ResolveIQ Works

The complete workflow looks like this:

Customer Message
↓
Flask API
↓
Support Agent
↓
Retrieve Hindsight Memories
↓
Search Company Knowledge
↓
Analyze Intent / Sentiment / Urgency
↓
Generate Personalized Response
↓
Check Escalation Conditions
↓
Store Useful Memory
↓
Save Conversation in MySQL
↓
Return Response

The project uses Hindsight as the long-term AI memory layer, while MySQL handles structured application data.

What Makes Hindsight Important?

Hindsight isn't being used as a simple database.

It acts as the AI's long-term memory layer.

ResolveIQ can:

1. Store useful customer interaction information.
2. Recall relevant information during future conversations.
3. Personalize responses using previous interactions.
4. Remember previous troubleshooting attempts.
5. Recognize repeated unresolved problems.

This creates an important difference:

Traditional Chatbot
Customer → Question → Answer

ResolveIQ
Customer
↓
Previous Context
↓
Hindsight Memory
↓
Company Knowledge
↓
AI Analysis
↓
Personalized Response

The goal isn't simply to make the AI remember everything.

The goal is to make it remember useful information.

Hindsight + Company Knowledge

Memory alone isn't enough.

An AI support agent also needs reliable information about the company and its products.

ResolveIQ therefore includes a lightweight knowledge-base system using synthetic company support articles.

When a customer asks a question, the system performs:

User Question
↓
TF-IDF Vectorization
↓
Cosine Similarity
↓
Relevant Knowledge Articles
↓
Information Supplied to AI
↓
AI Response

This allows ResolveIQ to combine two important sources of context:

Hindsight Memory

Company Knowledge

The AI can therefore consider both the customer's history and the company's available support information.

Understanding the Customer

ResolveIQ doesn't only process the content of a message.

It also analyzes the customer's situation.

The system identifies:

Intent

Examples include:

• Payment issue
• Billing question
• Refund request
• Subscription change
• Account access
• Technical issue
• Product question
• Cancellation
• General question

Sentiment

The system can identify states such as:

• Positive
• Neutral
• Frustrated
• Angry
• Negative
• Urgent

Urgency

Messages are categorized into:

• Low
• Medium
• High

This information helps the support workflow understand not just what the customer is asking, but also the context surrounding the request.

When AI Should Stop and Ask for a Human

One of the important design decisions in ResolveIQ is that the AI isn't expected to solve everything.

Some situations should be escalated.

A support ticket can be created when:

• The issue has high urgency.
• The customer is angry.
• The customer explicitly asks for a human agent.
• Relevant knowledge coverage is missing.
• The same issue remains unresolved after repeated attempts.

Tickets contain information such as:

Ticket ID
Customer
Issue
Priority
Status
Reason

Possible statuses include:

open
in_progress
resolved
closed

This creates a complete workflow from AI conversation to human intervention.

MySQL vs Hindsight

One of the important architectural decisions was keeping operational data separate from AI memory.

MySQL

MySQL stores structured application information:

• Customers
• Conversations
• Messages
• Tickets

Hindsight

Hindsight stores useful AI context that can be recalled later:

• Previous customer problems
• Previous troubleshooting
• Customer preferences/context
• Unresolved issues

In short:

MySQL
= Application Data

Hindsight
= AI Memory

This separation makes the purpose of Hindsight much clearer in the overall architecture.

Technology Stack

ResolveIQ is built using a relatively lightweight stack.

Frontend

• HTML
• CSS
• JavaScript

Backend

• Python
• Flask

AI

• Groq
• "openai/gpt-oss-120b"

Memory

• Hindsight
• Hindsight Client

Database

• MySQL 8.0

Knowledge Retrieval

• scikit-learn
• TF-IDF
• Cosine similarity

Additional Python packages include "python-dotenv" and "mysql-connector-python".

The User Interface

The interface is designed around three major areas:

┌────────────────┬───────────────────────┬───────────────────┐
│ CUSTOMER │ AI SUPPORT CHAT │ AI MEMORY │
│ CONTEXT │ │ + KNOWLEDGE │
│ │ │ │
│ Profile │ Messages │ Hindsight │
│ Tickets │ AI responses │ memories │
│ Intent │ Input box │ Company KB │
│ Sentiment │ │ Escalation │
│ Urgency │ │ │
│ Summary │ │ │
└────────────────┴───────────────────────┴───────────────────┘

The goal is to make the memory component visible rather than hiding it behind the chatbot.

The visual direction focuses on a premium enterprise SaaS experience rather than a traditional college-project dashboard.

The most important visual story is:

MEMORY
+
KNOWLEDGE
+
ACTION

Our Demo Scenario

For the main demonstration, we use a customer named Rahul Mehta.

The key interaction is:

«“I am having the payment problem again.”»

Instead of treating this as a completely new conversation, ResolveIQ retrieves the relevant previous context.

During the demonstration, the interface can show:

• Recalled Hindsight memories
• Relevant company knowledge
• Personalized AI response
• Detected intent
• Sentiment
• Urgency
• Human escalation when necessary

This makes the value of persistent AI memory immediately visible.

Development Journey

ResolveIQ was developed in multiple phases:

Phase 1 → Flask Setup
Phase 2 → Hindsight Integration
Phase 3 → Groq Integration
Phase 4 → AI Support Agent + Memory Loop
Phase 5 → MySQL Integration
Phase 6 → Multi-turn Conversations
Phase 7 → Knowledge Base / RAG
Phase 8 → Intent + Sentiment + Urgency
Phase 9 → Ticket Creation + Escalation
Phase 10 → Dashboard + Memory + Summaries + Integration

The project handover reports that the Phase 10 test suite passed, including tests for Flask health, MySQL, Hindsight, Groq configuration, memory retrieval, knowledge search, AI analysis, ticket APIs, escalation, multi-turn memory, conversation history, and summaries.

What We Learned

Building ResolveIQ taught us that adding an LLM to a support application is only one part of building an AI agent.

A useful support agent needs several layers working together:

LLM
↓
Memory
↓
Knowledge
↓
Analysis
↓
Action

The memory layer becomes particularly important when conversations span multiple sessions.

Without memory:

«“Tell me your problem.”»

With memory:

«“I remember that you previously experienced a UPI payment failure and the earlier troubleshooting didn't resolve it.”»

That difference is what makes the interaction feel more continuous and personalized.

What's Next?

The next development priorities are:

• Finish the premium frontend redesign.
• Make Hindsight memory visually obvious.
• Make the demonstration easy to understand.
• Remove unnecessary developer/debug information.
• Test the complete workflow again.
• Prepare the 60-second hackathon demonstration.
• Prepare final project documentation.
• Clearly explain why Hindsight is necessary.

There is also an important deployment consideration: the development setup currently uses local MySQL and Hindsight services, so these services need an appropriate deployment strategy before the application is publicly deployed.

Final Thought

ResolveIQ isn't just another chatbot.

The idea is to create a support agent that can remember the customer, understand the situation, use company knowledge, and know when to involve a human.

The central concept can be summarized in one line:

«A normal chatbot forgets. ResolveIQ remembers.»

And that is the core of our project:

CHAT
+
MEMORY
+
KNOWLEDGE
+
ANALYSIS
+
ESCALATION

Together, these components turn a simple AI chat interface into a more complete customer-support workflow.

ResolveIQ.AI — AI Customer Support That Remembers.