Managed extract-retrieve

Single-pass ADD-only extraction: each add() fires one LLM call (default gpt-5-mini) that accumulates facts — no UPDATE or DELETE on ingestion. Entity linking via spaCy (installed as `mem0ai[nlp]`) extracts named entities from every stored memory and writes them to a parallel vector sub-collection (`{collection}_entities`); retrieval folds entity-match scores into the ranking alongside dense and keyword signals. External graph DB support (Neo4j, Memgraph, Kuzu, AGE, Neptune) was removed in 2026; graph-style association is now vector-native. Three memory scopes: user (cross-session persistence), session (ephemeral per run), agent (runtime state). Two deployment paths: OSS library (BYO LLM + BYO vector store) or fully managed cloud (Qdrant-backed, auto-scaled). 23+ official integrations span LangChain, LangGraph, CrewAI, AutoGen, Vercel AI SDK, OpenAI Agents SDK, Google ADK, AWS Bedrock, LiveKit, ElevenLabs, Dify, Flowise, and more.

Best for: Fastest drop-in memory with the largest integration ecosystem when time-to-working-agent is the constraint · Token-cost-sensitive production agents needing sub-7k retrieval tokens and single-pass extraction without full-context overhead · SOC 2 / HIPAA workloads and AWS Agent SDK users needing managed, auditable memory with no infrastructure to run

Production polish: sub-300ms, SOC2/HIPAA, connectors, context fencing via container tags. Writes auto-extract facts into dual-layer user profiles (static + dynamic) and a unified knowledge graph; an asynchronous background pass ('Dynamic Dreaming', shipped May 2026) reconsolidates fragmented memories, reweights contradictions, and infers cross-memory connections without blocking the write path. Claims #1 on LongMemEval/LoCoMo/ConvoMem (self-reported); publishes an open-source benchmarking harness, MemoryBench, that others can run against Mem0 and Zep, though Supermemory's own headline numbers still come from its own runs of it.

Best for: Polished managed memory API with SOC 2 / HIPAA compliance · Coding-agent memory via MCP (Claude Code, OpenCode, OpenAI Codex CLI plugins) · One API over mixed data (files, email, PDFs, chat)

Dual-mode memory infrastructure: Local mode stores an atomic disk snapshot plus append-only journal under ~/.retaindb with no external dependencies (no Postgres, Redis, or Qdrant). Server/Cloud mode uses PostgreSQL with pgvector. Both modes share the same retrieval pipeline: BM25 lexical search + vector similarity + knowledge-graph signals (updates/contradicts/supports/extends/derives relations), fused with RRF then reranked. Supports 12 typed memory categories with temporal validity (validFrom/validUntil), recall reinforcement (access counts + memory-strength decay), and token-budgeted delta compression for context packing.

Best for: Coding-agent workflows: single-machine persistent memory for Codex, Claude Code, or OpenCode via MCP or CLI, no cloud account required · Agents needing multi-modal recall — exact-string hits (codes, IDs, error strings) that semantic-only search misses, plus preference, correction, and decision memory across sessions · Product teams wanting a self-hosted or cloud memory API with per-user isolation, session ingestion, and knowledge-source connectors (GitHub, Notion, Slack, PDF, arXiv, npm/PyPI docs)

Memory in plain SQL — no vector DB, fully inspectable, portable. LoCoMo benchmark: 81.95% accuracy at ~1,294 tokens/query (self-reported). Paper: arxiv.org/abs/2603.19935.

Best for: Cost-sensitive production: skip the vector DB and run on the SQL infra you already have · Inspectable, debuggable memory you can query directly · Agents where what the agent *did* (tool calls, decisions) matters as much as what the user *said*

A self-hostable 'memory operating system' that packages long-term memory into MemCube units and manages their lifecycle (store / retrieve / update / schedule) outside the model. v2.0 adds multi-cube knowledge base management, multi-modal memory, tool-use history, async ingestion via MemScheduler, and natural-language feedback and correction.

Best for: Teams wanting a self-hosted memory layer with hybrid retrieval and skill reuse · Projects needing an MCP-accessible memory server that can run locally or in the cloud

An OS-inspired memory layer for personalized AI agents that organizes user memory into short-, mid-, and long-term tiers and migrates entries between them via heat-based promotion/demotion. Four core modules: Storage, Updating, Retrieval, and Generation. Published as an EMNLP 2025 Oral.

Best for: Personalized conversational agents needing tiered long-term user memory · Claude Desktop / Cursor / Cline setups wanting plug-in memory via MCP

A modular multi-agent memory system that can be plugged into any LLM agent stack. Specialized agents manage six memory types (Core, Episodic, Semantic, Procedural, Resource, Knowledge Vault) under a meta-agent coordinator that orchestrates writes and retrieval. Backed by PostgreSQL with BM25 full-text search and embedding-based vector similarity. Exposed as a self-hosted REST API or via managed hosting at app.mirix.io. The screen-activity tracking desktop app was deprecated in v0.1.6 and lives on a separate branch.

Best for: Agent developers needing a drop-in, multi-type memory layer behind a REST API · Projects requiring BM25 + vector hybrid retrieval across distinct memory categories · Teams that want local-first, self-hosted storage with an optional managed fallback

Fully-local long-term memory for AI agents built on two pillars: layered long-term memory (a semantic pyramid L0 Conversation -> L1 Atom -> L2 Scenario -> L3 Persona) and symbolic short-term memory that offloads verbose tool logs to files while keeping a compact Mermaid 'canvas' in context. Distributed as a TypeScript/npm package (@tencentdb-agent-memory/memory-tencentdb); integrates with OpenClaw and Hermes via plugins and exposes a REST Gateway API at port 8420 for use from any HTTP-capable agent framework.

Best for: Long-horizon agent tasks needing token-efficient, fully-local memory with traceable layered recall · Agents running on OpenClaw or Hermes wanting zero-config long-term memory with no external API · Teams that want a standalone REST Gateway memory sidecar callable from any agent framework

A lifelong memory stack for LLM agents built on 'semantically lossless compression' — store dense, high-information memory so an agent recalls more while spending far fewer tokens. Ships as one `simplemem` Python package that auto-routes across three pillars: SimpleMem (text efficiency core), Omni-SimpleMem (multimodal: text/image/audio/video), and EvolveMem (self-evolving retrieval). Also offered as a cloud-hosted and self-hostable MCP server. Backed by arXiv papers (2601.02553, 2604.01007, 2605.13941).

Best for: Token-budget-constrained agents needing dense lifelong memory with intent-aware retrieval, optionally across modalities

An agent memory management layer positioned as a high-performance drop-in replacement for Mem0 (`import telemem as mem0`), optimized for multi-turn dialogue, character modeling, long-term storage, and semantic retrieval. Pipeline: character-aware summarization → semantic-clustering deduplication → efficient storage → precise retrieval. Extends to multimodal video memory (frame extraction → captioning → vector DB) with ReAct-style multi-step video QA. Backed by a tech report (arXiv 2601.06037).

Best for: Teams wanting a local, Mem0-compatible memory layer with strong per-character isolation and optional video memory

A self-hosted MCP server (plus REST API) that adds persistent, personalized long-term memory to any MCP-compatible assistant (Claude Code, ChatGPT, Cursor, Open WebUI, and more). A single unified LLM call performs fact extraction, metadata classification, deduplication, and contradiction resolution at once. Two-tier design: fast searchable summaries in a vector store, plus a detailed artifact store retrieved on demand.

Best for: Self-hosters wanting a private, MCP-native memory server with automatic fact extraction, dedup, and contradiction handling

An in-process, local-first Python memory library (`pip install archon-memory-core`) whose thesis is that memory should get better the longer it is used. Built on ChromaDB + Ollama, it pairs ranked top-1 retrieval with supersede-aware nightly consolidation, type-aware salience, an entity graph, active forgetting, and full replay/observability. Positions itself as a memory policy library (not an agent runtime), with LangChain and LlamaIndex adapters.

Best for: Agents that accumulate contradictory facts over long horizons and want a local, consolidating memory library with built-in forgetting

Persistent, self-evolving AI memory plugin for coding agents and applications. Combines LLM-driven memory extraction with a two-layer Experience + Skill distillation system: raw interactions are first compressed into Experience memories, then recurring patterns are further abstracted into reusable Skill entries. Ebbinghaus-style time-decay keeps memory collections pruned and relevant over time. Exposes a unified backend via Python SDK, HTTP REST server, MCP server, and CLI.

Best for: AI coding agents and multi-agent systems that need both factual recall and reusable procedural workflows distilled from past sessions · Teams wanting a production-ready memory backend that spans multiple agent clients (Claude Code, Codex, OpenCode, Cline) via a shared server

Self-organising long-term memory substrate for agentic LLM workflows, grounded in Event Segmentation Theory (EST) and Predictive Processing (PP). Ingests multi-turn conversations, segments them into topically coherent episodes via LLM-powered boundary detection, distils durable semantic knowledge from each episode, and exposes a unified search surface for downstream reasoning. Designed as a minimalist production-ready core: PostgreSQL for structured metadata, Qdrant for vector similarity.

Best for: Agentic LLM workflows needing structured long-term memory with semantically coherent episodes and a unified search surface across episodic and semantic stores

A local-first memory engine built on one Postgres store shared by every client — CLI, MCP, HTTP API, a browser viewer, and the raw Postgres wire. The same schema and the same SQL run across three tiers (embedded PGLite with no Docker, local Postgres, cloud Postgres), so moving tiers is a config swap. Its distinguishing bet is human-in-the-loop conflict handling: when a new memory contradicts an old one, memloom keeps both active and queues a conflict for you to resolve (keep new / keep existing / keep both / merge), and every resolution is reversible. Beliefs are versioned — restating or editing a fact appends a version sharing a root_id and stales the prior one, so history() shows how a fact changed.

Best for: One shared memory across several AI clients on your own machine (Claude Code, Claude Desktop, Cursor) without a hosted service or account · Cases where a silent overwrite is a liability and you want to review and revert what the agent decided to believe · Teams that want memory in plain Postgres they can query, audit, and back up with tools they already run · Mixing your own notes and PDFs into agent recall with citations back to the exact section and page

A CLI-first memory agent built on three primitives — remember, recall, answer — over 13 typed memory categories with conflict detection and temporal versioning. All retrieval runs through Moorcheh's proprietary information-theoretic search engine, which the CLI provisions either as a local Docker container (fully offline, no account) or as a managed cloud backend. External agents reach it via an MCP server, a local REST API, a TypeScript SDK, or one-command `memanto connect <tool>` wiring for a documented roster of coding agents and frameworks.

Best for: Developers wanting persistent memory shared across several coding agents with zero backend to manage · Teams wanting typed, versioned memory with conflict detection without standing up a vector or graph store · Offline or air-gapped setups that can run the local Docker engine with no account

A Go REST API server is the single source of truth, fronted by thin, stateless per-runtime plugins for OpenClaw, Hermes Agent, Claude Code, OpenCode, Codex, and Dify, plus a documented raw HTTP API for any custom client. Two deployment modes: Direct mode talks straight to a TiDB Serverless database with no server to deploy, while Server mode self-hosts the Go binary in front of TiDB or Postgres and adds multi-agent space management and LLM-based conflict merging. The design principle is explicit — plugins stay thin because storage, search, ingest, and policy all live in the server.

Best for: Teams already inside the OpenClaw ecosystem wanting managed shared memory with minimal setup · Multi-agent orgs needing one memory layer across several coding-agent runtimes without writing a plugin per tool · Teams that want a hosted start with a genuine self-host exit ramp that does not require an API rewrite

Runs a fixed four-stage LangGraph pipeline per turn (working-memory manager, search coordinator, synthesizer, reasoning agent), with a background consolidator that extracts seven typed memory record kinds and fuses near-duplicates by embedding cosine into a hierarchical composite-record tree. It also runs a working-memory token-budget manager, a procedural skill store using HyDE retrieval, and an optional multimodal visual-memory store with an Ebbinghaus-style forgetting curve. Everything persists to an embedded SQLite and LanceDB pair with no external database server.

Best for: Solo developers and researchers wanting a lightweight, fully local Python memory service with fine-grained typed records · Teams already on OpenClaw, Claude Code, or Hermes wanting native plugin memory · Anyone who wants an embeddable memory library without standing up a graph or vector database server

A single Go binary plus Postgres/pgvector, run with docker compose. Its differentiator is a nine-stage consolidation pipeline that turns raw episodic input into a structured, queryable memory graph: episodes become facts, then relationships, causal links, patterns, contradictions, goal inference, failure patterns, and finally a hypothesis scan. Each stage is incremental, processing only data new since the last run. Agents reach it through an MCP server exposing remember, recall, consolidate, namespace, goal, and failure tools.

Best for: Developers wanting a fully self-hosted, single-binary memory layer with transparent consolidation logic · Air-gapped or local-LLM setups running Ollama · Anyone who wants structured facts and causal links extracted from raw episodes rather than stored chat transcripts