When you spend a day stitching together prompts, pulling data from a pipeline, and then trying to remember what decision you made in the last session, the friction shows up as wasted time. The problem is not the model itself -- it is the memory layer that sits between you and the model. Over the past year four approaches to Claude memory have emerged. This post compares them directly: the Claude Memory Primitive, claude-mem, mem0, and LoreConvo. I have written individual deep-dives on LoreConvo vs mem0 and LoreConvo vs claude-mem; this post consolidates the full four-way picture in one place. The goal is a clear picture of the trade-offs in architecture, cost, privacy, and workflow so you can pick the tool that matches your situation. I have tried all four; I built LoreConvo, so I will tell you exactly where the others win.
Architecture and data ownership
The most obvious difference is where the memory lives.
The Claude Memory Primitive stores session snippets in a cloud-hosted graph that Anthropic manages. You send a request, Claude returns a short summary, and the service keeps a record tied to your API key. This model is the simplest to start with, but the data never leaves Anthropic's environment. For teams that must comply with strict data-handling policies, that retention is a deal-breaker.
claude-mem adds a thin layer that converts the graph into a JSON file on the client side. The file is written to a local directory, but the tool periodically syncs it back to a remote store for backup. The result is a hybrid: you get a local copy you can inspect, but you also rely on a cloud service for durability. For a lot of solo developers who just want Claude to remember what they figured out last Tuesday, that automatic behavior is exactly right.
mem0 takes a different route. It builds a vector store on top of a local database using an embedding model to index each interaction. The library exposes memory management operations that let you add, query, and delete memories programmatically. Because the index lives on your machine, you have full control -- but you also manage the embedding model yourself, which adds both complexity and ongoing cost.
LoreConvo uses a local-first design that combines portability with cross-surface reach. All session data lands in a single SQLite file you own. The file can be moved, backed up, or versioned with any tool you already use -- there is no hidden cloud component. At the same time, the MCP server exposes the memory layer to Claude Code, OpenAI Codex, Cursor, and Hermes Agent without any per-client configuration. You drop a .mcp.json file in the project root and the server discovers it automatically. Because the storage is local, privacy is guaranteed: only you, or teammates you explicitly share with, can read the file.
Pricing and scalability
Cost is another axis where the four diverge.
The Claude Memory Primitive is bundled with Claude API usage fees. There is no separate memory charge, but every call that reads from or writes to the graph incurs API cost. For a solo developer on a laptop this can be inexpensive; for a team running hundreds of sessions per day the extra calls add up quickly.
claude-mem is free to install. The optional remote backup service is priced per gigabyte stored. A few megabytes of session data costs almost nothing; once you archive weeks of history the price scales linearly with usage.
mem0 itself is free, but you need to provision an embedding model. Using a hosted embedding API typically costs a few cents per thousand tokens, and running a local model draws on GPU resources. For data engineers who already have GPU capacity the marginal cost is low, but for smaller teams the external API fees become a hidden expense that compounds over months.
LoreConvo offers a predictable two-tier structure. The free tier gives you up to fifty sessions, which covers most experimentation and short-term projects. Pro costs eight dollars per month and removes the session limit while adding semantic search, related-session discovery, and team memory sharing. All of those features run against the same local SQLite file, so there are no per-call fees layered on top. For a solo developer, Pro costs less than the extra API calls that the cloud-native options typically generate, and for a small team the flat monthly price makes budgeting straightforward.
Privacy and control
When you hand data to a cloud service you implicitly trust the provider's security practices. The Claude Memory Primitive encrypts data in transit and at rest, but Anthropic retains a copy. If you are working with proprietary code, regulated datasets, or internal architecture decisions, that retention introduces compliance risk.
claude-mem's hybrid approach gives you a local copy you can audit, but the remote backup still stores the data in a third-party bucket. You can disable the sync, but then you lose the automatic durability feature -- and you have to remember to disable it consciously.
mem0 puts the entire responsibility on you. The index files are local and inspectable with standard tools. However, the library does not enforce access controls, so any process with file system access can read the memories. You must set up your own OS-level permissions.
LoreConvo's design is built around ownership. The SQLite file lives in a directory you choose, and the memory inspection UI lets you list, filter, and delete sessions with a single command. The auto-save hook runs at the end of every session without any user action. It extracts a heuristic summary that captures decisions, tech-stack facts, and open questions when the session contains enough signal -- this is best-effort, not a guarantee on every save. Because the data never leaves your machine, you retain full control. Pro users can export selected sessions to JSON and let a teammate import them, all without a central server.
Which tool fits your situation
If you need zero setup and are comfortable with Anthropic managing your memory in the cloud, the Memory Primitive is the fastest path. It works well for quick prototypes where privacy is not a concern and you are not already paying close attention to API usage.
claude-mem earns its 45,000 GitHub stars. If you want a local copy with automatic backup and you are comfortable with the hybrid cloud model, it is the most polished community option. The seamless capture -- you keep working and your conversations get remembered -- is genuinely useful for solo developers who do not want to think about the memory layer.
mem0 wins for teams that need deep vector search and are willing to manage the embedding infrastructure. If you are building pipelines that benefit from semantic similarity lookups across thousands of stored facts, and you have the GPU or the API budget to support that, mem0 gives you more retrieval depth than the other options.
LoreConvo fits the practitioner who wants a portable, ownable file with cross-surface reach and predictable costs. The FTS5 full-text search handles most recall needs without an embedding layer. Session linking, project tagging, and the auto-load hook create context chains across runs without manual bookkeeping. If you work across multiple surfaces -- Claude Code in the morning, Cursor in the afternoon, a headless pipeline at night -- LoreConvo carries the same memory layer to all of them. The Python fallback script save_to_loreconvo.py lets any script read or write memories without registering an MCP tool, keeping the integration lightweight for automation.
For data engineers running multiple pipelines, the combination of skill history tracking, project tagging, and session linking turns the memory store into a lightweight audit trail: what decisions drove each pipeline design, which schemas changed and why, and where to pick up a refactor that stalled two weeks ago.
Bringing it together
The honest answer is that none of these four tools is wrong for every use case. The Claude Memory Primitive is the zero-friction starting point. claude-mem is the community-built standard that most developers reach for first. mem0 is the right choice when you need semantic retrieval at scale and can manage the embedding overhead. LoreConvo is the option when you want a single file you own, cross-surface reach you do not have to configure per client, and a flat monthly cost that does not scale with query volume.
You can see the full LoreConvo tool set and install instructions at /tools. If you are comparing these options for a specific pipeline or agent architecture, reach out -- I am happy to walk through the trade-offs for your stack.
PS: Get posts like this delivered weekly -- subscribe to Dispatches from the Labyrinth.