1. Executive Summary
2. Project Breakdowns
   1. mem0ai/mem0 (⭐57.3k)
   1. MemPalace/mempalace (⭐53.2k)
   1. Lum1104/Understand-Anything (⭐47.8k)
   1. pingcap/tidb (⭐40.1k)
   1. volcengine/OpenViking (⭐25k)
   1. supermemoryai/supermemory (⭐23.5k)
   1. humanlayer/12-factor-agents (⭐22.9k)
   1. rohitg00/agentmemory (⭐20.3k)
   1. memvid/memvid (⭐15.6k)
   1. vectorize-io/hindsight (⭐15.4k)
3. Cross-Cutting Analysis
4. Conflict Resolution Taxonomy
5. Recommendations

Executive Summary

The GitHub memory topic spans 6,187+ public repositories — a sprawling landscape that includes system memory profilers, AI agent memory layers, distributed databases, and knowledge graphs. The top 10, however, tell a more focused story: eight out of ten are AI agent memory projects, a category that barely existed two years ago and now dominates the conversation.

What the top 10 reveal:

• AI Agent Memory (8 projects): mem0, MemPalace, Understand-Anything, OpenViking, supermemory, agentmemory, memvid, hindsight
• Database/Infrastructure (1): TiDB — a distributed SQL database that has repositioned itself for agentic workloads
• Principles/Framework (1): 12-Factor Agents — a methodology, not software

A fundamental architectural divide runs through the ecosystem: embedded/local-first projects (MemPalace, memvid, agentmemory) keep data and inference on-device, while client-server/cloud projects (mem0, supermemory, OpenViking, hindsight) rely on remote infrastructure. A small subset — supermemory on Cloudflare, mem0 on FastAPI+Postgres — leans fully into cloud-native architectures.

Project Breakdowns

1. mem0ai/mem0 — Universal Memory Layer for AI Agents

Overview. mem0 positions itself as a universal memory layer for AI agents, offering multi-level memory (User/Session/Agent), graph memory support, multi-signal retrieval (semantic, BM25, entity), and integrations with over 30 vector stores. It is the most well-funded project in the space, with Y Combinator backing and a $24M raise.

Architecture & dependencies. Built on Python 3.9+ with qdrant-client, pydantic, openai, and sqlalchemy at its core. The optional ecosystem is vast: 30+ vector stores (Chroma, Pinecone, Weaviate, Milvus, pgvector, FAISS), 24+ LLM providers, 15+ embedders, and 5 rerankers. Graph memory uses Neo4j 5.x. Self-hosted deployments require FastAPI, PostgreSQL, and Docker.

Strengths.

• Top benchmark scores: 91.6 LoCoMo, 94.8 LongMemEval, 64.1 BEAM
• Single-pass ADD-only algorithm avoids the complexity of in-place updates
• Massive provider ecosystem with no single-vendor lock-in at the infrastructure level
• Multi-signal retrieval combining entity linking with temporal reasoning
• Rich surface area: MCP server, browser extension, CLI, Python and TypeScript SDKs
• Peer-reviewed publication at ECAI 2025

Limitations.

• Requires an external LLM (defaults to OpenAI, creating a de facto dependency)
• Self-hosted setup is complex — Docker, PostgreSQL, and Neo4j are all prerequisites
• The pre-April 2026 algorithm was significantly less capable
• Deduplication only activates with infer=True, which is easy to miss
• A known issue: silent memory loss when batch embedding partially fails
• Graph memory adds meaningful overhead for marginal gain in some use cases

Conflict resolution approach. mem0's architecture is fundamentally ADD-only — memories accumulate, nothing is overwritten. Conflicts are resolved at retrieval time through multi-signal ranking (semantic similarity, BM25, entity matching, temporal recency). The old algorithm used a more traditional detection → recency evaluation → explicitness check → merge-or-replace → logging pipeline. Graph memory introduces LLM-driven entity/relation extraction with duplicate merging via semantic similarity. Deduplication uses a cosine-similarity threshold controlled by the infer flag.

2. MemPalace/mempalace — Local-First AI Memory System

Overview. MemPalace is a local-first AI memory system inspired by the method of loci — a classical mnemonic technique. It stores content verbatim (never summarizes or lossy-compresses) and retrieves via semantic search. A knowledge graph with temporal validity, AAAK compression index, and an MCP server with 29 tools rounds out the offering.

Architecture & dependencies. Pure Python 3.9+ with ChromaDB 1.5+, huggingface_hub, and ONNX Runtime. The default multilingual embedding model is ~300 MB, with a 30 MB English-only alternative. The knowledge graph lives in SQLite. All embeddings run locally via ONNX — no API keys required.

Strengths.

• Exceptional benchmark results: 96.6% R@5 raw, 98.4% hybrid, 99%+ with LLM reranking
• Truly local-first: zero external API calls by default, no telemetry
• Verbatim storage guarantee — never summarizes or applies lossy compression
• Knowledge graph with temporal validity windows for time-aware queries
• Living memory dynamics: Hebbian potentiation (strengthening frequently accessed paths) and Ebbinghaus decay (fading unused memories)
• MIT license — completely free, no SaaS fees or vendor lock-in

Limitations.

• Beta status (Dev Status 4) — not yet production-hardened
• ChromaDB dependency introduces fragility: HNSW segment corruption and Windows deadlocks have been reported
• The default embedding model is large (~300 MB)
• Primarily designed for Claude Code; integrations with other tools are less mature
• The palace/wing/room/drawer conceptual model has a steep learning curve
• Historical silent data loss issues (now fixed, but trust takes time)
• Multi-hour rebuild times on large palaces

Conflict resolution approach. Every fact carries explicit valid_from/valid_to timestamps; as_of queries return state at any point in time. Cosine-similarity deduplication (default threshold 0.15) keeps the longest version of near-duplicate entries. Entity disambiguation uses context pattern matching for ambiguous names (e.g., "Apple" the company vs. "apple" the fruit). An entity registry priority system resolves conflicts by source: Onboarding (1.0) > Learned (0.75) > Researched > Wiki Cache. Repair tools include HNSW rebuild, SQLite recovery, segment quarantine, and truncation guards. Operations are designed to be idempotent with deterministic IDs, atomic writes, and triple deduplication.

3. Lum1104/Understand-Anything — Interactive Knowledge Graphs

Overview. A plugin for AI coding assistants that transforms codebases into interactive knowledge graphs. It uses a multi-agent pipeline combining Tree-sitter (deterministic structural analysis) with LLM-based semantic enrichment. Strictly speaking, this is not a memory system — it is a codebase-understanding tool that uses knowledge graphs as a memory substrate.

Architecture & dependencies. Node.js 22+, pnpm 10+, web-tree-sitter (WASM) with grammars for 10+ languages. The dashboard uses React 19, @xyflow/react, graphology, d3-force, and dagre. Search relies on Fuse.js, validation on Zod.

Strengths.

• Compatible with 15+ AI coding platforms (Claude Code, Cursor, Codex, Copilot)
• Tree-sitter + LLM hybrid gives you a deterministic structural graph with semantic enrichment on top
• Incremental updates via fingerprint-based change detection — no full rebuilds
• Guided tours, diff impact analysis, business domain mapping, persona-adaptive UI
• Shareable as plain JSON — team-friendly without proprietary formats
• MIT license

Limitations.

• Requires Node.js 22+, which is too new for some enterprise environments
• LLM dependency for the semantic layer adds latency and API costs
• pnpm-specific; not compatible with npm or yarn
• Very new (March 2026) — limited real-world track record
• No formal conflict resolution for contradictory LLM claims
• Large graphs require git-lfs

Conflict resolution approach. The deterministic structural layer (Tree-sitter) produces identical output for identical input — no conflicts are possible at this level. A graph-reviewer agent validates completeness and referential integrity. Zod schema validation catches malformed graphs on load. The LLM semantic layer is purely advisory: annotations are overlaid on the deterministic skeleton, and the latest pass simply overwrites the previous one. Fingerprint-based change detection preserves validated edges during incremental updates. For accumulated issues, a --full flag triggers a complete re-analysis from scratch.

4. pingcap/tidb — Distributed SQL Database for Agentic Workloads

Overview. A cloud-native distributed SQL database with MySQL compatibility, ACID transactions, HTAP (hybrid transactional/analytical processing), vector search via HNSW, and database branching designed for AI agents. TiDB can serve all four agent memory layers — short-term, episodic, procedural, semantic — in a single system.

Architecture & dependencies. Go runtime, Bazel build system. Storage is handled by TiKV (RocksDB + Raft consensus), with TiFlash providing columnar storage via Raft Learner nodes. A Placement Driver (PD) manages TSO timestamp allocation and load balancing. Kubernetes is the standard deployment mechanism via TiDB Operator.

Strengths.

• MySQL compatible — a drop-in replacement for many existing workloads
• HTAP eliminates the need for separate ETL pipelines
• True horizontal scaling with separated compute and storage
• AI-native features: database branching, durable agent state, vector search
• ACID distributed transactions via Raft + Percolator two-phase commit
• Generous free serverless tier: 5 GB storage, 50M RUs per month

Limitations.

• MySQL compatibility is not 100% — limited stored procedures and triggers
• Distributed system complexity requires significant operational expertise
• Dedicated clusters are expensive at scale
• Vector search is still in beta
• Self-hosted deployments need a minimum of 3 PD + 3 TiKV nodes

Conflict resolution approach. Raft consensus requires a majority quorum (2/3) for every write. Percolator two-phase commit uses TSO timestamps for global ordering. MVCC is implemented across three column families (Lock, Data, Write) with Snapshot Isolation. Both optimistic and pessimistic transaction modes are available, configurable per workload. Region splitting and rebalancing are handled automatically by the Placement Driver.

5. volcengine/OpenViking — Context Database for AI Agents

Overview. OpenViking is an open-source context database for AI agents that organizes memories, resources, and skills hierarchically using a filesystem paradigm (viking:// URIs). Its tiered context loading system (L0/L1/L2) is designed for token efficiency, and directory recursive retrieval makes it easy to pull related context.

Architecture & dependencies. Python 3.10+, Rust toolchain (Cargo), C++ compiler (GCC 9+). Supports VLM providers including Volcengine Doubao, OpenAI, Kimi, GLM, Gemini, and Ollama. Embedding providers span 13+ options. Deployment via Docker or Helm on Kubernetes.

Strengths.

• Up to 91% token reduction with 3.39x accuracy improvement over baseline
• Sub-0.2s retrieval latency
• Observable retrieval trajectories make RAG debuggable
• Self-evolving memory through automatic session management
• The filesystem paradigm is intuitive for developers
• Published at VLDB 2026 (peer-reviewed)

Limitations.

• Very early stage (v0.3.x, created January 2026)
• Complex setup requiring Python, Rust, C++, and model provider accounts
• AGPL-3.0 license is restrictive for commercial use
• Defaults lean heavily toward the Volcengine ecosystem
• Heavy external dependencies: VLM and embedding APIs are requirements, not options
• No explicit conflict resolution algorithm is documented

Conflict resolution approach. The filesystem hierarchy uses unique viking:// URIs to prevent naming conflicts. Tiered layers (L0/L1/L2) ensure consistent high-level signal even when L2 contains contradictions. End-of-session memory extraction uses VLM-driven synthesis to consolidate and resolve contradictions. Intent analysis via multi-condition retrieval helps disambiguate conflicting signals. Observable retrieval trajectories allow manual inspection of where conflicts arise.

6. supermemoryai/supermemory — Memory Engine & App

Overview. supermemory holds the #1 ranking across all three major AI memory benchmarks (LongMemEval, LoCoMo, ConvoMem). It provides memory extraction, user profiles (both static and dynamic), hybrid search combining RAG with direct memory retrieval, a rich connector ecosystem (Google Drive, Gmail, Notion, GitHub), and multi-modal file processing.

Architecture & dependencies. Built on Bun 1.2.17+ and TypeScript 5.8+. Heavily integrated with Cloudflare's ecosystem: Workers, Pages, KV, Hyperdrive, AI, and Workflows. PostgreSQL with Drizzle ORM for structured storage. Vercel AI SDK for LLM access (OpenAI, Anthropic, Google, Cerebras). The frontend uses Next.js 15, React 19, Hono, and TailwindCSS.

Strengths.

• Exceptionally simple API: add(), profile(), search.memories()
• Fast user profiles — ~50ms
• Automatic contradiction resolution with temporal supersedence
• Rich connector ecosystem with real-time webhooks
• MCP server, browser extension, and framework integrations
• MIT license

1 on all three major AI memory benchmarks

Limitations.

• Heavy Cloudflare lock-in: Workers, Pages, KV, AI, and Hyperdrive are all deeply embedded
• Requires external AI provider API keys
• Limited offline capability — fundamentally cloud-based
• Bun dependency is less universal than npm/pnpm/yarn
• Relatively young (~2.3 years) with an evolving API
• 22 open issues

Conflict resolution approach. Temporal supersedence is the core mechanism: newer facts override older ones (e.g., "I just moved to SF" supersedes "I live in NYC"). The split between static and dynamic profiles separates long-term stable facts from recent activity. Automatic forgetting expires temporary facts (like "exam tomorrow"). Ranked search surfaces the most relevant current facts first. The approach is benchmark-validated — LongMemEval explicitly tests contradiction resolution.

7. humanlayer/12-factor-Agents — Production Principles for LLM Software

Overview. Not a framework or library, but a methodology: 12 principles for building production-quality LLM-powered software, inspired by the 12-Factor App manifesto. Covers context ownership, control flow, state unification, human-in-the-loop patterns, and stateless reducer architecture.

Architecture & dependencies. None. This is documentation with code examples. References LangChain, CrewAI, LangGraph, OpenAI, and Anthropic by way of illustration.

Strengths.

• Pragmatic, production-tested philosophy grounded in real-world experience
• Framework-agnostic — applicable to any stack
• Modular 12 factors that can be adopted independently
• Real-world code examples in TypeScript and Python
• 22.9k stars indicate strong community validation

Limitations.

• Not a framework or library — there is no npm install that produces working agents
• Opinionated stance against frameworks may not suit all teams
• No releases or versioned artifacts
• Last commit was September 2025 (9+ months of inactivity)
• Skips MCP entirely
• TypeScript-centric examples

Approach to memory and conflict resolution. Factor 3 (Own Your Context Window) advocates for custom XML context formats with memory as part of context. Factor 5 (Unify State) uses a single thread of events as a unified history. Factor 9 (Compact Errors) enables LLM self-healing by reading errors in context. Factor 8 (Own Control Flow) keeps deterministic code responsible for handling LLM failures. Factor 12 (Stateless Reducer) treats the agent as (state, event) -> newState, where memory is accumulated state. Factor 10 (Small Agents) recommends 3-20 step agents to minimize conflict accumulation.

8. rohitg00/agentmemory — Persistent Memory for AI Coding Agents

Overview. The #1 ranked persistent memory for AI coding agents (95.2% R@5). Automatically captures tool calls, file accesses, decisions, and errors. Features 53 MCP tools, four-tier memory consolidation, a real-time viewer, and compatibility with 32+ agents via MCP.

Architecture & dependencies. Node.js 20+, iii-engine v0.11.2. Uses SQLite with an in-memory vector index — no external database required. Default embeddings come from @xenova/transformers (local). Optional remote embeddings via OpenAI, Voyage, Cohere, or Gemini. Approximately 21,800 LOC with 950+ tests.

Strengths.

• 95.2% R@5 retrieval significantly outperforms alternatives (68.5% for mem0, 83.2% for Letta)
• Zero external database dependency — SQLite + iii engine handle everything
• 53 MCP tools — the richest MCP surface of any project in this analysis
• Remarkably efficient: ~1,900 tokens per session, ~$10/year
• Works with 32+ agents via MCP
• Privacy-first: strips secrets and API keys from captured data
• Local embeddings work out of the box

Limitations.

• Pre-v1.0 (v0.9.x) — API may change
• iii-engine version pinning has caused issues
• Windows setup is involved
• LLM compression is opt-in and costs tokens
• No built-in authentication on the iii Console
• Documentation is sprawling and hard to navigate

Conflict resolution approach. A four-tier memory consolidation pipeline moves memories through Working → Episodic → Semantic → Procedural stages with decay. Ebbinghaus decay fades unused memories and evicts contradictory older entries. Versioning and supersession mean new observations override contradictory older ones. Importance-based eviction prunes conflicting low-importance entries. Confidence scoring combines frequency and recency. The consolidation pipeline uses graph extraction and slot reflection to detect conflicts. Manual override is available through forget and remember skills.

9. memvid/memvid — Single-File Memory Layer for AI Agents

Overview. memvid packages an entire memory layer — data, embeddings, search indices, and write-ahead log — into a single portable .mv2 file. Features hybrid search (BM25, HNSW, SimHash, Time), multi-modal support (text, PDF, images, audio), and time-travel debugging.

Architecture & dependencies. Rust 1.85.0+, Tantivy for BM25, in-house HNSW, ONNX Runtime. Optional dependencies include CLIP for images, Whisper for audio, and OpenCV. Embeddings can be cloud-based (OpenAI) or local (ONNX). SDKs available for Rust, Python, and Node.js.

Strengths.

• Truly portable: one .mv2 file, no server, no database
• Sub-5ms local memory access (0.025ms P50)
• +35% over SOTA on LoCoMo, +76% on multi-hop reasoning
• Multi-modal: text, PDF, images, and audio in a single memory store
• Crash-safe embedded write-ahead log
• Offline-first with local ONNX support
• Time-travel queries on any past state

Limitations.

• Very new (~1 year old, created May 2025)
• Rust-only core limits the contributor pool
• Manual model downloads from Hugging Face required
• Single file can grow large with no built-in sharding
• Limited enterprise track record
• v1 was deprecated with breaking changes

Conflict resolution approach. Append-only immutable frames mean no in-place updates — complete history is preserved. Time-travel queries can reconstruct any past state, with recency-based resolution. SimHash near-duplicate detection runs at ingest time. A Logic Mesh stores entity-relationship triples with temporal tracking. The embedded WAL ensures crash safety and atomic commits. Model consistency enforcement prevents incompatible embeddings from being mixed. The system produces deterministic output: identical inputs always produce identical results.

10. vectorize-io/hindsight — Agent Memory That Learns

Overview. hindsight is an agent memory system focused on genuine learning rather than simple recall. It organizes memories biomimetically into World Facts, Experiences, and Mental Models, with four parallel recall strategies (semantic, BM25, graph, temporal). Its signature innovation is the reflect operation, which synthesizes new understanding from existing memories.

Architecture & dependencies. Python 3.11+, FastAPI, Uvicorn. Requires PostgreSQL with pgvector (or Oracle 23ai). Uses SQLAlchemy 2.x with Alembic for migrations. sentence-transformers and torch provide ML capabilities. LLM providers supported include OpenAI, Anthropic, Google, Groq, Ollama, and LM Studio. Optional: llama.cpp for local LLMs, flashrank for reranking.

Strengths.

• State-of-the-art benchmarks: 91.4% LongMemEval, 89.61% LoCoMo
• Genuine learning via the reflect operation and mental models
• Four parallel retrieval strategies fused and reranked
• Simple three-operation API with a two-line LLM wrapper
• Fully offline capable with local llama.cpp and embeddings
• MIT license with active development (57 releases)
• Academic paper on arXiv (2512.12818)

Limitations.

• Requires PostgreSQL with pgvector (or Oracle 23ai) — not lightweight
• Python 3.11+ only
• LLM-dependent for both retain and reflect — latency and cost considerations
• Complex production infrastructure
• v0.x stage (v0.7.1) — API may evolve
• Heavy dependency footprint (OpenTelemetry, multiple LLM SDKs, etc.)
• GPU recommended for local ML workloads

Conflict resolution approach. During the retain phase, an LLM normalizes incoming data into canonical facts, entities, and relationships. The reflect operation performs deep analysis, synthesizing understanding by weighing evidence and applying temporal ordering. An entity resolution pipeline links references to the same entity across memories. All memories are timestamped, enabling temporal retrieval to resolve ordering. Four parallel retrieval strategies surface conflicting information, and cross-encoder reranking prioritizes the most reliable results. Disposition traits (configurable skepticism, literalism, empathy) affect how contradictions are resolved. Periodic consolidation processes reprocess memories into robust mental models.

Cross-Cutting Analysis

Dependencies Comparison

Key insight. Three projects can run fully offline with zero external dependencies: MemPalace, agentmemory, and memvid. The rest require external LLMs, cloud services, or both. This is the single most important axis of differentiation for teams with privacy, latency, or cost constraints.

Conflict/Contradiction Resolution Comparison

Key insight. Two fundamentally different philosophies emerge:

1. Deterministic conflict resolution (MemPalace, TiDB, memvid): rules-based, predictable, lower operational cost, but less flexible in the face of ambiguity.
2. LLM-driven conflict resolution (mem0, supermemory, agentmemory, hindsight): flexible and context-aware, but introduces latency, cost, and model-dependent variability.

Pros/Cons Summary Matrix

Conflict Resolution Taxonomy

Across the memory ecosystem, six distinct conflict resolution strategies emerge:

1. Temporal Supersedence (mem0, supermemory, hindsight)
   Newer facts override older ones. The most common and intuitive approach — what you reach for when you need a simple, effective model.
2. Versioned Append-Only (memvid)
   Nothing is ever deleted or overwritten. Conflicts are resolved at query time through temporal queries and ranking. Maximum fidelity at the cost of storage growth.
3. Temporal Validity Windows (MemPalace)
   Facts carry explicit valid_from/valid_to dates. Queries use as_of timestamps. This approach can model "formerly true, now false" facts explicitly — something temporal supersedence handles less cleanly.
4. LLM-Driven Synthesis (mem0, supermemory, agentmemory, hindsight, OpenViking)
   An LLM processes contradictory entries and synthesizes a consistent view during consolidation or reflection. Flexible and context-aware, but introduces model-dependent variability.
5. Multi-Axis Ranking (mem0, agentmemory, hindsight)
   Multiple retrieval signals (semantic, BM25, entity, temporal) are fused. The most relevant fact surfaces via ranking rather than explicit conflict detection — a pragmatic approach that sidesteps the hard problem of deciding what is "correct."
6. Deterministic Prevention (Understand-Anything, TiDB)
   Architecture prevents conflicts at the structural layer (Raft consensus, deterministic parsers). Conflict resolution logic is minimal because conflicts are designed to be impossible.

Recommendations

For maximum privacy or offline use.
MemPalace or memvid. Both are fully local, require no API calls, and offer strong performance guarantees. MemPalace if you need verbatim accuracy and rich knowledge graph features; memvid if you need portability and multi-modal support.

For quickest integration or easiest API.
supermemory offers the simplest API with the best benchmark scores. agentmemory is equally easy to get started with (npx install, auto-capture) and adds the richest MCP integration.

For maximum flexibility or provider choice.
mem0 leads with 30+ vector stores, 24+ LLM providers, and 15+ embedders. No other project comes close in ecosystem breadth.

For production database needs.
TiDB provides ACID transactions, HTAP, vector search, and database branching for agents — a single system that can serve all agent memory layers at scale.

For codebase understanding.
Understand-Anything is the clear choice for transforming codebases into interactive knowledge graphs, especially if you work across multiple AI coding platforms.

For true learning — not just recall.
hindsight's reflect operation and mental model approach stand alone. If you need an agent that genuinely synthesizes new understanding from experience, this is the one.

For architecture principles.
12-Factor Agents is worth reading for any team building production LLM applications, even if it is a methodology rather than a tool.