Mem0 uses a dedicated middleware layer to manage memory before and after an LLM call.
\nThe memory layer could be deterministic or not. It can potentially incorporate different types of memory, such as conversational, session, user, and agentic memory.
\nThe memory layer is pluggable and can be used with any agent.
\nConversational memory stays only in the context.
\nAs the context window fills up, older messages in the session are truncated from the context.
\nHowever, facts from previous conversations are not necessarily lost. At every turn, the memory management layer extracts relevant facts and persists them in a database.
\nThe exact conversation itself is not persisted (unless infer=False).
\nEpisodic memory is scoped at the run_id level.
The extraction pipeline extracts metadata such as timestamps and graph snapshots.
\nSemantic memory is scoped at the user_id level.
The extraction layer persists this information in a vector store.
\nMem0 has four layers of memory based on how long the information lives:
\nUser memory and agent memory are stored in vector databases, with relationships between them.
\nMemGPT is inspired by operating systems that have different layers of memory, such as RAM and hard disk.
\nThe idea is to create a hierarchical memory system.
\nIt has:
\nThe key difference is that the memory content is completely handled by the agent using tools.
\nThere is no intermediate memory layer managing the memory for the agent. Memory management is therefore tightly coupled to the agent itself.
\nConversational memory is present in a FIFO queue.
\nWhen the context starts filling up, older conversation is summarized.
\nThis is the recall memory.
\nIt is essentially a literal database of raw chronological events.
\nNo semantic search is performed here.
\nSemantic memory is stored in the working context as human memory and persona memory.
\nIf it gets too large, it is pushed to archival memory.
\nThe context window therefore looks roughly like:
\n+------------------------------------------------------+\n| System prompt | Working context (persona) | FIFO queue |\n+------------------------------------------------------+\n Context windowA-mem is inspired by note-taking methods such as Zettelkasten, where notes form a hierarchy and are connected to one another.
\nEvery fact is atomic and can be connected to other facts.
\nEvery memory an atomic memory.
\nThe immediate next step is to enrich the text with a structured schema so that it becomes a better base for semantic memory.
\nNext, links are generated.
\nThe top k existing notes are compared with the new note, and links are created if a relationship exists.
If a link is made, older notes can also be edited with additional information such as tags or keywords if needed.
\nOnly one or two turns of conversation are persisted in the context window.
\nAfter the context window slides, the conversation is converted into an atomic note and becomes part of the knowledge graph with a session_id tag.
Small language models are used for fast note-taking.
\nBoth A-mem and Mem0 use LLMs/SLMs for the memory layer.
\nOne way I see the difference between Mem0 and A-mem:
\nMem0:
\nA-mem:
\n| \n | Mem0 | \nA-MEM | \n
|---|---|---|
| Basic unit | \nMemory/fact | \nNote | \n
| Organization | \nRetrieval-oriented memory store | \nInterconnected memory network | \n
| Linking | \nEntity-aware relationships / graph mechanisms | \nSimilarity-based note links | \n
| Evolution | \nExtract/update/deduplicate memories | \nNew memories can modify existing notes | \n
| Memory management | \nDedicated memory layer | \nAgentic memory construction | \n
| Core idea | \nRemember useful facts | \nBuild an evolving network of notes | \n
One way to think about the evolution is:
\n MemGPT\n ↓\n Hierarchical memory\n ↓\n Agent manages memory using tools\n\n\n Mem0\n ↓\n Dedicated memory management layer\n ↓\n Memory extraction + storage happens around LLM calls\n\n\n A-mem\n ↓\n Memory as interconnected atomic notes\n ↓\n New memories create links and evolve existing notesThe interesting progression is that memory moves from being primarily a storage hierarchy toward becoming an active, evolving knowledge structure.
\n