Memory Management in LLM Apps

Build intelligent LLM applications with persistent memory using Mem0 and vector stores

Overview

Memory management enables LLM applications to maintain context across conversations, remember user preferences, and provide personalized experiences. This guide covers implementation patterns using Mem0 with Qdrant vector store.

Core Concepts

Persistent Memory

Store and retrieve conversation history across sessions using vector databases

User-Specific Context

Maintain separate memory spaces for each user with personalized preferences

Memory Retrieval

Semantic search through past interactions to provide relevant context

Multi-LLM Support

Share memory across different language models (GPT-4, Claude, Llama)

Memory Architecture

Configuration with Mem0 and Qdrant

OpenAI Configuration

import os
from mem0 import Memory
from openai import OpenAI

# Initialize Mem0 with Qdrant
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "model": "gpt-4o-mini",
            "host": "localhost",
            "port": 6333,
        }
    },
}

memory = Memory.from_config(config)
openai_client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])

from mem0 import Memory
from litellm import completion

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "collection_name": "local-chatgpt-memory",
            "host": "localhost",
            "port": 6333,
            "embedding_model_dims": 768,
        },
    },
    "llm": {
        "provider": "ollama",
        "config": {
            "model": "llama3.1:latest",
            "temperature": 0,
            "max_tokens": 8000,
            "ollama_base_url": "http://localhost:11434",
        },
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": "nomic-embed-text:latest",
            "ollama_base_url": "http://localhost:11434",
        },
    },
    "version": "v1.1"
}

memory = Memory.from_config(config)

Setup Qdrant Vector Database

1. Pull Qdrant Docker Image

   docker pull qdrant/qdrant
   
2. Run Qdrant Container

   docker run -p 6333:6333 -p 6334:6334 \
       -v $(pwd)/qdrant_storage:/qdrant/storage:z \
       qdrant/qdrant
   
3. Verify Connection

   Access the Qdrant dashboard at http://localhost:6333/dashboard

Implementation Patterns

Pattern 1: AI Research Agent with Memory

View Full Implementation

import streamlit as st
import os
from mem0 import Memory
from multion.client import MultiOn
from openai import OpenAI

st.title("AI Research Agent with Memory 📚")

# Initialize components
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "model": "gpt-4o-mini",
            "host": "localhost",
            "port": 6333,
        }
    },
}

memory = Memory.from_config(config)
multion = MultiOn(api_key=api_keys['multion'])
openai_client = OpenAI(api_key=api_keys['openai'])

user_id = st.sidebar.text_input("Enter your Username")
search_query = st.text_input("Research paper search query")

if st.button('Search for Papers'):
    with st.spinner('Searching and Processing...'):
        # Retrieve relevant memories for context
        relevant_memories = memory.search(search_query, user_id=user_id, limit=3)
        
        # Build context-aware prompt
        prompt = f"Search for arXiv papers: {search_query}\n"
        prompt += f"User background: {' '.join(mem['text'] for mem in relevant_memories)}"
        
        # Execute search with context
        result = multion.browse(cmd=prompt, url="https://arxiv.org/")
        st.markdown(result)

Key Features:

• Maintains user research interests across sessions
• Contextualizes searches based on past queries
• Personalizes results using memory retrieval

Pattern 2: Local ChatGPT with Personal Memory

View Full Implementation

import streamlit as st
from mem0 import Memory
from litellm import completion

# User-specific session management
if "messages" not in st.session_state:
    st.session_state.messages = []
if "previous_user_id" not in st.session_state:
    st.session_state.previous_user_id = None

user_id = st.text_input("Enter your Username")

# Clear history on user switch
if user_id != st.session_state.previous_user_id:
    st.session_state.messages = []
    st.session_state.previous_user_id = user_id

if prompt := st.chat_input("What is your message?"):
    # Add to chat history
    st.session_state.messages.append({"role": "user", "content": prompt})
    
    # Store in memory
    m.add(prompt, user_id=user_id)
    
    # Retrieve context from memory
    memories = m.get_all(user_id=user_id)
    context = ""
    if memories and "results" in memories:
        for memory in memories["results"]:
            if "memory" in memory:
                context += f"- {memory['memory']}\n"
    
    # Generate response with context
    response = completion(
        model="ollama/llama3.1:latest",
        messages=[
            {"role": "system", "content": "You are a helpful assistant with access to past conversations."},
            {"role": "user", "content": f"Context: {context}\nCurrent message: {prompt}"}
        ],
        api_base="http://localhost:11434",
        stream=True
    )
    
    # Store response in memory
    m.add(f"Assistant: {full_response}", user_id=user_id)

Key Features:

• Fully local implementation (no external APIs)
• Per-user memory isolation
• Streaming responses with context

Pattern 3: Multi-LLM with Shared Memory

Show Multi-Model Memory Sharing

Enable multiple LLMs to access the same memory layer:

from mem0 import Memory

# Shared memory configuration
memory = Memory.from_config(config)

def chat_with_gpt4(prompt, user_id):
    # Retrieve memories
    context = memory.search(prompt, user_id=user_id, limit=5)
    
    # Add to GPT-4
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )
    
    # Store response
    memory.add(response.choices[0].message.content, user_id=user_id)
    return response

def chat_with_claude(prompt, user_id):
    # Same memories available to Claude
    context = memory.search(prompt, user_id=user_id, limit=5)
    
    response = anthropic.messages.create(
        model="claude-3-5-sonnet-20241022",
        messages=[{"role": "user", "content": prompt}]
    )
    
    memory.add(response.content[0].text, user_id=user_id)
    return response

Benefits:

• Seamless model switching without context loss
• Unified conversation history
• Cross-model personalization

Memory Operations

Adding Memories

memory.add() · function

Show Parameters

text · string · required

Content to store in memory

user_id · string · required

Unique identifier for user’s memory space

metadata · dict · default: "{}"

Additional context (timestamps, tags, etc.)

# Add user message to memory
memory.add(
    "I'm interested in machine learning papers on transformers",
    user_id="user123",
    metadata={"timestamp": datetime.now(), "category": "preference"}
)

Retrieving Memories

memory.search() · function

Show Parameters

query · string · required

Search query for semantic matching

user_id · string · required

User’s memory space to search

limit · integer · default: "5"

Maximum number of results

# Semantic search through memories
relevant_memories = memory.search(
    "papers about attention mechanisms",
    user_id="user123",
    limit=3
)

for mem in relevant_memories:
    print(f"- {mem['text']} (relevance: {mem['score']})")

Viewing All Memories

# Get complete memory history
all_memories = memory.get_all(user_id="user123")

if "results" in all_memories:
    for memory in all_memories["results"]:
        print(f"- {memory['memory']}")

Best Practices

Memory Granularity

Store atomic pieces of information:

• ✅ “User prefers Python over JavaScript”
• ✅ “Interested in computer vision research”
• ❌ “User had a long conversation about many topics”

Smaller, focused memories enable better retrieval and context building.

Context Window Management

Optimize context usage:

# Retrieve only relevant memories
memories = memory.search(current_query, user_id=user_id, limit=3)

# Build concise context
context = "\n".join([m['text'] for m in memories[:3]])

# Don't exceed token limits
if len(context) > 1000:  # tokens
    context = context[:1000]

Privacy & Data Management

User data controls:

# Delete user memories
memory.delete_all(user_id="user123")

# Export user data
user_data = memory.get_all(user_id="user123")
with open(f"{user_id}_memories.json", "w") as f:
    json.dump(user_data, f)

Performance Optimization

Optimize vector operations:

• Use appropriate embedding dimensions (768 for nomic-embed-text)
• Implement pagination for large memory sets
• Cache frequently accessed memories
• Use batch operations when possible

# Batch add memories
memories_to_add = [
    {"text": "Memory 1", "user_id": "user123"},
    {"text": "Memory 2", "user_id": "user123"},
]

for mem in memories_to_add:
    memory.add(mem["text"], user_id=mem["user_id"])

Use Cases

Research Assistants

Remember research interests, past queries, and preferred topics

Travel Agents

Maintain travel preferences, budget constraints, and destinations

Personalized Chatbots

Build rapport through conversation history and user preferences

Learning Assistants

Track learning progress, knowledge gaps, and study patterns

Advanced Patterns

Stateful Multi-Turn Conversations

class StatefulAgent:
    def __init__(self, user_id, memory_config):
        self.user_id = user_id
        self.memory = Memory.from_config(memory_config)
        self.conversation_history = []
    
    def chat(self, message):
        # Add user message
        self.memory.add(message, user_id=self.user_id)
        
        # Retrieve relevant context
        context = self.memory.search(message, user_id=self.user_id, limit=5)
        
        # Generate response with full context
        response = llm.generate(
            prompt=message,
            context=context,
            history=self.conversation_history
        )
        
        # Store in memory and history
        self.memory.add(f"Assistant: {response}", user_id=self.user_id)
        self.conversation_history.append(
            {"user": message, "assistant": response}
        )
        
        return response

Memory-Enhanced RAG

def rag_with_memory(query, documents, user_id):
    # Retrieve user preferences and past interactions
    user_context = memory.search(query, user_id=user_id, limit=3)
    
    # Standard RAG retrieval
    relevant_docs = vector_store.similarity_search(query, k=5)
    
    # Combine with memory context
    enhanced_prompt = f"""
    User context: {user_context}
    Relevant documents: {relevant_docs}
    Query: {query}
    
    Provide a personalized response based on user preferences and documents.
    """
    
    return llm.generate(enhanced_prompt)

Resources

Mem0 Documentation

Official Mem0 memory framework docs

Qdrant Guides

Vector database setup and optimization

Example Apps

Complete implementations with memory

Tutorial

Step-by-step memory tutorial