Awesome Agent Memory

A curated list of projects on memory systems of AI agents.

Comparing Different Designs

• AI Agent Memory Playground – An interactive evaluation suite for 9 memory strategies (sequential, retrieval, hierarchical, decay-based, etc.). Includes simulation environment and plots for token–recall trade-offs and forgetting dynamics.

• Agent Memory Hub – A live model directory to search and explore the agent memory ecosystem.

Standalone Libraries / Frameworks for Building Agent Memory Systems

• Letta – Memory hierarchy with editable memory blocks, agentic context tools, multi-agent shared memory, and portable Agent File (.af) snapshots.

• MemMachine – Universal memory layer that lets agents learn/store/recall user data across sessions, building evolving user profiles. Supports Working (Short-Term), Persistent (Long-Term), and Personalized (Profile) memories with developer-friendly APIs (Python SDK, REST, and MCP). Persists episodic memory in a graph DB and profile memory in an SQL DB.

• Mem0 – “Universal memory layer” for short/long-term + semantic/episodic memory, with a local-first dashboard and broad framework integrations.

• MemU – Companion-focused memory that organizes/links/evolves memories, adds adaptive forgetting, and emphasizes accuracy + cost efficiency.

• A-Mem – Zettelkasten-style create/link/revise operations with ChromaDB indexing and automatic memory evolution.

• MemEngine – Unified, modular library with many pluggable memory models and automatic config selection for local/remote runs.

• memonto – Ontology/knowledge-graph memory that extracts entities/relations and exposes graph queries; can run ephemeral or persist to triple/vector stores.

• Zep – Temporal knowledge graph memory (Graphiti engine) with bi-temporal facts and hybrid retrieval (graph + semantic + keyword).

• Agno – Full-stack multi-agent framework with built-in Storage/Memory drivers, small footprint, and fast stateful agents.

• MemoryOS – OS-like memory stack with short/mid/long-term layers and plug-and-play storage/retrieval; exportable via tools.

• Memary – Human-memory-inspired layer with persona-aware graphs and multi-graph support (FalkorDB/Neo4j; local or hosted LLMs).

• Cognee – Extract-Cognify-Load pipeline that turns conversations/files into graph + vector memory to replace/augment RAG with relationship-aware recall.

• Nemori – Self-organising long-term memory substrate for agentic LLM workflows. Nemori segments multi-turn conversations into topic-consistent episodes, distils durable semantic knowledge, and exposes a unified search surface for downstream reasoning. The system uses insights from Event Segmentation Theory and predictive processing and provides production-ready concurrency, caching and pluggable storage options.

• ReMe – Remember Me, Refine Me. A modular memory management kit that unifies personal, task, and tool memories for agents. Features refinement cycles, temporal prioritization, and Pydantic-backed schemas to ensure memory coherence and relevance.

• Memori – Open-source memory engine for LLMs and agents with entity extraction, auto-categorization, memory promotion, and multi-agent sync. Supports temporal retention policies, retrieval tuning, and cross-agent context exchange.

• O-Mem – Omni memory system for personalized, long‑horizon, self‑evolving agents. It views memory as an active user‑modelling process: it continually extracts and updates user persona attributes, event records, and topic‑indexed messages. This enables dynamic user profiling, a three‑layer hierarchical memory (persona, event and message), user‑centric retrieval, and interaction‑time scaling. O‑Mem includes an evaluation suite and exposes modular APIs under the Apache‑2.0 license.

• OpenMemory Engine – Self-hosted, sectorized semantic memory engine with hierarchical storage, auto decay, and explainable recall graphs; integrates with LangGraph, Mem0, and MCP tools.

• Task Memory Engine – Structured task-level memory engine combining hierarchical trees and rollback-aware buffers to track multi-step reasoning; enables state reconstruction and planning with minimal context tokens.

• Persistent AI Memory System – Persistent, searchable memory plus tool-usage logs, deduping/self-reflection, and cross-conversation sync.

Memory Modules in Existing Agent Frameworks

• Ars Contexta – A second brain for your agent. A Claude Code plugin that generates complete knowledge systems from conversation — you describe how you think and work, and the engine derives a cognitive architecture (folder structure, context files, processing pipeline, hooks, navigation maps, and note templates) tailored to your domain and backed by 249 research claims. No templates, no configuration — just conversation.

• LangMem – SDK that gives agents long-term, semantic memory with tools to store/search memories in LangGraph stores, plus a managed service and templates.

