Every LLM is stateless. Send the same prompt twice, get the same answer twice. This is fine for one-shot tasks, but terrible for conversational AI, personal assistants, and any application where context builds over time. Memory systems solve this by persisting information across interactions — from simple conversation history to complex knowledge graphs that capture relationships between entities. This guide covers every memory approach available in 2026, with production-ready implementation patterns.

Types of AI Memory

Memory systems exist on a spectrum from simple to sophisticated:

Memory Type	What It Stores	Persistence	Retrieval	Use Case
Buffer memory	Recent conversation turns	Session	Direct inclusion	Chatbots
Summary memory	Condensed conversation history	Session	Direct inclusion	Long conversations
Vector memory	Embedded facts and conversations	Database	Semantic search	Personal assistants
Entity memory	Key facts about users/things	Database	Key lookup	User profiles
Knowledge graph	Relationships between entities	Graph DB	Graph traversal	Complex domains

Buffer Memory: The Simplest Approach

Just keep the last N messages in the conversation and include them in each request:

class BufferMemory:
    """Simple sliding window memory."""
    
    def __init__(self, max_messages=10):
        self.messages = []
        self.max_messages = max_messages
    
    def add(self, role, content):
        self.messages.append({"role": role, "content": content})
        if len(self.messages) > self.max_messages:
            self.messages = self.messages[-self.max_messages:]
    
    def get_context(self):
        return self.messages.copy()

# Usage
memory = BufferMemory(max_messages=6)
memory.add("user", "My name is Alice")
memory.add("assistant", "Nice to meet you, Alice!")
memory.add("user", "What's my name?")

response = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        *memory.get_context(),
        {"role": "user", "content": "What's my name?"}
    ]
)

Pros: Simple, fast, no external dependencies
Cons: Limited context, no persistence across sessions

Summary Memory: Compress the Past

For long conversations, periodically summarize old messages instead of dropping them:

class SummaryMemory:
    def __init__(self, client, max_recent=4, summary_trigger=8):
        self.client = client
        self.messages = []
        self.summary = ""
        self.max_recent = max_recent
        self.summary_trigger = summary_trigger
    
    def add(self, role, content):
        self.messages.append({"role": role, "content": content})
        if len(self.messages) >= self.summary_trigger:
            self._summarize()
    
    def _summarize(self):
        to_summarize = self.messages[:-self.max_recent]
        recent = self.messages[-self.max_recent:]
        
        response = self.client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=[
                {"role": "system", "content": "Summarize the following conversation concisely."},
                {"role": "user", "content": str(to_summarize)}
            ]
        )
        
        new_summary = response.choices[0].message.content
        self.summary = f"{self.summary}\n\nNew context: {new_summary}" if self.summary else new_summary
        self.messages = recent
    
    def get_context(self):
        context = []
        if self.summary:
            context.append({"role": "system", "content": f"Previous conversation summary: {self.summary}"})
        context.extend(self.messages)
        return context

Vector Memory: Semantic Recall

Store facts as embeddings and retrieve relevant ones based on semantic similarity:

from openai import OpenAI
import numpy as np

class VectorMemory:
    def __init__(self, client, embedding_model="text-embedding-3-small"):
        self.client = client
        self.embedding_model = embedding_model
        self.memories = []
    
    def _get_embedding(self, text):
        response = self.client.embeddings.create(
            model=self.embedding_model, input=text
        )
        return response.data[0].embedding
    
    def add(self, text, metadata=None):
        embedding = self._get_embedding(text)
        self.memories.append({"text": text, "embedding": embedding, "metadata": metadata or {}})
    
    def _cosine_similarity(self, a, b):
        return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
    
    def retrieve(self, query, top_k=3):
        query_embedding = self._get_embedding(query)
        scored = [(self._cosine_similarity(query_embedding, m["embedding"]), m) for m in self.memories]
        scored.sort(reverse=True)
        return [m for _, m in scored[:top_k]]

# Usage
memory = VectorMemory(client)
memory.add("User's name is Alice", {"type": "fact"})
memory.add("Alice works as a software engineer at Google", {"type": "fact"})
memory.add("Alice prefers Python over JavaScript", {"type": "preference"})

relevant = memory.retrieve("What programming language should I recommend?", top_k=2)
for mem in relevant:
    print(f"- {mem['text']}")

Production Vector Memory with ChromaDB

import chromadb

