Memory-Powered Support Agent

Build a support assistant that keeps past tickets and resolutions at its fingertips.

You can create a personalized Customer Support AI Agent using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

Overview

The Customer Support AI Agent leverages Mem0 to retain information across interactions, enabling a personalized and efficient support experience.

Setup

Install the necessary packages using pip:

pip install openai mem0ai

Full Code Example

Below is the simplified code to create and interact with a Customer Support AI Agent using Mem0:

import os
from openai import OpenAI
from mem0 import Memory

# Set the OpenAI API key
os.environ['OPENAI_API_KEY'] = 'sk-xxx'

class CustomerSupportAIAgent:
    def __init__(self):
        """
        Initialize the CustomerSupportAIAgent with memory configuration and OpenAI client.
        """
        config = {
            "vector_store": {
                "provider": "qdrant",
                "config": {
                    "host": "localhost",
                    "port": 6333,
                }
            },
        }
        self.memory = Memory.from_config(config)
        self.client = OpenAI()
        self.app_id = "customer-support"

    def handle_query(self, query, user_id=None):
        """
        Handle a customer query and store the relevant information in memory.

        :param query: The customer query to handle.
        :param user_id: Optional user ID to associate with the memory.
        """
        # Start a streaming chat completion request to the AI
        stream = self.client.chat.completions.create(
            model="gpt-5-mini",
            stream=True,
            messages=[
                {"role": "system", "content": "You are a customer support AI agent."},
                {"role": "user", "content": query}
            ]
        )
        # Store the query in memory
        self.memory.add(query, user_id=user_id, metadata={"app_id": self.app_id})

        # Print the response from the AI in real-time
        for chunk in stream:
            if chunk.choices[0].delta.content is not None:
                print(chunk.choices[0].delta.content, end="")

    def get_memories(self, user_id=None):
        """
        Retrieve all memories associated with the given customer ID.

        :param user_id: Optional user ID to filter memories.
        :return: List of memories.
        """
        return self.memory.get_all(filters={"user_id": user_id})

# Instantiate the CustomerSupportAIAgent
support_agent = CustomerSupportAIAgent()

# Define a customer ID
customer_id = "jane_doe"

# Handle a customer query
support_agent.handle_query("I need help with my recent order. It hasn't arrived yet.", user_id=customer_id)

Fetching Memories

You can fetch all the memories at any point in time using the following code:

memories = support_agent.get_memories(user_id=customer_id)
for m in memories['results']:
    print(m['memory'])

Key Points

• Initialization: The CustomerSupportAIAgent class is initialized with the necessary memory configuration and OpenAI client setup.
• Handling Queries: The handle_query method sends a query to the AI and stores the relevant information in memory.
• Retrieving Memories: The get_memories method fetches all stored memories associated with a customer.

Conclusion

As the conversation progresses, Mem0’s memory automatically updates based on the interactions, providing a continuously improving personalized support experience.

---

Build a Mem0 Companion

Master the foundational patterns for building memory-powered assistants.

Email Automation with Mem0

Extend support capabilities with intelligent email processing and routing.

Using Mem0? Star us on GitHub to help more developers discover memory for AI apps.