Two professionals comparing alternatives with sticky notes at a table in a bright office

MemoryFirst vs Zep and Graphiti: a graph to build agents with, or memory to use with them

Market8 min read

An honest Zep and Graphiti vs MemoryFirst comparison: verified pricing and credits, MCP, temporal graph, compliance and when each fits. Data of 2026-11-14.

by Equipo MemoryFirst

Table of contents
  1. The honest summary
  2. Feature table
  3. Pricing and credits, with dates
  4. Pros and cons of each
  5. Where Zep wins
  6. When to choose Zep or Graphiti
  7. When to choose us
  8. Sources

Anyone who has looked at the market for AI agent memory has run into two names that sound alike: Graphiti and Zep. Graphiti is the open-source graph engine; Zep is the company and the managed service that uses it inside. We are MemoryFirst and we compete with Zep in some cases, so we are an interested party. What follows tries to be fair: every Zep fact has its source and date at the end, and what we could not check, we say so.

The honest summary

  • Zep presents itself as an "enterprise context layer": it organizes business data, documents and conversations into temporal context graphs and serves them to agents through SDKs (Python, TypeScript and Go) or MCP. It has connectors, access controls, retention policies and audit logs.
  • Graphiti is the open-source framework (Apache 2.0) used to build those graphs. You bring the graph database (Neo4j, FalkorDB or Amazon Neptune) and run it yourself.
  • MemoryFirst is a managed service for people who use ready-made agents (Claude, ChatGPT, Cursor, VS Code): it plugs in over MCP, ingests your sources and answers with citations to the original passage. There is no self-hosted edition.

The dividing line: Zep and Graphiti are better if you build agents and need to control the graph; MemoryFirst is better if you do not want to build anything. And on compliance and enterprise deployment, Zep currently publishes more options than we do.

Feature table

AspectZep (and Graphiti)MemoryFirst
What it isContext layer with temporal graphs, SDKs and MCP; Graphiti is its open engineMemory service to plug into agents over MCP and REST
Open sourceGraphiti: Apache 2.0. Zep Cloud: managed service. Zep Community Edition is deprecated and unsupportedNo
Self-hostingGraphiti, yes (you provide the graph database). Zep in your cloud (BYOC): Enterprise plan only, via salesNo self-hosted edition
MCPTheir pages mention MCP access and "seats" for the context MCP server in each plan; we did not verify its tools. Graphiti's reference server warns it has no authenticationRemote at mcp.memoryfirst.ai with 15 tools and OAuth 2.1 or API key, plus a stdio server
Temporal graphTheir specialty (temporal context graphs)Temporal graph with citations and resolved contradictions on Pro
Citations to the originThey say you can "trace graph data to its sources"; we did not verify the citation formatEvery answer cites its source (page, minute, message, URL)
ConnectorsGoogle Drive, Slack, Notion, Gmail and Granola from Flex; more (Teams, SharePoint, Snowflake, Databricks, BigQuery) on EnterpriseGmail and IMAP, Calendar, Drive, Dropbox, OneDrive, Slack, Telegram, files and events through the API
Where data is hostedTheir pages give no regions. They say they sign data processing agreements with EU customersDatabase, embeddings and files in the EU (Germany)
CertificationsSOC 2 Type II and HIPAA BAA: advertised, although their plan table marks them as Enterprise onlyGDPR by design; we do not claim certifications we do not hold

Pricing and credits, with dates

Zep, as of 2026-11-14 (prices in US dollars, billed monthly):

  • Free trial: 10,000 credits a month, 2 projects. No price appears in the table.
  • Flex: $125/month, 50,000 credits, 600 requests per minute, 5 projects, 5 context MCP seats, connectors, 1-day API log retention. Overage: $25 per 10,000 credits.
  • Flex Plus: $375/month, 200,000 credits, 1,000 requests per minute, 10 projects, 15 MCP seats, observations, webhooks, analytics and custom extraction. Overage: $75 per 40,000 credits.
  • Enterprise: custom (BYOK, BYOC, SOC 2 Type II, HIPAA BAA, SLA, 1-year log retention).

A credit corresponds to an "episode", any object you send (a message, a JSON payload, a block of text): up to 350 bytes costs 1 credit and each extra 350-byte chunk costs one more. According to their page, retrieval, storage and users do not consume credits.

A software engineer thinking in front of a whiteboard covered in node-and-line sketches

Simulated scenario: a fictional startup sends 2,000 episodes a day of about 700 bytes each. Each episode costs 2 credits, so that is 4,000 credits a day, around 120,000 a month. That is well above Flex's 50,000 and fits inside Flex Plus's 200,000. This is an illustrative calculation with invented numbers, not a real case.

MemoryFirst (from our pricing page, on the date of this article): Free (0 euros, 1 project, 1 seat, 30-day retention); Pro, 12 euros a month billed annually (144 euros a year) or 14.40 paid monthly, with unlimited projects and retention, all connectors and a temporal graph with citations; Team, 39 euros a month billed annually (468 euros a year) or 46.80 monthly, with 5 seats and shared memory. Pioneer offer: Pro for 9 euros a month for life, for the first 50 seats and until 31 December 2026.

The difference in model matters more than the number. With Zep, cost grows with the volume of episodes you send; with MemoryFirst you pay for a plan with seats and connectors, and quotas apply per plan. We are not comparing $125 with 12 euros as if they were the same thing.

Pros and cons of each

Zep and Graphiti

Pros

  • The temporal graph is their focus: probably the most specialized option for people building agents.
  • Graphiti is open source (Apache 2.0, 32.8k GitHub stars on the date we checked) and you can run it yourself.
  • Published enterprise options: your own keys (BYOK), deployment in your cloud (BYOC), SOC 2 Type II and a HIPAA BAA on Enterprise.
  • Described data governance: attribute-based access control, retention and audit logs.
  • SDKs in Python, TypeScript and Go.

Cons

  • It is infrastructure to build with: you integrate an SDK, model entities and decide how memory is shown.
  • Published plans start at $125 a month and meter usage in credits, so you have to estimate your volume.
  • We could not verify the hosting region or the citation format.
  • Zep Community Edition is deprecated and unsupported; to self-host you use Graphiti with your own graph database.
  • Graphiti's reference MCP server warns that it has no authentication or prompt-injection protection.

MemoryFirst

Pros

  • A finished product, with no SDK to maintain.
  • Citations to the source passage in every answer.
  • Data stored in the EU and verifiable erasure.
  • Low entry price and a free plan with MCP.

Cons

  • No self-hosted edition, no BYOC and no certifications of our own to publish.
  • Default inference is not EU-only: questions and retrieved passages go to Cerebras (US), unless you use your own LLM key, which covers only part of the processes.
  • Not a component to embed in another company's agent.
  • Less maturity and presence than a competitor with enterprise customers.
Two colleagues reviewing a printed contract together at a meeting table

Where Zep wins

It wins on technical depth of the graph, on enterprise options (own keys, customer cloud, certifications and a BAA, all as they publish them) and on developer control: SDKs in three languages and an open framework. If your project is an agent product and the graph is the heart of it, it is a serious choice. And if your organization requires deployment in your own cloud, we cannot offer that today.

When to choose Zep or Graphiti

  • You build agents and need to govern the graph and its entity types yourself.
  • Your company requires BYOC, your own keys or a SOC 2 Type II report in its name.
  • You want open source and to run the graph database yourself (Graphiti).
  • You have an engineering team and your episode volume fits comfortably in a Flex plan or above.

When to choose us

  • You use agents that already exist and want them to remember your projects, clients and decisions without building anything.
  • You want citations to the source in every answer.
  • You prefer data stored in the EU, accepting the inference caveat described above.
  • Your budget or team does not fit a $125-a-month, SDK-based infrastructure.
A person closing a notebook next to a cup of coffee on a desk in the morning

Keep reading. The full context is in the AI memory market in 2026. For a joint view of Mem0, Supermemory and Zep, read how to choose a memory layer; for the other comparison in this series, MemoryFirst vs Mem0. You can also read how we retrieve information, citations and GDPR, the pricing page and the short comparison.

Sources

All accessed 2026-11-14. Anything not listed here, or marked "we could not verify", is not claimed.

  • Zep plans, credits and credit definition: https://www.getzep.com/pricing (accessed 2026-11-14)
  • Zep home page: https://www.getzep.com/ (accessed 2026-11-14)
  • Zep deployment and compliance: https://www.getzep.com/enterprise (accessed 2026-11-14)
  • Zep general documentation: https://help.getzep.com/overview (accessed 2026-11-14)
  • FAQ and Community Edition deprecation: https://help.getzep.com/faq and https://help.getzep.com/ce-deprecation-notice (accessed 2026-11-14; the second only through a search result)
  • Graphiti, license and graph databases: https://github.com/getzep/graphiti (accessed 2026-11-14)
  • MemoryFirst pricing: our own pricing page.

Try memory on one project

The Free plan includes one project, MCP memory and the Claude Code hooks, with data stored in the EU.

Start free

Keep reading