Zep Docker in 2026: Self-Hosting Options Explained

You can’t self-host today’s Zep with Docker. Zep Community Edition, the Docker-based self-hosted Zep, has been deprecated since April 2025. What you can run in Docker now is Graphiti, Zep’s open-source temporal graph engine, as a REST server with Neo4j or an MCP server with FalkorDB. The full Zep product runs in your own cloud only on the Enterprise plan.

Many guides still show docker compose up for Zep. They describe an edition that gets no updates or support. This page lays out the real options as of 8 October 2026, with working Compose setups, based on the getzep/zep and Graphiti repositories.

What are the Zep self-hosting options in 2026?

There are three ways to run Zep-style memory on your own infrastructure: Graphiti in Docker (supported, open source, Apache 2.0), the legacy Zep Community Edition Compose stack (deprecated and unsupported), or Zep’s Bring Your Own Cloud deployment (Enterprise plan only). Zep Cloud, the main product, is managed.

What happened to Zep Community Edition

On 2 April 2025, Zep announced it had “decided to stop maintaining and releasing Zep Community Edition.” The code stayed public under Apache 2.0, but with no updates or support. Zep’s open-source work moved to Graphiti.

Today the getzep/zep README opens with “This repository is not Zep’s product or service.” It holds examples, framework integrations and benchmarks for Zep Cloud. The old server lives in legacy/, labeled “Deprecated Zep Community Edition (unsupported).”

That folder still has docker-compose.ce.yaml. It starts the zepai/zep:latest image, a pinned zepai/graphiti:0.3 image and Postgres with pgvector (ankane/pgvector:v0.5.1). It may still start, but it’s frozen at an old Graphiti and gets no security fixes. The CE API also differs from Zep Cloud’s v3 SDK, which is built around users and threads. Don’t start a new project on it.

Option 1: Graphiti REST server with Neo4j

The Graphiti repo includes a FastAPI service, published to Docker Hub as zepai/graphiti with tags that match each graphiti-core release (0.30.2 as of September 2026). It needs a Neo4j database and an LLM key.

This Compose file follows the server README and the repo’s own docker-compose.yml:

 1services:
 2  graph:
 3    image: zepai/graphiti:latest
 4    ports:
 5      - "8000:8000"
 6    environment:
 7      - OPENAI_API_KEY=${OPENAI_API_KEY}
 8      - NEO4J_URI=bolt://neo4j:7687
 9      - NEO4J_USER=neo4j
10      - NEO4J_PASSWORD=${NEO4J_PASSWORD}
11    depends_on:
12      - neo4j
13  neo4j:
14    image: neo4j:5.26.2
15    ports:
16      - "7474:7474"
17      - "7687:7687"
18    environment:
19      - NEO4J_AUTH=neo4j/${NEO4J_PASSWORD}
20    volumes:
21      - neo4j_data:/data
22volumes:
23  neo4j_data:

Steps to run it:

1. Save the file as docker-compose.yml and create a .env with OPENAI_API_KEY and NEO4J_PASSWORD.
2. Run docker compose up -d.
3. Open http://localhost:8000/docs for the Swagger UI.
4. Open http://localhost:7474 to browse the graph in Neo4j.
5. Send messages to POST /messages and query with POST /search.

A group_id plays the role of a Zep user: each group is a separate graph partition. This Python client adds a conversation and searches it:

 1import time
 2import httpx
 3
 4api = httpx.Client(base_url="http://localhost:8000", timeout=30)
 5
 6api.post("/messages", json={
 7    "group_id": "user-dana",
 8    "messages": [
 9        {"content": "I moved to Lisbon last month.", "role_type": "user", "role": "Dana"},
10        {"content": "Noted, I'll use your Lisbon address.", "role_type": "assistant", "role": "bot"},
11    ],
12}).raise_for_status()  # 202: processed by a background worker
13
14time.sleep(20)  # extraction runs LLM calls asynchronously
15
16result = api.post("/search", json={
17    "group_ids": ["user-dana"],
18    "query": "Where does Dana live?",
19    "max_facts": 5,
20}).json()
21
22for fact in result["facts"]:
23    print(fact["fact"], fact["valid_at"], fact["invalid_at"])

Each fact comes back with valid_at and invalid_at, the validity window that makes Graphiti temporal. When Dana later says she moved again, the Lisbon fact gets an invalid_at instead of disappearing. For why that matters, see temporal reasoning in AI memory.

The server also has POST /get-memory (facts relevant to a list of messages), GET /episodes/{group_id}, and deletes for edges, episodes and whole groups.

Option 2: Graphiti MCP server in Docker

If the goal is memory for Claude Desktop, Cursor or another MCP client, use the Graphiti MCP server. A pre-built image is published as zepai/knowledge-graph-mcp. Its default setup runs FalkorDB and the MCP server in a single container:

1git clone https://github.com/getzep/graphiti.git
2cd graphiti/mcp_server
3cp .env.example .env      # set OPENAI_API_KEY (or another provider's key) here
4cd docker && docker compose up

The Compose file reads keys from mcp_server/.env, so set them there rather than only exporting them in your shell.

That exposes the MCP endpoint at http://localhost:8000/mcp/ over HTTP, FalkorDB on port 6379, and FalkorDB’s web UI on port 3000. A Neo4j variant is in docker-compose-neo4j.yml in the same folder. Point an HTTP-capable MCP client at the endpoint; stdio-only clients can run the server directly with uv, per the MCP server README.

The MCP server supports OpenAI, Anthropic, Gemini, Groq and Azure OpenAI for the LLM, and OpenAI, Voyage, Sentence Transformers and Gemini for embeddings, configured in config.yaml. More on this pattern in AI memory MCP servers.

Running Zep-style memory fully local

“Local” usually means no cloud LLM. Graphiti defaults to OpenAI for both extraction and embeddings, but its README says other providers, including local servers such as Ollama, vLLM, llama.cpp and LM Studio, work through their OpenAI-compatible endpoints. It also warns that Graphiti “works best with LLM services that support Structured Output.” Small local models often fail to produce valid entity and edge JSON, so test extraction quality before you commit.

Graph database choices for Graphiti 0.30: Neo4j 5.26, FalkorDB 1.1.2, or Amazon Neptune. Kuzu support is deprecated because the upstream Kuzu project is no longer maintained. FalkorDB also has an embedded “lite” install extra (graphiti-core[falkordblite]) for single-process setups.

Graphiti vs the Zep you’d get in the cloud

Self-hosted Graphiti is the engine, not the product. The Graphiti README is explicit about the split:

If you were on Community Edition and want the closest thing to what you had, Graphiti plus a thin layer for users and sessions is the honest answer. If you’d rather not run a graph database, other self-hostable memory servers exist: Mem0’s Docker server and Hindsight both run on Postgres with pgvector, and Cognee runs with local file-based stores. These are compared in Zep alternatives, and Zep’s own product is explained in what is Zep memory.