AI Agent Memory Patterns — Build Agents That Remember

What it is

This resource collects design patterns for adding persistent memory to AI agents. It covers the spectrum from simple conversation buffers to sophisticated knowledge graph memory, with working code examples for each pattern. The patterns include conversation buffer memory, sliding window memory, entity extraction, summary memory, knowledge graph memory, and tiered memory architectures.

The target audience is developers building AI agents who need memory beyond a single conversation turn. Whether you are using LangChain, LlamaIndex, or building from scratch, these patterns apply to any agent framework.

How it saves time or tokens

Memory management is one of the hardest parts of agent development. These patterns save you from reinventing solutions for common memory problems. Sliding window memory reduces token usage by keeping only recent context. Summary memory compresses long conversations into shorter summaries. Tiered memory separates short-term and long-term storage to optimize both recall and cost.

How to use

1. Start with the simplest pattern (ConversationBufferMemory) and evaluate if it meets your needs.
2. If conversations grow too long, switch to sliding window or summary memory to reduce token usage.
3. For agents that need to remember facts across sessions, implement entity extraction or knowledge graph memory.

Example

# Pattern 1: Conversation Buffer (simplest)
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context(
    {'input': 'My name is Alice'},
    {'output': 'Hello Alice!'}
)
memory.save_context(
    {'input': 'I like Python'},
    {'output': 'Python is great for AI development.'}
)

# Pattern 2: Sliding Window (token-efficient)
from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=5)  # Keep last 5 exchanges

# Pattern 3: Entity Memory (fact extraction)
from langchain.memory import ConversationEntityMemory

memory = ConversationEntityMemory(llm=llm)
# Automatically extracts entities: Alice -> likes Python

Related on TokRepo

• AI Memory Providers — Memory frameworks and providers for AI agents
• Agent Tools — AI agent frameworks and tools

Common pitfalls

• Conversation buffer memory grows linearly with conversation length. Without pruning, you will hit context window limits. Always set a maximum or use window/summary patterns.
• Entity extraction memory depends on LLM quality. Low-quality models may extract incorrect or irrelevant entities, degrading agent performance over time.
• Knowledge graph memory adds complexity and latency. Only use it when you need structured relationship queries across entities. For most chatbots, simpler patterns suffice.