# Graphiti review

> Graphiti is an open-source Python framework for building and querying temporal knowledge graphs, called context graphs, for AI agents.

Devtoolwatch Board, the week of Oct 25–31, 2026. Canonical page: https://index.devtoolwatch.com/tools/graphiti/

## TL;DR

Graphiti is an open-source Python framework for building temporal context graphs that track how facts change over time. It is for developers building AI agents on evolving data. Graphiti updates graphs incrementally, keeps provenance to source episodes, and uses hybrid semantic, keyword, and graph retrieval. You bring your own graph database.

## Graphiti at a glance

- **Category:** [RAG, data and memory](https://index.devtoolwatch.com/categories/rag-data-and-memory/)
- **Maintained by:** Zep (organization, [@getzep](https://github.com/getzep) on GitHub)
- **License:** Apache 2.0
- **Language:** Python, Dockerfile, Shell
- **Repository:** [github.com/getzep/graphiti](https://github.com/getzep/graphiti)
- **Website:** [help.getzep.com/graphiti](https://help.getzep.com/graphiti)
- **PyPI package:** [graphiti-core](https://pypi.org/project/graphiti-core/) 0.31.2
- **Latest release:** [v0.31.2](https://github.com/getzep/graphiti/releases/tag/v0.31.2) on GitHub, Oct 20, 2026
- **First published:** Aug 8, 2024

## What Graphiti does

- Graphiti builds temporal knowledge graphs where each fact has a validity window, and old facts are invalidated rather than deleted.
- Graphiti traces every entity and relationship back to the episodes, the raw data that produced it.
- Graphiti ingests text and structured JSON episodes and integrates new data without batch recomputation of the graph.
- Graphiti combines semantic embeddings, BM25 keyword search, and graph traversal for hybrid retrieval.
- Graphiti supports custom entity and edge types defined as Pydantic models, or structure learned from your data.
- Graphiti answers historical queries about what was true at any point in time.
- Graphiti includes reference MCP and REST servers that show how to put the library behind a protocol.

### How it works

Graphiti is a Python library, graphiti-core, that you run in your own service. It connects to a graph database: Neo4j, FalkorDB, Amazon Neptune with OpenSearch Serverless, or the deprecated Kuzu. It uses OpenAI by default for LLM inference and embeddings. Anthropic, Gemini, Groq, and OpenAI-compatible endpoints such as Ollama or vLLM are also supported.

## How to install Graphiti

**With pip**

```
pip install graphiti-core
```

**With uv**

```
uv add graphiti-core
```

**With FalkorDB support**

```
pip install graphiti-core[falkordb]
```

### Requirements

- Python 3.10 or higher
- A graph database: Neo4j 5.26, FalkorDB 1.1.2, Amazon Neptune with OpenSearch Serverless, or Kuzu 0.11.2 (deprecated)
- An OpenAI API key by default; Anthropic, Gemini, or Groq keys are optional alternatives
- Python 3.12 or higher for the embedded FalkorDB Lite option

### First steps

1. Start a graph database, for example Neo4j with Docker Compose using docker compose up.
2. Set OPENAI_API_KEY in your environment, since Graphiti defaults to OpenAI for inference and embeddings.
3. Connect to the database and initialize Graphiti indices and constraints, as shown in the quickstart example.
4. Add text or JSON episodes, then search relationships with hybrid search and rerank by graph distance.

## Who Graphiti is for

- Developers building AI agents that need memory of facts that change over time
- Applications that need precise historical queries and provenance back to source data
- Teams comfortable building and operating the surrounding system around an open-source core

### Limitations

- Graphiti is self-hosted only and requires you to bring your own third-party graph database.
- Graphiti works best with LLMs that support Structured Output; other services, especially smaller models, may cause ingestion failures.
- The reference MCP and REST servers have no authentication, authorization, or prompt-injection protection and are not production deployments.
- Kuzu support is deprecated and will be removed in a future release.

## Usage data (the week of Oct 25–31, 2026)

- Board rank: #126 overall, #13 in RAG, data and memory, momentum score 57
- Downloads that week: 211k (+16% vs 4-week average)
- New GitHub stars per week (last 12 weeks): Aug 9: 279; Aug 16: 252; Aug 23: 220; Aug 30: 224; Sep 6: 232; Sep 13: 188; Sep 20: 179; Sep 27: 247; Oct 4: 234; Oct 11: 321; Oct 18: 268; Oct 25: 229

## Graphiti alternatives

| Rank | Tool | Stars | Downloads/wk |
|---|---|---|---|
| #1 | [XERJ](https://index.devtoolwatch.com/tools/xerj-org-xerj/) | 17.9k | – |
| #2 | [Memvid](https://index.devtoolwatch.com/tools/memvid-memvid/) | 17.3k | – |
| #3 | [LEANN](https://index.devtoolwatch.com/tools/startrail-org-leann/) | 13.7k | – |
| #4 | [Graphify](https://index.devtoolwatch.com/tools/graphify-labs-graphify/) | 140k | 480.7k |
| #5 | [MarkItDown](https://index.devtoolwatch.com/tools/markitdown/) | 193.2k | 4.7M |
| #6 | [Firecrawl](https://index.devtoolwatch.com/tools/firecrawl/) | 197.4k | 2.9M |

## Graphiti FAQ

### Is Graphiti free and open source?

Yes. Graphiti's source code is on GitHub (getzep/graphiti) under the Apache 2.0 license, so you can use it for free.

### How do I install Graphiti?

Run `pip install graphiti-core`. The graphiti-core package needs Python 3.10 or newer, below 4. The install section above has the other options from the project's README.

### Is Graphiti still maintained?

Yes. The getzep/graphiti repository was last updated on Oct 21, 2026, and the latest release, v0.31.2 on GitHub, came out on Oct 20, 2026.

### How popular is Graphiti?

Graphiti has 32.4k GitHub stars as of Nov 1, 2026. It gained 229 new stars in the week of Oct 25–31, 2026, against a 12-week average of 239 a week. Its main package had 211k downloads that week, +16% against its own 4-week average. That made it #13 among RAG, data and memory tools on the Devtoolwatch Board.

### Graphiti vs Mem0: how do they compare?

Graphiti and Mem0 are both tracked by Devtoolwatch as RAG, data and memory tools. Graphiti has 32.4k GitHub stars and Mem0 has 68.2k. In the week of Oct 25–31, 2026, Graphiti's main package had 211k downloads and Mem0's had 884.1k. Mem0 is a memory layer for AI agents and apps that stores and retrieves user, session, and agent context across interactions. [Mem0 review](https://index.devtoolwatch.com/tools/mem0/)

### Graphiti vs cognee: how do they compare?

Graphiti and cognee are both tracked by Devtoolwatch as RAG, data and memory tools. Graphiti has 32.4k GitHub stars and cognee has 33k. In the week of Oct 25–31, 2026, Graphiti's main package had 211k downloads and cognee's had 24.9k. Cognee is an open-source Python memory platform that turns documents, code, and conversations into a self-hosted knowledge graph AI agents can search. [cognee review](https://index.devtoolwatch.com/tools/cognee/)

### What are the best alternatives to Graphiti?

Other RAG, data and memory tools on the Devtoolwatch Board in the week of Oct 25–31, 2026, by momentum: XERJ (#1), Memvid (#2), LEANN (#3), Graphify (#4), MarkItDown (#5). The alternatives table above has their numbers.

### What is a Graphiti knowledge graph?

A Graphiti knowledge graph is a temporal context graph of entities, relationships, and facts. Each fact has a validity window showing when it became true and when it was superseded. Everything traces back to episodes, the raw ingested data.

### How does Graphiti relate to Zep?

Graphiti is the open-source framework at the core of Zep's context infrastructure. Zep is managed infrastructure with a proprietary graph database, user management, and dashboards. Graphiti is self-hosted and builds individual context graphs on your own database.

### How is Graphiti different from GraphRAG?

Graphiti targets dynamic data with continuous incremental updates. It uses hybrid semantic, keyword, and graph search and bi-temporal fact invalidation. The README describes GraphRAG as batch-oriented static document summarization using sequential LLM summarization.

### Can Graphiti use local LLMs?

Graphiti can use local servers such as Ollama, vLLM, llama.cpp, and LM Studio through their OpenAI-compatible endpoints. Models without Structured Output support may produce incorrect schemas.

### How do I avoid LLM rate limit errors in Graphiti?

Graphiti controls ingestion concurrency with the SEMAPHORE_LIMIT environment variable, which defaults to 10. Lower it if you hit 429 errors, or raise it if your provider allows more throughput.

## Sources

1. [getzep/graphiti on GitHub](https://github.com/getzep/graphiti)
2. [Graphiti README](https://github.com/getzep/graphiti/blob/main/README.md)
3. [graphiti-core on PyPI](https://pypi.org/project/graphiti-core/)
4. [Graphiti website](https://help.getzep.com/graphiti)
5. [Release v0.31.2 (Oct 20, 2026)](https://github.com/getzep/graphiti/releases/tag/v0.31.2)
6. [Release v0.31.1 (Oct 15, 2026)](https://github.com/getzep/graphiti/releases/tag/v0.31.1)
7. [Release v0.31.0 (Oct 14, 2026)](https://github.com/getzep/graphiti/releases/tag/v0.31.0)
8. [Hacker News: Show HN: Graphiti – LLM-Powered Temporal Knowledge Graphs](https://news.ycombinator.com/item?id=41445445)
9. [Devtoolwatch Board, the week of Oct 25–31, 2026](https://index.devtoolwatch.com/)