Mnemoverse Docs

Appearance

Landscape of Memory Solutions for LLM Agents ​

Last Updated: 2025-07-28
Version: 1.0.1

Abstract ​

The modern "memory stack" for large‑language‑model agents spans from low‑level vector stores to full agent runtimes. This report surveys ten notable open‑source (or open‑core) projects, summarises their architectures, strengths and weaknesses, and maps common gaps where new research—such as Mnemoverse's hyperbolic, spatial memory—could create value.

Solutions analysed ​

1 Letta (ex‑MemGPT) ​

Technologies & Architecture

  • Memory Kernel orchestrates short‑/long‑term stores with automatic eviction. (letta.com)
  • Structured MemoryEntry objects carry source, salience, timestamp, importance. (letta.com)
  • Agents call system functions (mem_read, mem_write, search_memory). (letta.com)
  • Event‑driven triggers fire workflows when memory changes. (letta.com)
  • Pluggable back‑ends (OpenAI, Claude, vLLM, Ollama). (letta.com)
  • Default storage stack: Docker + PostgreSQL.
  • System Call Interface (memory_replace, memory_rethink, memory_append) for programmatic mutation of memory blocks.

Strengths

  • Full OS‑style abstraction; white‑box and highly extensible.
  • Event hooks enable reactive agents.
  • Active community (>17k GitHub stars).

Weaknesses

  • Steep learning curve; OS‑style abstractions add complexity.
  • No built‑in knowledge graph.
  • Dev‑only debug UI—no visual graph viewer.
  • External‑data ingest (PDFs, DBs) requires custom glue.

2 Cognee ​

Technologies & Architecture

  • ECL pipeline (Extract → Cognify → Load) populates knowledge‑graph + vector DB. (cognee.ai)
  • Graph store: Neo4j or Memgraph; vector store: Qdrant / Weaviate. (cognee.ai)
  • LLM Enricher normalises entities and adds relations. (cognee.ai)
  • Dynamic Ontology Builder auto‑creates hierarchies. (cognee.ai)
  • 30+ connectors (Notion, Confluence, S3, PDFs …).
  • Community vs Core split – open‑source Community edition vs enterprise‑grade Core (June 2025).
  • Native Qdrant integration; new Redis & Azure Search back‑ends.
  • RBAC permissions layer & audit logging.
  • Associative MCP Memory for dynamic cross‑domain links.

Strengths

  • Powerful graph queries (Cypher) for multi‑hop reasoning.
  • Scales to data‑lakehouse via Iceberg integration.
  • Fine‑grained security (RBAC) and SaaS beta now available.

Weaknesses

  • Requires graph‑DB operations expertise.
  • Agent runtime still absent; SaaS in beta.

3 Mem0 ​

Technologies & Architecture

  • Three layers: User, Session, Agent. (mem0.ai)
  • LoCoMo pipeline extracts, clusters and summarises salient facts. (mem0.ai)
  • SaaS platform (OpenMemory MCP) with optional self‑host; supports optional graph-based memory (Neo4j / Memgraph). (mem0.ai)

Strengths

  • Production‑ready hosted API; minimal infra.
  • LOCOMO benchmark: +26% accuracy, −91% latency vs. full‑context. (mem0.ai)

Weaknesses

  • Open-source core (Apache-2); pipeline logic not easily customizable.
  • Primarily vector store — graph mode optional; still no built-in event triggers.
  • Advanced features gated to cloud tier.

4 LangGraph ​

Graph‑based state‑machine layer built atop LangChain.

  • Namespace‑scoped long‑term memory with checkpointing.
  • LangChain v0.3.x deprecates legacy Memory classes in favour of LangGraph persistence.
  • Compose workflows as nodes/edges; integrates any LangChain Memory store.

Pros: Visual graph DSL; interoperates with LangChain ecosystem.
Cons: Early‑stage (beta) docs; thin abstraction over underlying memory type.

5 LangChain Memory Modules ​

Legacy memory classes (ConversationBufferMemory, WindowMemory, etc.) deprecated as of LangChain v0.3; migrate to LangGraph checkpointing.

  • Vector back‑ends such as Pinecone still available for persistence.

Pros: Fast prototype; rich catalogue; ties into agents & tools.
Cons: Simple eviction (truncate/window); no hierarchy; your infra bill.

6 LlamaIndex Contextual Memory ​

Customisable BaseMemory that stores interaction nodes with context‑window IDs. (docs.llamaindex.ai)

Pros: Flexible retrievers; Ray scaling; integrates with 20+ index types.
Cons: Memory model ad‑hoc; no automatic eviction.

  • Added multi‑modal retrieval (images, figures) and sample Agent Memory recipes (July 2025 newsletter).

7 Semantic Kernel / Kernel Memory ​

Microsoft's service layer for RAG + memory.

  • Pluggable stores (PostgreSQL, Redis, Azure Search …).
  • v1.61.0 (24 Jul 2025) adds AgentKernelPluginFactory.CreateFromAgents, improved OpenAPI plugin support.
  • C# / Python / Java SDK; secure, multi‑tenant.

Pros: Enterprise‑ready; strong security model.
Cons: .NET bias; memory not hierarchical.

8 OpenAI Memory (ChatGPT & Assistants) ​

  • Two layers: explicit Saved Memories and Reference History; Project Memory improvements (June 16 release) extend recall across grouped chats.
  • Rolling out to free tier (July 2025) with user controls. (axios.com)

Pros: Zero‑setup; deep integration with OpenAI models.
Cons: Closed‑source; no event hooks; privacy trade‑offs.

9 Zep ​

Long‑term memory service that builds a temporal knowledge graph from interactions.

Pros: Temporal KG; high accuracy & low latency; active OSS roadmap.
Cons: New player; requires separate service; licence currently BSL‑v.

10 Pinecone + VectorStoreMemory ​

Using Pinecone as persistent store behind LangChain ConversationVectorStoreMemory. (docs.pinecone.io, python.langchain.com)

Pros: Managed vector DB at scale; straightforward integration.
Cons: Pure vector recall—no hierarchy, eviction, or graph semantics.

11 LangMem ​

Technologies & Architecture

  • Functional primitives for memory recording and search (record_memory, query_memory).
  • Background consolidation daemon merges redundant entries and refines prompts.
  • Native integration with LangGraph checkpointing; works with any storage.

Strengths

  • Tight integration with LangChain/LangGraph ecosystem.
  • MIT-licensed; lightweight Python package.

Weaknesses

  • Early-stage; limited visual tooling.
  • No built-in knowledge graph; depends on configured store.

12 MemoryOS ​

Technologies & Architecture

  • Four-level hierarchy (Short-, Mid-, Long-, Profile-term).
  • MemoryOS MCP server with gRPC; Rust core + Python client.
  • GPU-accelerated vector index and Chromadb back-end.

Strengths

  • SOTA on LoCoMo (+49 % F1).
  • OS-style abstraction; open-source Apache-2.0.

Weaknesses

  • Heavy stack (Rust + GPU).
  • Docs still evolving; no SaaS yet.

13 A-MEM (Agentic Memory) ​

Technologies & Architecture

  • Zettelkasten-style note+link model; dynamic linking operations.
  • PyTorch + Faiss implementation; research-oriented.

Strengths

  • Demonstrates "memory evolution" concept; benchmarks on LoCoMo and A-MEM BENCH.
  • MIT licensed.

Weaknesses

  • Prototype quality; no production deployment path.
  • Vector-only; no event triggers or SaaS.

14 Memary ​

Technologies & Architecture

  • Local-first memory layer supporting Ollama/LLamaCPP LLMs.
  • Writes to Neo4j or FalkorDB for knowledge graph; Streamlit GUI.

Strengths

  • Easy self-host; works offline.
  • MIT licence; small footprint.

Weaknesses

  • Limited scaling; no hosted option.
  • Sparse documentation; small community.

Comparative feature matrix ​

FeatureLettaCogneeMem0LangGraphLangChainLlamaIndexSemKernelOpenAI MemoryZepPinecone + LCLangMemMemoryOSA-MEMMemary
Hierarchical memory✅❌✅⚠️*⚠️*⚠️*❌❌✅†❌⚠️*✅❌❌
Knowledge graph❌✅⚠️⚠️*❌❌❌❌✅❌❌❌❌✅
Vector retrieval✅✅✅✅✅✅✅⚠️✅✅✅✅✅✅
Event triggers✅❌❌⚠️❌❌❌❌⚠️❌❌❌❌❌
Agent runtime✅❌⚠️✅✅✅⚠️✅⚠️❌⚠️✅❌❌
SaaS offering❌⚠️*✅❌❌❌✅ (Azure)✅✅✅❌❌❌❌
Visual GUIDev onlyCypher❌Graph‑DSLLangSmith❌❌❌Web console❌❌❌❌Streamlit
LicenseApache‑2Apache‑2Apache‑2MITMITApache‑2MITProprietaryBSL‑vProprietaryMITApache-2.0MITMIT

