Graphiti is an open-source framework for building and querying temporal knowledge graphs (Context Graphs) for AI agents, developed by Zep in the United States. Where typical RAG retrieves document fragments through vector search, Graphiti extracts entities such as people, organizations, and events from conversations and data, along with the relationships between them, and accumulates them in a graph. Its distinguishing trait is that every fact carries a validity window describing when it held true; when information changes, the old fact is invalidated rather than deleted. Released in August 2024, it has gathered more than 30,000 GitHub stars and continues to be developed under the Apache-2.0 license.
Key Features
- Temporal fact management: Each fact carries a validity window. When information is updated, the previous fact is invalidated instead of being overwritten and lost, so you can trace what used to be true and when it changed. This keeps an agent’s memory from contradicting itself
- Episode-level provenance: Ingested conversations and documents are retained as “episodes,” so every entity and relationship in the graph can be traced back to the input that produced it. This matters for business use cases where answers must be justified
- Hybrid retrieval: Semantic embedding search, keyword search (BM25), and graph traversal are combined to retrieve context. Fewer misses than vector search alone, with a design aimed at low latency
- Incremental updates without batch recomputation: New data can be appended in real time without rebuilding the entire graph, which suits the memory layer of an always-on agent
- Prescribed and learned ontology: You can define custom entity and edge types with Pydantic models, or let patterns emerge from the data when you do not
- Broad backend and LLM support: Graph databases include Neo4j, FalkorDB, and Amazon Neptune. LLM providers include OpenAI (default), Anthropic, Google Gemini, Groq, Azure OpenAI, and OpenAI-compatible endpoints such as local models via Ollama
- MCP server and REST API: An official MCP server lets clients such as Claude write to and search the graph directly. A FastAPI-based REST service is also included
Pricing
| Item | Price | Details |
|---|---|---|
| Graphiti (open source) | $0 | Apache-2.0 license, free to run in your own environment |
| External running costs | Usage-based | LLM API charges and graph database (Neo4j / FalkorDB, etc.) hosting costs apply separately |
| Zep (managed, for reference) | From $0 (Free) | Zep’s cloud service. Paid tiers start at Flex; Enterprise is quote-based |
Pricing is current as of August 2026. Please check the official site for the latest information.
Graphiti itself is open source and carries no license fee. Real-world cost concentrates on LLM API calls and graph database hosting. If you would rather not operate it yourself, Zep’s managed service — which uses Graphiti as its core engine — is an alternative.
Pros & Cons
✅ Pros
- Changes in facts are preserved as history, so memory stays current even for agents that run for long periods
- You can trace which input produced a piece of knowledge, which is strong for citing sources and for auditing
- Combining vector search, keyword search, and graph traversal reduces the context that plain RAG misses
- Apache-2.0 open source, so it can run entirely inside your own environment, including locally
⚠️ Cons
- A graph database must be set up and operated, which is more work than a vector-database-only setup
- Ingestion uses an LLM to extract entities and relationships, so bulk loading drives up API cost and processing time
- Familiarity with knowledge graphs and ontology design is needed; the learning curve is not trivial
- Accuracy depends on the LLM used for extraction, leaving room for model selection and prompt tuning
- Development moves quickly, so you need to keep up with changes between versions
Comparison with Similar Services
| Item | Graphiti | Mem0 | Zep (managed) | Microsoft GraphRAG |
|---|---|---|---|---|
| Delivery | Open-source framework | Open source + cloud | Cloud service | Open-source library |
| Data structure | Temporal knowledge graph | Vector + graph memory layer | Memory layer built on Graphiti | Knowledge graph + community summaries |
| Update model | Incremental (real time) | Incremental | Incremental | Mostly batch |
| Handling of time | Validity windows preserve history | Limited | Validity windows preserve history | Not a design goal |
| Main use | Long-term agent memory | Agent memory | Fully managed memory layer | Analysis and summarization of large document sets |
| Operational effort | Self-hosted (graph DB required) | Self-hosted or cloud | Minimal | Self-hosted (batch runs) |
Who Is It For
- Developers building long-running AI agents that must remember an accumulation of conversations and events
- Teams handling business systems where “as of when” matters — customer records, contract status, organizational change
- Anyone struggling with missed context or stale information in a plain vector-search RAG setup
- Teams that must cite sources back to the original material
- Anyone who wants the memory layer to stay local, using a local graph database and local LLM without sending data outside
Summary
Graphiti redesigns AI agent memory as a temporal knowledge graph rather than a vector index. Giving facts validity windows and recording change as invalidation rather than deletion pays off more the longer an agent runs. In exchange, there is real operational weight — running a graph database and paying LLM costs at ingestion — which can be overkill for a short-lived QA bot. A reasonable path is to stand up a local graph database, try it small through the official quick start and the MCP server, and confirm that you genuinely need a history of memory before committing to it.