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

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

Our team wanted to solve this problem.

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:
Python
"I was charged twice for my subscription this month."
AI:
Python
"I’m sorry to hear that. Let me help you."

Follow-Up Interaction
Customer:
Python
"I’m following up on my refund request."

Traditional AI:
Python
"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 solve this issue, we developed two separate AI systems:
Without Memory
With Memory

• Generic responses
• Personalized responses
• No contextual awareness
• Context-aware support
• Stateless interactions
• Persistent customer history

Treats every chat as new
Remembers previous issues
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
For the language model, we used:
Python
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:
Python

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.

Python
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.

Python
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.
Python

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

r

• etrieves 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:

Plain text
"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:
Plain text

"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.

1. 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.

2. 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.