LLMSlim vs Zep. An honest comparison.

From Zep's documentation, its FAQ and the Graphiti repository, read on 2 November 2026.

1. 01

   Verbatim storage, no graph to maintain

   add stores each turn as it was said, with its time and scope. There are no entities to resolve and no facts to extract, so nothing can be merged wrongly or extracted wrongly; what the model reads later is what was said.

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 Graphiti's graph on Claude Haiku 5.5 was $5.29 of its $6.24 per 1,000 LoCoMo questions, and about $0.70 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 graph database, embedding model or LLM to run.

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

   Changes kept side by side

   Zep invalidates a fact when a newer one contradicts it. LLMSlim keeps both statements under their dates, and since 0.12 its search shows statements that may conflict side by side, so the model weighs which one holds.

Paired differences with 95% intervals

Paired differences in points, the default LLMSlim (no model) minus Zep, 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.

What this does not show

Graphiti, not Zep Cloud

Zep Cloud is a hosted service with its own models and settings. We ran Graphiti 0.30.2, the open-source framework that powers it, on Neo4j (Graphiti's primary backend), through Zep's own harness (getzep/zep-papers), with Claude Haiku 5.5 for extraction, Qwen3-Embedding-0.6B for embeddings and Zep's BGE reranker. Zep Cloud may score differently.

Far below Zep's own published result

Zep's paper reports 71.2% on LongMemEval-S with GPT-4o, against 60.2% for full context in its setup. Our 58.3% used Claude Haiku 5.5 for extraction and reading, on a 24-question sample, so the two are not comparable. Compare each system's gap to its own full-context baseline, not raw scores across readers.

Where the run differs from Zep's harness

Each difference is in Zep's favour or forced by the benchmark's one-model rule. On LongMemEval, Zep's run added every message on its own; here each session is one episode, to keep the cost of Graphiti's several calls per episode within budget. Zep's LoCoMo script read a photo-caption key LoCoMo does not have; here every system sees the captions. Graphiti's embedding and database compute is not counted, which favours it.

A small sample on LongMemEval

Zep ran on its pre-registered 24 questions, because building a graph of each 500-message history costs about $0.70 a question. The 95% intervals are about ±17 points on 24 questions; under Mem0's more lenient judge the gap's interval touches zero.

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 Zep run scripts Per-question results Every benchmark

• Shared, governed context across sources

  Zep combines business data, documents and conversations into Context Graphs shared across users and accounts, with access policies for agents and teams. LLMSlim scopes memory per user, agent and session, and has no graph that spans sources.

• Compliance and a managed service today

  Zep's Enterprise plan includes SOC 2 Type II, a HIPAA BAA, an SLA and deployment in your own VPC. LLMSlim Core runs wherever you run it, and its hosted edition, Orbit, opens with LLMSlim 1.0.

• Questions about entities and their history

  Zep's graph answers questions about people, accounts and how facts about them changed, with validity times on each fact. LLMSlim returns what was said; it has no entity graph.

• Facts that should be invalidated

  When a fact changes, Zep invalidates the older one. LLMSlim keeps both under their dates and shows statements that may conflict side by side; if your agent must see only the current fact, Zep does that work for you.

• 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.

• Conversation memory where the exact words matter, with no extraction model in between.
• No LLM bill for memory: storing a message costs nothing. In round 3, building Graphiti's graph was $5.29 of its $6.24 per 1,000 LoCoMo questions.
• Long conversations: on LoCoMo, 91.7% with no model and 93.0% with the reranker, against 74.4% for Graphiti, in round 3.
• One package on your own machines: SQLite, Postgres or, from 1.0, MongoDB, with no graph database to run.
• Claude Code, Cursor and other MCP clients through llmslim mcp, and any language through llmslim serve.

Source: www.getzep.com/pricing, checked 2 November 2026. Prices change; check the page before you decide.

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

• A credit, per Zep's page: an episode (a chat message, a JSON payload or a block of text) up to 350 bytes uses 1 credit, plus 1 for each further 350 bytes or part of it. Retrieval, storage, threads and users use no credits. The page also offers annual billing, which it says saves 17%.
• Zep's extraction runs on Zep's side and is covered by credits. On Graphiti it is your LLM bill: in round 3, building Graphiti's graph on Claude Haiku 5.5 added $5.29 per 1,000 LoCoMo questions, and about $0.70 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
import os

from zep_cloud.client import Zep

client = Zep(api_key=os.environ["ZEP_API_KEY"])
users = {"asha": "<Asha's Zep user UUID>"}  # your user id -> Zep's user UUID


def to_llmslim(message, thread_uuid, user_id):
    return {
        "id": message.uuid_,
        "role": message.role,
        "content": message.content,
        "timestamp": message.reference_time or message.created_at,
        "session_id": thread_uuid,
        "user_id": user_id,
    }


with open("zep-history.jsonl", "w", encoding="utf-8") as out:
    for user_id, user_uuid in users.items():
        for thread in client.thread.list(user_uuid=user_uuid):  # the pager reads every page
            for message in client.thread.list_messages(thread.uuid_, order_by="created_at", order="asc"):
                out.write(json.dumps(to_llmslim(message, thread.uuid_, user_id), ensure_ascii=False) + "\n")

{"id": "c0a8f1e2-0001-4a7b-9c3d-5e6f7a8b9001", "role": "user", "content": "I moved to Pune last month, to Koregaon Park.", "timestamp": "2026-10-03T06:12:40.118Z", "session_id": "8a41c6d2-7f0e-4c11-b5e3-2d9f60a1c001", "user_id": "asha"}
{"id": "c0a8f1e2-0002-4a7b-9c3d-5e6f7a8b9002", "role": "assistant", "content": "Noted: you live in Pune now, in Koregaon Park.", "timestamp": "2026-10-03T06:12:44.902Z", "session_id": "8a41c6d2-7f0e-4c11-b5e3-2d9f60a1c001", "user_id": "asha"}

# 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 jsonl zep-history.jsonl --db memory.db

  8a41c6d2-7f0e-4c11-b5e3-2d9f60a1c001: 2 turns, 2 new, 0 already there
  8a41c6d2-7f0e-4c11-b5e3-2d9f60a1c002: 3 turns, 3 new, 0 already there
Imported JSONL history from zep-history.jsonl
  into:        memory.db (user asha)
  files:       1
  sessions:    2
  turns:       5 imported, 0 already there, 0 skipped

import json

from llmslim.memory import Memory

memory = Memory("memory.db")
added = 0
with open("zep-history.jsonl", encoding="utf-8") as history:
    for line in history:
        row = json.loads(line)
        if row["role"] not in ("user", "assistant"):
            continue  # system, function and tool messages stay behind
        memory.add(
            {"role": row["role"], "content": row["content"]},
            user_id=row["user_id"],
            run_id=row["session_id"],
            timestamp=row["timestamp"],
            metadata={"source_id": row["id"]},
        )
        added += 1
print(added, "messages added")

5 messages added

from llmslim.memory import Memory

memory = Memory("memory.db")
for question in ["What am I allergic to?", "Where did I move to?"]:
    context = memory.search(question, user_id="asha", budget=60)
    print(f"{question} ({context.tokens} of {context.history_tokens} tokens)\n{context.text}\n")

What am I allergic to? (42 of 149 tokens)
[2026-10-17 (Sat) 08:30] user: I'm allergic to peanuts, so never suggest satay.
assistant: Understood: no peanuts, and no satay.

Where did I move to? (47 of 149 tokens)
[2026-10-03 (Sat) 06:12] user: I moved to Pune last month, to Koregaon Park.
assistant: Noted: you live in Pune now, in Koregaon Park.

• Only messages come across. Zep's facts, entities, summaries and data added to a graph directly are not exported by this script; LLMSlim reads the messages themselves.
• Your user ids are yours to choose: the script maps each of your users to their Zep user UUID, and stores turns under your id.
• Re-run your own evaluation after switching. Our results cover two English benchmarks and one reader.

Import your chat history (1.0 docs)

Sources

• Zep pricing (read 2 November 2026)
• Zep docs: overview
• Zep docs: How graph creation works
• Zep docs: retrieving context
• Zep docs: FAQ (self-hosting, Community Edition)
• Zep docs: threads and messages
• Zep API: list thread messages
• Graphiti overview
• getzep/graphiti on GitHub (Apache-2.0)
• Zep paper (arXiv:2501.13956)
• Zep's benchmark harness
• Round 3 report and tables
• How round 3 was run, and where Zep's run differs
• Known memory quality issues (1.0 roadmap)