Novasas Agent: Building an AI Support System That Actually Remembers Customers

Dhanalakshmi-bn — Tue, 19 May 2026 17:00:00 +0000

Artificial Intelligence has transformed modern customer support systems by enabling faster and smarter interactions. AI-powered assistants can now answer questions, automate workflows, and assist customers efficiently.

However, despite these advancements, most AI support systems still suffer from one major limitation:

They forget everything.

Traditional AI agents treat every conversation as a completely new interaction. Customers repeatedly explain the same issues, re-enter their details, and lose conversational context every time they return.

This creates:

repetitive conversations
poor customer experience
lack of personalization
inefficient support systems

So we built Novasas Agent, an AI-powered customer support system capable of remembering previous customer interactions and using contextual memory to provide personalized responses.

But instead of simply claiming our AI had memory, we designed a real-time side-by-side comparison dashboard to visually demonstrate the difference between:

AI without memory
AI with memory

This became the core concept of our project.

The Problem With Traditional AI Systems

Most AI support systems today work statelessly.
The workflow typically looks like this:

Customer asks a question
AI responds
Conversation ends
AI forgets everything

When the same customer returns later, the AI behaves as if it has never interacted with them before.
For example:

First Interaction
Customer:
"I was charged twice for my subscription this month."
AI:
"I’m sorry to hear that. Let me help you."
Follow-Up Interaction
Customer:
"I’m following up on my refund request."
Traditional AI:
"Can you explain your issue again?"

This makes customer support feel robotic and repetitive.

We wanted our AI system to behave more like a real support agent — one that remembers customers and understands previous conversations.

Our Solution: Novasas Agent

To visually demonstrate the impact of memory, we designed a dual-chat dashboard where both systems operate side-by-side in real time.

This allowed users to instantly compare how memory changes AI behavior.

Tech Stack Used

We built our project using:

Python
Groq API
GitHub
Hindsight API

For the language model, we used:

self.model = "llama-3.3-70b-versatile"

This model provided fast inference and clean conversational responses for our AI assistant.

Building the AI Support Agent

The backend of Novasas Agent was built entirely using Python.
The AI receives:

customer name
customer ID
customer issue and generates support responses using Groq-powered LLMs.

Initially, our memory system was implemented using a Python dictionary:
Python
self.customer_history = {}

This allowed the AI to temporarily store customer interactions during runtime.

Retrieving Customer Memory

One of the most important components of our project was retrieving previous customer interactions.
We implemented a memory retrieval function:

def get_customer_history(self, customer_id: str) -> str:
"""Get previous interactions for a customer"""

if customer_id in self.customer_history:
    history = self.customer_history[customer_id]
    return f"\nPrevious interactions with this customer:\n{history}"

return "\nThis is the customer's first interaction with us."

This allowed the AI agent to:

identify returning customers
retrieve earlier interactions
provide contextual responses

Saving Customer Interactions

To maintain conversational memory, we created a function that stores customer interactions dynamically.

def save_interaction(self, customer_id: str,
customer_name: str,
message: str,
response: str):

interaction = f"- {customer_name}: {message}\n Agent: {response}"

if customer_id not in self.customer_history:
    self.customer_history[customer_id] = ""

self.customer_history[customer_id] += interaction + "\n"

Every interaction gets appended to the customer’s history, enabling the AI to remember previous conversations.

Building the Memory-Enabled AI

Our memory-enabled support function retrieves customer history before generating a response.

def handle_support_request(self,
customer_name: str,
customer_id: str,
message: str) -> str:

customer_context = self.get_customer_history(customer_id)

The retrieved context is injected directly into the AI prompt.
This enables the model to:

recognize returning customers
recall earlier issues
generate more personalized support responses

Building the Stateless AI Version

To demonstrate the limitations of traditional AI systems, we also created a version without memory.

def handle_support_request_no_memory(
self,
customer_name: str,
customer_id: str,
message: str) -> str:

customer_context = "\nThis is the customer's first interaction with us."

Unlike the memory-enabled version, this system always treats users as completely new customers.

This comparison became one of the strongest parts of our project.
Designing the Dual-Chat Dashboard
Instead of building a simple chatbot interface, we wanted users to instantly understand the importance of AI memory.

So we created a dual-chat dashboard:
Left Side — With Memory

retrieves customer history
remembers previous interactions
provides personalized replies

Right Side — Without Memory

generic responses
no contextual understanding
stateless behavior

This side-by-side visual demonstration clearly shows how memory improves customer experience.

First Interaction

During the first interaction, both AI systems respond similarly because no previous context exists yet.

The customer reports a billing issue:

"I was charged twice for my subscription this month."

The memory-enabled system stores the interaction for future retrieval.

Second Interaction

When the customer returns later and asks:

"Following up on my refund for the double charges issue"

the difference becomes obvious.

With Memory

The AI remembers:

previous billing issue
transaction details
earlier conversation context and responds accordingly.

Without Memory

The AI treats the customer as completely new and asks for information again.
This visual comparison became the highlight of our project.

Challenges We Faced

Like most engineering projects, we encountered several technical challenges during development.

Memory Reset After Restart
Initially, customer memory was stored only in runtime variables.
Whenever the application restarted, all memory disappeared.
This meant the AI only had temporary conversational memory instead of true persistent memory.
API Handling
Handling API responses consistently was another challenge.
We had to carefully manage:

API calls
response formatting
conversation flow
contextual prompts to ensure smooth user interactions.

Why Persistent Memory Matters
Modern AI systems are becoming more conversational, but most still fail to maintain long-term context.
Persistent memory can significantly improve:

customer support
AI assistants
educational chatbots
productivity systems

By enabling AI systems to remember previous interactions, users receive:

personalized responses
smoother conversations
reduced repetition
more human-like interactions

Our project demonstrates how even simple memory systems can dramatically improve AI behavior.

Future Improvements

Although our current prototype works successfully, we plan to improve the project further with:

Multi-user authentication
Voice-based support
Advanced memory databases
Cloud deployment
Long-term semantic memory
Smarter retrieval systems

These upgrades would make the system more scalable and production-ready.

Final Thoughts

One of the biggest weaknesses of traditional AI systems is their inability to maintain memory and context across interactions.

With Novasas Agent, our goal was to demonstrate how persistent memory can improve customer support experiences in a simple yet impactful way.

By visually comparing AI systems with and without memory, we were able to clearly show why contextual AI matters.

This project taught us that AI should not just respond.

AI should remember.

Because memory is what makes interactions feel intelligent, personal, and human.

DEV Community: Dhanalakshmi-bn

Novasas Agent: Building an AI Support System That Actually Remembers Customers