class PersistentVectorMemory:
    def __init__(self, collection_name="memories", persist_dir="./chroma_db"):
        self.client = chromadb.PersistentClient(path=persist_dir)
        self.collection = self.client.get_or_create_collection(
            name=collection_name, metadata={"hnsw:space": "cosine"}
        )
    
    def add(self, text, memory_id=None, metadata=None):
        import uuid
        memory_id = memory_id or str(uuid.uuid4())
        self.collection.add(documents=[text], ids=[memory_id], metadatas=[metadata or {}])
        return memory_id
    
    def retrieve(self, query, top_k=3, filter_dict=None):
        results = self.collection.query(query_texts=[query], n_results=top_k, where=filter_dict)
        memories = []
        for i in range(len(results["documents"][0])):
            memories.append({
                "text": results["documents"][0][i],
                "metadata": results["metadatas"][0][i],
                "distance": results["distances"][0][i]
            })
        return memories

Entity Memory: Structured Facts

from pydantic import BaseModel
from typing import Optional

class UserProfile(BaseModel):
    name: Optional[str] = None
    occupation: Optional[str] = None
    location: Optional[str] = None
    preferences: list[str] = []
    goals: list[str] = []

class EntityMemory:
    def __init__(self, client):
        self.client = client
        self.entities = {}
    
    def extract_entities(self, text):
        response = self.client.responses.parse(
            model="gpt-5.4-mini",
            input=[
                {"role": "system", "content": "Extract user information from the text."},
                {"role": "user", "content": text}
            ],
            text_format=UserProfile,
        )
        return response.output_parsed
    
    def update_profile(self, user_id, text):
        extracted = self.extract_entities(text)
        if user_id not in self.entities:
            self.entities[user_id] = UserProfile()
        
        profile = self.entities[user_id]
        if extracted.name: profile.name = extracted.name
        if extracted.occupation: profile.occupation = extracted.occupation
        if extracted.location: profile.location = extracted.location
        profile.preferences.extend(extracted.preferences)
        profile.goals.extend(extracted.goals)
        return profile

Hybrid Memory: Production Pattern

class HybridMemory:
    def __init__(self, client, user_id):
        self.client = client
        self.user_id = user_id
        self.buffer = BufferMemory(max_messages=6)
        self.vector = PersistentVectorMemory(collection_name=f"user_{user_id}")
        self.entity = EntityMemory(client)
    
    def add_interaction(self, user_message, assistant_response):
        self.buffer.add("user", user_message)
        self.buffer.add("assistant", assistant_response)
        
        combined = f"User: {user_message}\nAssistant: {assistant_response}"
        self.vector.add(combined, metadata={"type": "conversation"})
        
        self.entity.update_profile(self.user_id, user_message)
        self.entity.update_profile(self.user_id, assistant_response)
    
    def get_context(self, current_query):
        context_parts = []
        
        profile = self.entity.get_profile_summary(self.user_id)
        if profile:
            context_parts.append(f"User profile:\n{profile}")
        
        relevant = self.vector.retrieve(current_query, top_k=3)
        if relevant:
            context_parts.append("Relevant past context:")
            for mem in relevant:
                context_parts.append(f"- {mem['text']}")
        
        buffer_msgs = self.buffer.get_context()
        return "\n\n".join(context_parts), buffer_msgs

Memory Management

Memory grows indefinitely. You need strategies to keep it useful:

• Forgetting: Remove least relevant or oldest memories when exceeding max capacity
• Deduplication: Don't store memories too similar to existing ones
• Confidence scoring: Weight memories by source reliability (user_stated > inferred > assumed)
• Consolidation: Periodically summarize groups of old memories

Memory Libraries Comparison

Library	Type	Best For	Complexity
LangChain Memory	Multiple	Quick prototyping	Low
Mem0	Vector + Entity	Production user memory	Medium
Zep	Vector	Long-term conversation memory	Medium
ChromaDB	Vector store	Custom implementations	Medium
Neo4j	Graph	Knowledge graphs	High

Common Pitfalls

1. Storing everything — Not every utterance is worth remembering. Filter for facts, preferences, and decisions
2. No memory decay — Old memories should fade or be summarized
3. Conflicting memories — Users change their minds. Store timestamps and confidence scores
4. Privacy violations — Implement deletion, anonymization, and consent mechanisms
5. Retrieving irrelevant context — Tune top_k and similarity thresholds
6. Not testing retrieval quality — Run evals on memory retrieval precision

Conclusion

Memory transforms stateless LLMs into persistent, personalized assistants. Start with buffer memory for simple chatbots, add vector memory for cross-session recall, and use entity memory for structured user profiles. The hybrid approach — buffer for recency, vectors for semantic recall, entities for structured facts — covers most production needs.

The key insight: memory is not just storage, it's retrieval. The best memory system is the one that retrieves the right context at the right time.