• Claude-Mem – Persistent memory compression system for Claude Code that automatically captures tool-usage observations and generates semantic summaries for reuse across sessions. Offers progressive disclosure retrieval with token-cost visibility, a mem-search skill with hybrid semantic + keyword search, and a local web viewer UI for inspecting the memory stream. Includes privacy controls (e.g., <private> exclusion) and configurable context injection.

• LangGraph + MongoDB Store – Introduces a persistent document memory layer for LangGraph, combining vector and document stores for scalable long-term retention.

• LlamaIndex – Agent Memory – Unified APIs for short- and long-term memory, including composable memory so agents can combine multiple sources. Recent updates improve long/short-term blocks.

• Semantic Kernel – Memory Plugin – Embeddings-based memory plugin (e.g., TextMemoryPlugin) to save/recall short/long-term info across agents in .NET/JS/py SK apps.

• AutoGen – Memory – Provides a Memory protocol (e.g., ListMemory) and official notebooks showing long-term memory with Zep and Mem0 in conversational agents.

• smolagents – Memory – Exposes a first-class agent memory you can inspect/replay/modify; supports step callbacks for dynamic memory policies.

• CrewAI – Memory – Adds short-term (RAG) and long-term stores (e.g., SQLite backed) so crews retain insights across executions and reuse them later.

Reinforcement-Learning Training for Agent Memory

• MemSearcher – RL-driven search agent that maintains a compact memory, fusing each query with memory to generate reasoning traces, perform search actions, and update memory to keep only task-relevant information (stabilizing context length across long multi-turn runs). Uses multi-context GRPO end-to-end RL to jointly optimize reasoning, search, and memory management.

• MemEvolve – Meta-evolution framework that jointly evolves an agent’s memory base and memory architecture via a dual-loop process, enabling the memory system itself (not just contents) to improve over time. Includes automated multi-round tournament evolution with candidate generation, evaluation, and selection; supports optional Pareto multi-objective selection.

• MemAgent – RL-trained long-context agent with a memory mechanism that enables arbitrarily long inputs within fixed windows; RLVR-based training and linear-time scaling, shown to extrapolate to multi-million-token tasks with minimal loss.

• MEM1 – End-to-end RL that learns a compact internal state for constant-memory long-horizon agents; integrates new observations while discarding redundancy to improve efficiency.

• Memento – Memory-based online RL over a memory-augmented MDP with a neural case-selection policy; planner–executor loop reuses past trajectories so agents learn without fine-tuning the base LLM.

• Memory-R1 – the paper (code not yet publicly available) proposes an RL framework where a Memory Manager learns to add, update or delete memory entries and an Answer Agent learns to select relevant entries. Both agents are trained with PPO and GRPO to actively manage and utilise an external memory bank.

• Mem-α – RL framework that teaches agents how to build and manage complex memory systems through interaction and feedback. Agents process sequential information, learn to extract and store relevant content, and update core/episodic/semantic memory components; rewards derive from downstream question-answering accuracy.

MCP-Centric Memory Servers & Tools

• Basic Memory – Local-first Markdown knowledge base exposed via MCP; bi-directional human/LLM editing with simple, file-backed persistence.

• OpenMemory MCP – Mem0’s local-only MCP server that centralizes cross-tool memory with a unified dashboard.

• Memory MCP Server (Swift) – Lightweight MCP server for entity/relation memory graphs with JSON storage and a simple CLI.

• memory (HamzaFarhan) – Minimal knowledge-graph MCP server (entities/relations/observations) with JSON persistence and flexible search modes.

• mcp-memory (Puliczek) – Cloudflare-backed MCP memory with D1 + vector search, namespaces, and rate-limited, TLS-secured endpoints.

• memory-mcp (JamesANZ) – MCP memory for conversation logging, context-window caching, relevance scoring, and MongoDB storage.

• MCP Memory Service (doobidoo) – Universal MCP memory with semantic search, natural-language time filters, and storage options (SQLite-vec/Chroma/Cloudflare).

• Supermemory MCP – Graph memory service implementing MCP context sharing, cross-app recall, and relationship graphs for multi-agent sessions.

• MCP-Titan – Experimental neural memory engine integrating online vector processing and TensorFlow.js learning loops, enabling live memory update and auto-retention control.

• Redis Agent Memory Server – Redis-powered memory with REST + MCP, two-tier memory (session/long-term), configurable extraction, and pluggable vector backends.

Contributing

Contributions are welcome! If a project belongs here, open an issue or PR with:

• Name + link
• One-to-two sentence description
• A unique feature or highlight (e.g., storage model, retrieval strategy, tooling, compliance)
• License and ecosystem (LangGraph, SK, AutoGen, MCP, etc.)