Graphiti: Temporal Context Graph Engine for AI Agents
Build real-time knowledge graphs that evolve with every interaction — know what's true now and what was true before.
Evidence shows: Apache-2.0 license, SECURITY.md indicating 0.x support and private vulnerability reporting. Dependencies listed in pyproject.toml but no security audit evidence. Data flow described in README but no explicit user confirmation or transparency. External effects involve LLM and database calls but no least privilege or confirmation. No rollback mechanism. Source attribution present via authors but publisher unverified. Deductions: lack of user confirmation, insufficient data flow transparency, weak dependency security evidence, unclear external effects permissions, no rollback.
Evidence shows: README and code examples are consistent in functionality description, but no execution test evidence. Dependencies listed but availability not verified. Failure messages not exemplified. Deductions: no executed tests, dependency availability unverified, insufficient failure message evidence.
Evidence shows: README identifies target audience (AI agent developers) and use cases (building temporal context graphs). Capability boundaries explained via Zep vs Graphiti and GraphRAG comparisons. Trigger precision not explicit but API examples provided. Environment fit supports multiple databases and LLM providers but not all configurations. Deductions: trigger precision unclear, environment fit not comprehensive.
Evidence shows: README well-structured with installation, quickstart, examples. Installation notes detailed. Naming consistent. Examples and FAQ present. Known limitations mentioned (Kuzu deprecation, LLM structured output issues). License Apache-2.0. Version in pyproject.toml. Maintenance responsibility via authors and contributing guide. Deductions: no explicit changelog, version history incomplete.
Evidence shows: Output usability via API and MCP server, but no actual output examples. Marginal value highlighted vs GraphRAG with temporal awareness and incremental updates. Cost-benefit: open-source free but requires self-hosted database and LLM API costs. Deductions: insufficient output examples, cost-benefit not quantified.
Evidence shows: Claims in README (temporal awareness, incremental updates) supported by code and docs, but no independent verification. Cross-source corroboration via arXiv paper link but no other independent sources. Fact vs inference separation not explicit. Deductions: insufficient cross-source corroboration, unclear fact-inference separation.
- Publisher identity unverified; exercise caution regarding supply chain risks.
- No dependency security audit evidence; recommend checking for vulnerabilities.
- Project calls external LLM and database services; ensure data privacy and least privilege.
- Kuzu backend deprecated; be aware before use.
- No rollback mechanism; handle data operations with care.
What does this agent do, and when should you use it?
Graphiti is an open-source framework for building and querying temporal context graphs for AI agents. Unlike static knowledge graphs, Graphiti tracks how facts change over time, maintains provenance to source data, and supports both prescribed and learned ontology. It continuously integrates user interactions, structured and unstructured enterprise data, and external information into a coherent, queryable graph. The framework supports incremental updates, eliminating the need for full graph recomputation, and enables efficient retrieval and precise historical queries. Graphiti offers hybrid retrieval combining semantic embeddings, keyword search, and graph traversal, with sub-second query latency. It serves as the core engine of Zep's context infrastructure, which has been demonstrated as State of the Art in Agent Memory.
Graphiti constructs temporal context graphs: it ingests episodes (raw data) and extracts entities and relationships, assigning temporal validity windows to each fact. It automatically invalidates outdated facts while preserving history. Key operations include: initializing the Graphiti class, adding episodes (text or structured JSON), searching for nodes and edges using hybrid search (semantic + BM25 + graph traversal), reranking results with graph distance, and querying across time. It connects to graph databases such as Neo4j, FalkorDB, Amazon Neptune via drivers like Neo4jDriver and FalkorDriver.
- Customer support agents that need to track evolving user preferences and relationships from conversation history.
- Financial or legal analysts who require precise answers about whether a fact was true at a specific time.
- Recommendation systems that must adapt to real-time user behavior and emerging trends.
- Enterprises aiming to build a unified knowledge graph from diverse data sources (emails, documents, databases).
- Development teams that prefer a self-hosted graph engine with multi-provider LLM support (OpenAI, Anthropic, etc.) and no vendor lock-in.
What are this agent's strengths and limitations?
- Temporal fact management: old facts are invalidated, not deleted, preserving history and enabling queries at any point in time.
- Hybrid retrieval: combines semantic, keyword, and graph traversal for sub-second queries.
- Incremental graph construction: new data integrates immediately without batch recomputation.
- Multiple graph backends: Neo4j, FalkorDB, Amazon Neptune, etc.
- Strong dependency on LLMs that support structured output (e.g., OpenAI); others may fail.
- Requires self-managed graph database (e.g., Neo4j), adding operational overhead.
- Advanced features like user management and dashboards must be built yourself or via Zep (commercial).
- Kuzu backend is deprecated.
How do you install or deploy this agent?
Requirements: Python 3.10+, a graph database (Neo4j 5.26, FalkorDB 1.1.2, etc.), and an OpenAI API key. Install via pip: pip install graphiti-core, or with uv: uv add graphiti-core. For FalkorDB support, use: pip install graphiti-core[falkordb]. Optional LLM providers: e.g., Anthropic via pip install graphiti-core[anthropic].
How do you use this agent?
Quick start: set OPENAI_API_KEY, connect to a database, initialize Graphiti, add episodes, and search. Example: from graphiti_core import Graphiti; graphiti = Graphiti("bolt://localhost:7687", "neo4j", "password"). For a complete example, see the examples/quickstart directory.
How does this agent compare with similar options?
Graphiti can be compared to GraphRAG: GraphRAG is suited for static document summarization with batch processing and query latency of seconds; Graphiti is designed for dynamic, evolving context with incremental updates, sub-second latency, and explicit temporal tracking with automatic fact invalidation.