Legend:

  • ⚠️* = Inherits capability from the configured memory store
  • ✅† = Zep's KG is temporal and layered (facts vs. chat)
  • ⚠️ = Limited or partial support
  • ✅ = Full support
  • ❌ = Not supported

Note ⚠️ = Beta wait‑list.*

Common gaps & opportunities ​

  • Spatial / hyperbolic topology is absent across the board, limiting global reasoning and intuitive visualisation.
  • Unified 3‑D workspace for both humans and agents has not yet emerged.
  • Reasoning‑on‑memory remains shallow; most systems act as passive retrieval caches rather than active cognitive modules.
  • Multi-modal memory (images, audio, video) is not systematically integrated.
  • Collaborative memory between agents is in its infancy.

These gaps align with Mnemoverse's roadmap: GPU‑native hyperbolic embeddings, agent drop‑crumbs forming dynamic edges, and WebGL‑based spatial UI.

Significance for Mnemoverse ​

This analysis reveals specific opportunities where Mnemoverse can create unique value:

Immediate Competitive Advantages ​

  1. Hyperbolic Memory Representation: While Letta, Mem0, and MemoryOS offer hierarchical memory, none use hyperbolic geometry for efficient representation of hierarchical relationships. This could provide exponential space savings for deep knowledge structures.
  2. Spatial Memory Interface: All solutions lack intuitive spatial visualization. LangGraph's Graph-DSL is developer-focused, while Mnemoverse's WebGL interface targets end-users.
  3. GPU-Optimized Architecture: Current solutions (LangChain, LlamaIndex) rely on CPU-based vector operations. Mnemoverse's GPU-first approach could provide 10-100x performance improvements for large memory graphs.
  4. Performance Benchmarking: MemoryOS achieves SOTA on LoCoMo (+49% F1), but Mnemoverse's hyperbolic approach could potentially exceed this through more efficient spatial representation.

Strategic Positioning Opportunities ​

  1. LangChain Ecosystem Integration: LangChain's modular design allows Mnemoverse to become the spatial memory provider. Target: SpatialMemoryStore class that integrates with existing ConversationBufferMemory.
  2. Mem0 Enhancement Layer: Mem0's black-box approach creates opportunity for Mnemoverse to provide spatial visualization layer. Target: OpenMemory MCP protocol extension.
  3. Letta Complementary Solution: Letta's OS-like abstraction could benefit from Mnemoverse's spatial memory kernel. Target: Memory visualization module for Letta's debug UI.
  4. LangMem Integration: LangMem's consolidation daemon could be enhanced with Mnemoverse's spatial memory concepts for better memory organization.
  5. Local-First Alternative: Memary's local-first approach shows demand for offline memory solutions. Mnemoverse could provide a more sophisticated local spatial memory option.

Specific Technical Challenges to Address ​

  1. Hyperbolic Embedding Scalability: Current hyperbolic neural networks struggle with >1M embeddings. Need to develop efficient approximation algorithms.
  2. 3D Interface Performance: WebGL rendering of large memory graphs requires optimization. Target: 60fps with 100k+ memory nodes.
  3. Integration Complexity: Each solution (LangChain, Mem0, Letta, MemoryOS) has different memory APIs. Need to develop unified spatial memory interface.
  4. Benchmark Competition: MemoryOS's SOTA performance on LoCoMo creates a high bar. Need to demonstrate that hyperbolic spatial memory can achieve comparable or better results.

See Also ​

Sources ​

  1. Letta documentation and landing page (letta.com)
  2. Cognee website & Iceberg deep‑dive (cognee.ai)
  3. Mem0 research note on LOCOMO benchmark (mem0.ai)
  4. LangGraph long‑term memory concept docs (langchain-ai.github.io)
  5. LangChain ConversationBufferMemory API (python.langchain.com)
  6. Pinecone × LangChain integration guide (docs.pinecone.io)
  7. LlamaIndex memory module guide (docs.llamaindex.ai)
  8. Kernel Memory GitHub README (github.com)
  9. OpenAI memory announcement & Axios follow‑up (openai.com, axios.com)
  10. Zep product page + GitHub + Graphiti repo + Autogen notebook (getzep.com, github.com, github.com, microsoft.github.io)
  11. Pinecone vector store memory example (python.langchain.com)
  12. LangChain VectorStoreMemory practice article (apxml.com)

This research is conducted as part of the Mnemoverse project and is regularly updated to reflect the latest trends in AI agent memory.

Explore related documentation: