LLMSlim vs Mem0. An honest comparison.

From Mem0's documentation and its GitHub repository, read on 2 November 2026. Mem0's documentation also covers add with infer=False, which stores messages without extraction; Mem0's harness, and so round 3, used the default.

1. 01

   Verbatim storage

   add stores each turn as it was said, with its time and scope. Nothing is summarized or extracted, so a stored turn can't become a wrong fact. When something changes, both turns stay, each under its date, and the model sees which is newer.

2. 02

   No LLM calls on write

   Storing makes no model call, so adding memory costs nothing per message and works offline. In round 3, building Mem0's memory on Claude Haiku 5.5 was $1.76 of its $2.66 per 1,000 LoCoMo questions, and about $0.22 a question on LongMemEval's 500-message histories.

3. 03

   Selection at question time, within a budget

   search ranks user turns and windows of replies against the question, and returns what fits the token budget you give, in date order. Relevance is lexical by default: no model, deterministic. relevance="semantic" adds a 22M-parameter cross-encoder that runs on a CPU.

4. 04

   Self-hosted on SQLite, Postgres or MongoDB

   One pip install. Memory lives in a SQLite file by default, in Postgres for several processes or machines, or, from 1.0, in MongoDB. There is no vector database to run and no embedding service to host.

5. 05

   An MCP server and an HTTP API

   llmslim mcp gives Claude Code, Claude Desktop, Cursor and other MCP clients remember, recall, forget and fit_context tools. llmslim serve puts the same memory behind a JSON API, with a TypeScript client for the Vercel AI SDK and Mastra.

6. 06

   A Mem0-compatible facade

   from llmslim.memory.compat import Mem0Memory as Memory keeps Mem0 2.x method names, keyword arguments and return shapes, so most code changes one import. Where behaviour differs, it fails loudly: an unknown filter key raises instead of being ignored.

Paired differences with 95% intervals

Paired differences in points, the default LLMSlim (no model) minus Mem0, on the same questions, with the paired bootstrap 95% interval in brackets, from the round 3 tables. Level means the interval includes zero, so the gap may be noise. The tables give no paired interval between LLMSlim with its reranker and Mem0, so none is shown here.

What this does not show

Mem0's open-source library, not its Platform

We ran mem0ai 2.2.1 through Mem0's own harness (mem0ai/memory-benchmarks), with Claude Haiku 5.5 for extraction and Qwen3-Embedding-0.6B for embeddings. The Platform has features the library lacks, such as graph memory and Dream, and may score differently.

One reader and one extraction model

Every number uses Claude Haiku 5.5 at effort low, for reading and for Mem0's extraction. Another model may rank these systems differently. Third-party re-runs of Mem0 on LongMemEval-S with GPT-4o-mini report 53.6% to 66.4%, against 55.4% to 56.8% for full context (the MemOS and LightMem papers).

Where the run differs from Mem0's harness

Each difference is in Mem0's favour or forced by the benchmark's one-model rule. Mem0's open-source add rejects a timestamp, so its harness dates every memory at ingestion; here each memory got its session's date. On LongMemEval, Mem0's 2,000-token output cap cut off about 2% of extraction replies, so it was raised to 8,192. Mem0's embedding and database compute is not counted, which favours it.

Small samples on LongMemEval

Mem0 ran on its pre-registered 60-question sample, because building a memory of each 500-message history costs about $0.22 a question. The 95% intervals are about ±10 points on 60 questions.

Measured on Core 0.9.0, not on the 0.12 Memory API

Round 3 measured LLMSlim selecting from whole sessions with compress_documents. Since 0.12.0, Memory.search reads a history turn by turn. On 230 LoCoMo development questions, counting the questions whose labelled evidence is all in the context (no reader in the loop), the 0.12 read path kept all of it for 75.7% of questions at 2,500 tokens, against 85.7% for the path benchmarked here. Fixes on main raise that to 80.0%; the rest of the gap is open, and is listed in the 1.0 roadmap's known quality issues.

A cached full history

When a conversation's questions come back to back, the cached full history (95.1% for $0.83 per 1,000 questions) is cheaper than LLMSlim at 10,000 tokens and more accurate than any compressed context. LLMSlim is the cheaper choice when the context changes between questions, when questions arrive too far apart for the cache, or when a history is long enough to be billed at the long-prompt rate.

Round 3 report and tables How the runs were kept honest Mem0 run scripts Per-question results Every benchmark

• Questions that join many sessions, in a small context

  At about 1,000 tokens, Mem0's extracted facts packed more evidence into the prompt: 88.7% against 80.3% for the default LLMSlim on LoCoMo's multi-hop questions, and 93.4% against 85.7% on temporal ones. If your prompts must stay that small and your questions span many sessions, extraction helps.

• A managed service today

  Mem0's Platform is available now, with a free plan and custom plans that add SSO, audit logs, an SLA and on-prem deployment. LLMSlim's hosted edition, Orbit, opens with LLMSlim 1.0; until then LLMSlim is a library and servers you run yourself.

• A profile of facts, not a transcript

  Mem0 keeps a list of short facts per user that you can read and edit, and the Platform can export them to a schema you define. LLMSlim keeps what was said; it has no step that turns a conversation into a profile.

• Graph memory and consolidation

  Mem0's Platform links entities across memories and can merge duplicates and supersede outdated facts in the background. LLMSlim has no graph and never rewrites a stored turn: when a fact changes, both turns stay under their dates.

• Questions worded unlike what was said

  LLMSlim's default relevance needs shared words. In our migration test, "Where does Asha live now?" did not find the memory "Moved to Pune in September 2026", while "Where did Asha move to?" did. Mem0 searches by embedding similarity. On LLMSlim, paraphrase is what the optional reranker (relevance="semantic") is for; we did not run it in that test.

• Text mostly not in English

  LLMSlim's default lexical scoring uses English stemming and stopwords, and we have no published results in other languages. Evaluate both on your own data before choosing.

• You want what was said, not a model's summary of it: stored turns are exact, under their dates, and nothing is lost or reworded when you add them.
• Write cost and latency matter: storing a message makes no model call. In round 3, building Mem0's memory was $1.76 of its $2.66 per 1,000 LoCoMo questions.
• Long per-user histories: on Mem0's own LongMemEval questions, LLMSlim with its reranker answered 78.3% for $1.04 per 1,000 questions, against 76.7% for $220.88.
• Everything on your own machines in one package: SQLite, Postgres or, from 1.0, MongoDB, with no vector database or embedding service.
• Claude Code, Cursor and other MCP clients through llmslim mcp, and any language through llmslim serve.
• Code already written for Mem0: Mem0Memory keeps its method names, filters and result shapes.

Source: mem0.ai/pricing, checked 2 November 2026. Prices change; check the page before you decide.

Source: llmslim.app/pricing, which also lists the plans in rupees.

• Mem0's pricing page lists no per-unit price for usage past the free limits.
• With extraction on, every add is an LLM call, and with your own key that call is on your provider's bill. In round 3, building Mem0's memory on Claude Haiku 5.5 added $1.76 per 1,000 LoCoMo questions, and about $0.22 per LongMemEval question.
• LLMSlim Core makes no model calls, so its only costs are your machine and database.
• LLMSlim Orbit, the hosted edition, opens with LLMSlim 1.0 and is not available yet; these are its plans at launch, from /pricing. Nothing is charged before it opens.

import json

from mem0 import MemoryClient

client = MemoryClient()  # reads MEM0_API_KEY
user_ids = ["asha", "ravi"]  # the users whose memories you are moving

with open("mem0-export.jsonl", "w", encoding="utf-8") as out:
    for user_id in user_ids:
        page = 1
        while True:
            batch = client.get_all(filters={"user_id": user_id}, page=page, page_size=200)
            for memory in batch["results"]:
                memory.setdefault("user_id", user_id)
                out.write(json.dumps(memory, ensure_ascii=False) + "\n")
            if not batch.get("next"):
                break
            page += 1

# Open-source Mem0 returns every memory of a scope in one call:
#   Memory.from_config(config).get_all(filters={"user_id": user_id}, top_k=100_000)["results"]

{"id": "3f1c2a9e-5b7d-4e21-9a0c-1d2e3f4a5b01", "memory": "Is allergic to peanuts", "user_id": "asha", "metadata": null, "categories": ["health"], "created_at": "2026-03-02T09:14:11.482913-08:00", "updated_at": "2026-03-02T09:14:11.482931-08:00", "expiration_date": null}
{"id": "3f1c2a9e-5b7d-4e21-9a0c-1d2e3f4a5b05", "memory": "Works as a data engineer in Bengaluru", "user_id": "ravi", "agent_id": "career-coach", "metadata": null, "categories": ["professional_details"], "created_at": "2026-06-05T22:40:00.000000-07:00", "updated_at": "2026-06-05T22:40:00.000000-07:00", "expiration_date": null}

# main from GitHub, which becomes 1.0: adds llmslim import
pip install "llmslim[fast-tokens] @ git+https://github.com/Thanatos9404/llmslim"

# 0.12.0 from PyPI: no importer (see the loop below)
pip install "llmslim[fast-tokens]"

llmslim import mem0 mem0-export.jsonl --db memory.db --dry-run   # look first: stores nothing
llmslim import mem0 mem0-export.jsonl --db memory.db             # import
llmslim import mem0 mem0-export.jsonl --db memory.db             # again: only what is new

  (no session): 4 turns, 4 new, 0 already there
  (no session): 2 turns, 2 new, 0 already there
Would import Mem0 history from mem0-export.jsonl
  into:        memory.db (user asha, ravi)
  files:       1
  sessions:    2
  turns:       6 to import, 0 already there, 0 skipped
  dry run: nothing was stored
  (no session): 4 turns, 4 new, 0 already there
  (no session): 2 turns, 2 new, 0 already there
Imported Mem0 history from mem0-export.jsonl
  into:        memory.db (user asha, ravi)
  files:       1
  sessions:    2
  turns:       6 imported, 0 already there, 0 skipped
  (no session): 4 turns, 0 new, 4 already there
  (no session): 2 turns, 0 new, 2 already there
Imported Mem0 history from mem0-export.jsonl
  into:        memory.db (user asha, ravi)
  files:       1
  sessions:    2
  turns:       0 imported, 6 already there, 0 skipped

import json

from llmslim.memory import Memory

memory = Memory("memory.db")
count = 0
with open("mem0-export.jsonl", encoding="utf-8") as export:
    for line in export:
        item = json.loads(line)
        memory.add(
            {"role": "user", "content": item["memory"]},
            user_id=item.get("user_id"),
            agent_id=item.get("agent_id"),
            run_id=item.get("run_id") or item.get("session_id"),
            timestamp=item["created_at"],
            metadata={"source_id": item["id"]},
        )
        count += 1
print(count, "memories added")

6 memories added

from llmslim.memory import Memory
from llmslim.memory.compat import Mem0Memory

# Code written for Mem0 keeps its calls: the same method names, filters and result shape.
mem0_style = Mem0Memory("memory.db")
hits = mem0_style.search("What is Asha allergic to?", filters={"user_id": "asha"})
for hit in hits["results"]:
    print(f'{hit["score"]:.3f}  {hit["memory"]}')
coach = mem0_style.get_all(filters={"user_id": "ravi", "agent_id": "career-coach"})
print(len(coach["results"]), "memories for ravi with career-coach")

# LLMSlim's own API: the turns that answer the question, within a token budget.
memory = Memory("memory.db")
for question in ["Where did Asha move to?", "Where does Asha live now?"]:
    context = memory.search(question, user_id="asha", budget=40)
    print(f"{question} ({context.tokens} of {context.history_tokens} tokens)\n  {context.text}")

0.642  Is allergic to peanuts
0.344  Is going to Jaipur in December for her sister's wedding
0.179  Moved to Pune in September 2026, to Koregaon Park
0.000  Prefers window seats on flights
2 memories for ravi with career-coach
Where did Asha move to? (31 of 107 tokens)
  [2026-09-21 (Mon) 15:30] user: Moved to Pune in September 2026, to Koregaon Park
Where does Asha live now? (21 of 107 tokens)
  [2026-03-02 (Mon) 17:14] user: Is allergic to peanuts

• Mem0's memories are facts its model extracted ("Is allergic to peanuts"), not what was said, and they are stored as they are. From then on, what you add is stored word for word.
• Each turn keeps the memory's created_at as its time and its id as source_id in its metadata. Mem0's categories and metadata are not imported.
• Mem0Memory covers Mem0's open-source Memory class in its 2.x shape, not the hosted MemoryClient. Filters other than user_id, agent_id and run_id raise, and so do reset, expiration_date and reference_date.
• Re-run your own evaluation after switching. Our results cover two English benchmarks and one reader.

The full migration guide

Sources

• Mem0 pricing (read 2 November 2026)
• Mem0 docs: Platform overview
• Mem0 docs: Platform vs open source
• Mem0 docs: add
• Mem0 docs: search
• Mem0 API: get all memories
• Mem0 docs: memory export
• mem0ai/mem0 on GitHub (Apache-2.0)
• Mem0's benchmark harness
• Third-party Mem0 re-run (MemOS paper)
• Round 3 report and tables
• How round 3 was run, and where Mem0's run differs
• Known memory quality issues (1.0 roadmap)
• Migration guide on GitHub