Mnemoverse Docs

Appearance

Landscape of Memory Solutions for LLM Agents ​

Last Updated: 2025-08-27
Version: 1.3.0

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.

Repository

github.com/letta-ai/letta — ★18.1k, forks 1.9k; license Apache-2.0; language: Python ~99%; last commit August 12, 2025.

9 Zep ​

Long‑term memory service built on a temporal knowledge graph (Graphiti).

What’s good (dev‑relevant):

  • Temporal KG with incremental updates → consistent facts over time, better than plain RAG for changing data.
  • SDKs (Python/TS/Go), guides for LangChain/LangGraph/Autogen; works in modern agent stacks.
  • Graph queries (paths, entities, time) enable multi‑hop reasoning.

Why it’s useful:

  • Temporal queries handle fact changes and recency cleanly; suits agents that need durable memory beyond simple vector recall.

Open source status:

  • Graphiti and Zep repos are open (Apache‑2.0). Zep CE is legacy; focus shifted to Graphiti + Zep Cloud.
Repositories
  • 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.

Repository

github.com/mem0ai/mem0 — ★38.8k, forks 4k; license Apache-2.0; languages: Python/TS; last commit August 21, 2025.

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.

Repository

github.com/langchain-ai/langgraph — ★17.8k, forks 3.1k; license MIT; language: Python ~99%; last commit August 21, 2025.

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.

Architecture: Zep is a memory layer for AI agents based on a 'temporal knowledge graph'. At its core lies the Graphiti library, which allows building and querying dynamic knowledge graphs with time consideration. Graphiti continuously integrates user interactions and business data into a unified graph structure, supporting incremental updates and efficient search by embeddings, keywords, and graph trajectories. This implementation gives Zep an advantage over the classic RAG approach: the graph remains consistent, and temporal queries allow accurately accounting for fact changes. Zep uses the Graphiti graph subsystem as the 'core' of the contextual engineering platform, providing a ready-made memory service for agents.

License and Support: Zep and Graphiti projects are distributed under the Apache 2.0 license. Previously, there was an open edition Zep CE (Community Edition), but in April 2025, developers announced the cessation of its active support: the repository remains open under Apache 2.0, but there will be no further updates for CE. The company's focus has shifted to Graphiti (also Apache 2.0) as the basis for the memory system. Thus, the code remains open, but user support in Zep Community Edition has ceased.

Integrations and Compatibility: Zep has built-in support for popular frameworks and SDKs. For example, a guide has been released for integrating Zep with Vercel AI SDK (for Next.js). Documentation and communities note compatibility with LangChain/LangGraph and Microsoft Autogen: Zep can be used as a memory layer in LangChain and LangGraph applications, as well as provide long-term memory in Autogen-based projects. Zep offers SDKs for Python and JavaScript/TypeScript, supporting installation via pip install zep-cloud and npm packages. Thus, the Zep platform is ready for embedding in many modern agent stacks.

Development Activity: The projects are actively developing. The Zep GitHub repository shows more than 3.6k ★ and 537 forks. The latest commits were made at the end of August 2025 (for example, August 27, 2025). The Graphiti library is very popular – about 17.3k ★ and 1.5k forks. The Graphiti community is growing rapidly: as of July 2025, the project gained almost 14k stars on GitHub and 35+ contributors. This reflects the wide acceptance of Graphiti, especially thanks to its ability to accelerate knowledge graph development through MCP server.

Repositories
  • Zep examples/integrations: github.com/getzep/zep — ★3.6k, forks 537; languages: Python ~47%, Go ~38% (as of 2025-08-27).
  • Graphiti core: github.com/getzep/graphiti — ★17.3k, forks 1.5k; language: Python ~99%; last release v0.18.9 (2025-08-19).

Pros: Temporal KG; high accuracy/low latency; active OSS ecosystem (Graphiti).
Cons: Requires separate service/graph DB; Zep CE — legacy.

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.

Repository

github.com/langchain-ai/langmem — ★982, forks 114; license MIT; language: Python ~99%; last commit July 9, 2025.

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.

Repository

github.com/BAI-LAB/MemoryOS — ★642, forks 59; license Apache-2.0; language: Python; last commit July 29, 2025.

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.

Repository

github.com/kingjulio8238/memary — PyPI package; release 0.1.1 published (see Releases).

Comparative feature matrix ​

SolutionHierarchicalKnowledge graphVector retrievalEvent triggersAgent runtimeSaaSGUILicense
Letta✅❌✅✅✅❌Dev onlyApache‑2
Cognee❌✅✅❌❌⚠️*CypherApache‑2
Mem0✅⚠️✅❌⚠️✅❌Apache‑2
LangGraph⚠️*⚠️*✅⚠️✅❌Graph‑DSLMIT
LangChain⚠️*❌✅❌✅❌LangSmithMIT
LlamaIndex⚠️*❌✅❌✅❌❌Apache‑2
SemKernel❌❌✅❌⚠️✅ (Azure)❌MIT
OpenAI Memory❌❌⚠️❌✅✅❌Proprietary
Zep✅†✅✅⚠️⚠️✅Web consoleBSL‑v
Pinecone + LC❌❌✅❌❌✅❌Proprietary
LangMem⚠️*❌✅❌⚠️❌❌MIT
MemoryOS✅❌✅❌✅❌❌Apache-2.0
A-MEM❌❌✅❌❌❌❌MIT
Memary❌✅✅❌❌❌StreamlitMIT

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)
  13. Official GitHub repositories and Zep/Graphiti documentation; Zep developers' blog for license and development strategy information (blog.getzep.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: