getzep/graphiti
51.2
Adequate · 15 November 2026
41.5k
lines of production code
Python
primary language
5
measurements over time
What this system is
Features
Add Azure OpenAI with Neo4j example
A new example demonstrating how to integrate Graphiti with Azure OpenAI and Neo4j has been added. This example shows how to configure Azure OpenAI clients for LLM and embedding tasks, ingest text and JSON episodes into a Neo4j knowledge graph, and perform hybrid and center-node searches.
examples/azure-openai · high confidence
Add LangGraph ShoeBot Sales Agent example
Added a new Jupyter notebook example (\agent.ipynb\) demonstrating how to build a sales agent using LangGraph and Graphiti. The example shows how to persist chat turns to a Graphiti knowledge graph, recall relevant facts to personalize responses, and query a product database (loaded from \manybirds\_products.json\) to assist users in finding shoe information.
examples/langgraph-agent · high confidence
Added ecommerce example runner
The examples/ecommerce directory now includes a runnable script (runner.py) and its Jupyter notebook equivalent (runner.ipynb) that demonstrate how to initialize a Graphiti client, connect to a Neo4j database, ingest product data from a JSON file, and process a sample shoe-sales conversation.
examples/ecommerce · high confidence
FalkorDB graph driver integration with multi-tenant graph routing
The graphiti\_core driver now supports FalkorDB as a graph backend alongside Neo4j. This adds a new GraphProvider enum value and a full set of FalkorDB-specific operations (entity, episode, community, saga nodes and edges, search, and graph maintenance). A key behavioral change for FalkorDB users is automatic multi-tenant routing: when reading by group\_id, the driver clones the connection to the specific graph namespace for that group, ensuring reads target the correct isolated graph rather than an empty default. Fulltext queries are also adapted for FalkorDB's RediSearch syntax, including character sanitization and group\_id escaping.
_graphiti\core/driver · high confidence
Initial release of Graph Service API endpoints
This change introduces the initial set of REST API endpoints for the graph service, enabling users to ingest and retrieve graph data. The ingest router provides endpoints to add messages and entity nodes, delete specific edges, episodes, or entire groups, and clear the graph data. The retrieve router exposes search capabilities (including multi-group search), retrieval of entity edges and episodes, and a memory-based search feature. These endpoints are backed by an asynchronous worker for message processing and utilize the ZepGraphiti integration for underlying graph operations.
_server/graph\service/routers · high confidence
Initial release of Graph Service DTOs
This change introduces the data transfer objects for the new graph service, defining the structure for ingesting messages and entity nodes, as well as retrieving facts and memories. Users interacting with the service will now have access to endpoints that accept \AddMessagesRequest\ and \AddEntityNodeRequest\ for data ingestion, and return \FactResult\ objects containing source/target node UUIDs and episode lists during search and memory retrieval operations.
_server/graph\service/dto · high confidence
Initial release of Graphiti Core library
Introduces the Graphiti Core package, providing the foundational classes and utilities for building graph-based AI applications. This includes the main Graphiti client for managing episodes, nodes, and edges, along with support for multiple graph database backends (Neo4j, FalkorDB, Kuzu, and Amazon Neptune). The release adds features such as multi-group ID isolation with concurrent execution, configurable embedding and LLM clients, OpenTelemetry distributed tracing, and anonymous usage telemetry via PostHog.
_graphiti\core · high confidence
Initial release of the Graphiti MCP Server
The Graphiti MCP Server is now available, exposing Graphiti's knowledge graph capabilities through the Model Context Protocol. It supports multiple graph databases (FalkorDB by default, with Neo4j support), multiple LLM providers (OpenAI, Anthropic, Gemini, Groq, Azure OpenAI), and provides tools for episode management, entity search, and graph maintenance. The server includes pre-built Docker images, configurable concurrency limits, and structured output modes for LLM interactions.
_mcp\server · high confidence
Initial repository scaffolding and documentation
The repository has been initialized with foundational project files, including an Apache 2.0 license, a Python .gitignore template, and a Makefile for standard development tasks (install, format, lint, test). Comprehensive documentation has been added to guide contributors and users: AGENTS.md and CLAUDE.md provide detailed instructions for local setup, database configuration (Neo4j, FalkorDB), and development workflows; CONTRIBUTING.md outlines the process for reporting bugs, proposing features, and submitting pull requests; CODE\_OF\_CONDUCT.md establishes community standards; and OTEL\_TRACING.md explains how to enable OpenTelemetry distributed tracing. The README.md introduces Graphiti as a framework for building temporal knowledge graphs, highlighting its bi-temporal data model, hybrid retrieval capabilities, and support for multiple graph backends.
(repo-wide) · high confidence
Introduce YAML-based configuration with provider schemas
The configuration system now supports loading settings from a YAML file via a custom Pydantic settings source, including recursive environment variable expansion for values. New schema definitions have been added for server settings (transport, host, port), LLM providers (OpenAI, Azure OpenAI, Anthropic, Gemini, Groq), embedder providers, and database providers (Neo4j, FalkorDB), allowing users to manage these settings declaratively.
_mcp\server/src/config · high confidence
Introduce cross-encoder reranking for search results
The \graphiti\_core/cross\_encoder\ module has been added to provide a pluggable reranking layer for search results. It defines a \CrossEncoderClient\ interface and includes three concrete implementations: \OpenAIRerankerClient\ (using GPT-4.1-nano with log-probabilities), \GeminiRerankerClient\ (using Gemini-2.5-flash-lite for direct relevance scoring), and \BGERerankerClient\ (using the local BAAI/bge-reranker-v2-m3 model). This allows users to improve search relevance by re-ranking retrieved passages based on their specific relevance to the query.
_graphiti\_core/cross\encoder · high confidence
Introduce dedicated Graph Service with configurable backend and LLM settings
A new FastAPI-based graph service has been added to handle graph operations, featuring a lifespan-managed application with a healthcheck endpoint. The service supports configurable database backends (Neo4j or FalkorDB) via environment variables and allows customization of OpenAI LLM settings (API key, base URL, model name) and embedding models. It includes dedicated endpoints for ingesting and retrieving data, with specific logic for handling entity nodes, edges, and group deletion, while ensuring proper initialization and cleanup of the graph client.
_server/graph\service · high confidence
Introduce modular MCP server with multi-group routing and bi-temporal support
The MCP server has been restructured into a modular architecture that supports multiple database providers and routes tool requests to the specific graph associated with a requested group\_id. This update enables bi-temporal data modeling, allowing users to specify reference times for episodes and filter facts by validity periods, while also introducing support for sagas, community detection, custom entity/edge types, and scalar group\_id parameters on read tools.
_mcp\server/src · high confidence
MCP Server utility layer for formatting, configuration, and authentication
The MCP server now includes a new utility module (mcp\_server/src/utils) that standardizes how data is presented and configured. The formatting utilities (formatting.py) strip embedding vectors from node and edge results to reduce payload size and prevent exposure of internal representations. The type configuration helpers (type\_config.py) translate MCP settings into graphiti-core arguments, including support for bi-temporal filtering via ISO-8601 date parsing and normalization of group\_id inputs to ensure consistent scoping. Additionally, a new authentication utility (utils.py) provides Azure Managed Identity token generation for secure service-to-service communication.
_mcp\server/src/utils · high confidence
New Docker deployment options for FalkorDB and Neo4j backends
The \mcp\_server/docker\ directory now provides complete Docker configurations for running the Graphiti MCP server. A new combined image (\Dockerfile\) bundles the MCP server with FalkorDB, including a startup script that launches both services and optionally the FalkorDB Browser UI. A standalone image (\Dockerfile.standalone\) is also introduced for connecting to external databases, supporting both FalkorDB and Neo4j drivers. The release includes Docker Compose files for both the combined FalkorDB setup and a separate Neo4j deployment, along with build scripts and documentation to simplify local development and production deployment.
_mcp\server/docker · high confidence
New GLiNER2 hybrid LLM client example
Added a new example in \examples/gliner2\ demonstrating a hybrid LLM client setup using GLiNER2 for local, CPU-based entity extraction (NER) and a general-purpose LLM (configured here with Google Gemini) for edge/fact extraction, deduplication, and summarization. The example includes the \gliner2\_neo4j.py\ script, configuration via \.env.example\, and documentation in \README.md\, showing how to integrate the \GLiNER2Client\ with Graphiti and Neo4j.
examples/gliner2 · high confidence
New OpenTelemetry stdout tracing example for Graphiti
Added a new example in the \examples/opentelemetry\ directory that demonstrates how to configure Graphiti with OpenTelemetry to output trace spans to stdout. The example includes a Python script (\otel\_stdout\_example.py\) showing how to set up a \TracerProvider\ with a \ConsoleSpanExporter\, initialize a \Graphiti\ instance with a Kuzu driver and the tracer, and perform episode ingestion and search operations while emitting traces. It also provides a \.env.example\ file for the required \OPENAI\_API\_KEY\ and a \uv.lock\ file to manage dependencies for the example environment. Also in this area: 2 commits (0 fixes) modifying examples.
examples/opentelemetry · medium confidence · unverified
New dedicated embedder interface with OpenAI, Azure OpenAI, Gemini, and VoyageAI support
The embedder module has been restructured around a new \EmbedderClient\ abstract base class, providing a unified interface for generating embeddings. This change introduces dedicated client implementations for OpenAI, Azure OpenAI, Google Gemini, and VoyageAI, each with their own configuration classes and support for both single and batch embedding creation. Users can now select their preferred embedding provider through these new clients while maintaining a consistent API for embedding operations.
_graphiti\core/embedder · high confidence
New examples for Jev and OpenAI Decisions deduplication
Added two new example scripts demonstrating how to route node deduplication and edge resolution to decision models while keeping extraction and summarization on a general LLM. The \examples/jev\ example shows integration with the Jev API (using \JevClient\ and \jev\_prompt\_overrides\) and FalkorDB, requiring a \JEV\_API\_KEY\. The \examples/openai\_decisions\ example demonstrates the same pattern using OpenAI Decisions (via \OpenAIDecisionsClient\ and \openai\_decisions\_prompt\_overrides\) and FalkorDB, requiring only an \OPENAI\_API\_KEY\. Both examples configure \LLMRuntime\ with \PromptRoutes\ to send \dedupe\_nodes.nodes\ and \dedupe\_edges.resolve\_edge\ to the respective decision models.
_examples/jev, examples/openai\decisions · high confidence
New maintenance utilities for graph data operations and entity extraction
The \graphiti\_core/utils/maintenance\ package introduces a suite of utilities for managing graph data and entity extraction. It includes \graph\_data\_operations\ for clearing data and retrieving episodic nodes, \node\_operations\ and \edge\_operations\ for extracting entities and relationships from episodes, and \combined\_extraction\ for performing joint node and edge extraction in a single LLM call. The package also provides \attribute\_utils\ to cap string attribute lengths and prevent LLM meta-reasoning bleed, \dedup\_helpers\ for fuzzy entity deduplication using MinHash and Jaccard similarity, and \community\_operations\ for in-memory community detection via label propagation.
_graphiti\core/utils/maintenance · high confidence
New modular search subsystem with configurable strategies and filters
The \graphiti\_core/search\ package has been restructured into a modular system that decouples search logic from configuration. Users can now define search behavior via \SearchConfig\ objects, selecting from specific methods (BM25, cosine similarity, BFS) and rerankers (RRF, MMR, cross-encoder, node distance, episode mentions) for edges, nodes, episodes, and communities. The new \SearchFilters\ model allows precise filtering by node labels, edge types, and temporal validity (valid\_at/invalid\_at). Predefined recipes like \COMBINED\_HYBRID\_SEARCH\_RRF\ provide ready-to-use configurations, while the \search\ entry point orchestrates these components to return structured \SearchResults\.
_graphiti\core/search · high confidence
New modular service architecture with multi-provider LLM support and episode processing queues
The MCP server introduces a new modular service layer in \mcp\_server/src/services\. The \LLMClientFactory\ now supports a wide range of providers (OpenAI, Azure OpenAI, Anthropic, Gemini, Groq, Ollama, and other OpenAI-compatible endpoints) and correctly handles reasoning models and structured output modes. Additionally, a new \QueueService\ manages sequential episode processing, supporting advanced features like bi-temporal data, sagas, and community updates.
_mcp\server/src/services · high confidence
New podcast and Wizard of Oz ingestion examples
Added two new example scripts demonstrating knowledge graph ingestion: a podcast runner that parses a Freakonomics transcript and ingests it into an embedded FalkorDB graph using bulk or single-episode modes, and a Wizard of Oz runner that parses the book's chapters and ingests them into a Neo4j graph.
examples/podcast · high confidence
New quickstart examples for FalkorDB and Amazon Neptune
The examples/quickstart directory now includes dedicated quickstart scripts for FalkorDB (quickstart\_falkordb.py) and Amazon Neptune (quickstart\_neptune.py), in addition to the existing Neo4j example. These new examples demonstrate how to initialize Graphiti with their respective drivers, add episodes, and perform hybrid and graph-aware searches. The updated README documents the prerequisites and setup instructions for all three supported databases.
examples/quickstart · high confidence
New utility modules for bulk ingestion, content chunking, and datetime handling
This change introduces several new utility modules in \graphiti\_core/utils\ to support bulk ingestion and improved data processing. \bulk\_utils.py\ provides functions for bulk adding nodes and edges, including directed UUID mapping for deduplication and batch database operations. \content\_chunking.py\ adds logic to estimate token counts and determine if content (JSON or text) has high entity density, deciding whether to chunk it for LLM processing. \datetime\_utils.py\ standardizes UTC datetime handling with \utc\_now()\ and conversion functions to ensure consistent serialization across different graph drivers. \text\_utils.py\ adds helpers for truncating summaries at sentence boundaries and concatenating episodes with headers for LLM context.
_graphiti\core/utils · high confidence
Removals
Removal of core graph data models and client
The core graph data models (nodes and edges) and the Graphiti client class have been removed from the codebase. This eliminates the previous implementation of Episodic and Semantic nodes, along with their associated Neo4j persistence logic and the main Graphiti entry point.
core · high confidence
Behavioural changes
1 commit (0 fixes) modifying examples/concurrent\_ingestion, graphiti\_core/ingestion
A change to existing behaviour in examples/concurrent\_ingestion, graphiti\_core/ingestion — 1 commit, 11 files: “Add concurrent ingestion for one graph (\#2154)” (refs \#2154).
_examples/concurrent\_ingestion, graphiti\core/ingestion · medium confidence · unverified
Add database-specific query generation for Episodic and Entity nodes
The node persistence layer now generates distinct Cypher-like queries tailored to specific graph database providers (Neptune, Kuzu, FalkorDB, and Neo4j). This ensures correct handling of provider-specific features, such as vector embedding storage and list serialization, when saving or bulk-saving Episodic and Entity nodes.
_graphiti\core/models/nodes · high confidence
Edge persistence logic refactored to support multiple graph database providers
The edge model layer has been restructured to support saving and querying edges across different graph database backends, including Neo4j, FalkorDB, Neptune, and Kuzu. This change introduces provider-specific Cypher queries for saving episodic and entity edges, handling nuances such as embedding vector formats (e.g., \vecf32\ for FalkorDB) and relationship directionality. Users benefit from consistent edge behavior regardless of the underlying graph driver, with the system automatically selecting the correct query structure based on the configured provider.
_graphiti\core/models/edges · high confidence
New modular LLM client architecture with multi-provider support
The LLM client layer has been restructured into a modular, provider-specific architecture. This introduces dedicated client implementations for OpenAI, Azure OpenAI, Anthropic, Gemini, Groq, and the local GLiNER2 model, all unified under a common LLMClient interface. Key behavioral changes include the introduction of retry logic with exponential backoff for transient errors, a new SQLite-based response cache (replacing the previous diskcache implementation to address a security vulnerability), and configurable max token limits that vary by model. The system now supports structured output parsing, reasoning model features (such as effort and verbosity settings for GPT-5), and language-aware extraction instructions.
_graphiti\_core/llm\client · high confidence
Refactored prompt system with modular deduplication and extraction logic
The prompt library has been restructured into a modular architecture with dedicated files for node and edge deduplication (\dedupe\_nodes.py\, \dedupe\_edges.py\), extraction (\extract\_nodes.py\, \extract\_edges.py\, \extract\_nodes\_and\_edges.py\), and summarization (\summarize\_nodes.py\). This change introduces stricter entity naming rules to prevent generic extractions (e.g., requiring 'Nisha's dad' instead of 'dad'), enforces specific temporal resolution using ISO 8601 timestamps, and adds a combined node+edge extraction path for single-pass processing. Additionally, the system now supports custom edge types and includes an evaluation module (\eval.py\) for assessing extraction quality.
_graphiti\core/prompts · high confidence
Test coverage
1 commit adding/updating tests in tests/ingestion; Added end-to-end graph building evaluation suite; Added live end-to-end regression test for the graph service API; Added test coverage for graph maintenance utilities; Added tests for BGE and Gemini reranker clients; Added tests for episode concatenation and content chunking utilities; Added tests for the GitHub issue/PR intake automation; Added unit and integration tests for LLM client providers and utilities; Added unit tests for FalkorDB and Neo4j driver routing and operations; Added unit tests for Gemini, OpenAI, and VoyageAI embedders; Added unit tests for search utilities and security hardening; Comprehensive test suite for Graphiti MCP Server; Expanded test coverage for graph operations, concurrency fixes, and security hardening.
Dependencies
Dependency and build manifest updates across core, server, and MCP server
This change updates dependency declarations and build configurations across five key areas. The core library (graphiti-core) is bumped to version 0.30.2, with updated requirements for pydantic (\>=2.11.5), neo4j (\>=5.26.0), and openai (\>=1.91.0), while also pinning redis\<9 for the falkordblite extra to ensure compatibility. The MCP server (mcp-server) is upgraded to version 1.1.0, requiring mcp SDK 2.x (\>=2,\<3), openai (\>=2.41.0), and graphiti-core (\>=0.30.2), along with updated provider dependencies for google-genai, anthropic, and groq. The graph service server is updated to require graphiti-core\>=0.28.2, fastapi\>=0.115.0, and uvicorn\>=0.44.0. Additionally, new example projects for OpenTelemetry and quickstart are introduced with their own specific dependency sets.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 52 → 51 (-0.3)
- Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 61 → 58 (-3.5)
- Architecture 92 → 93 (+1.2)
- Maturity 65 → 69 (+3.6)
- Readiness 76 → 76 (+0.0)
- Security 32 → 32 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (41)
- Change coupling: extract_edges.py ↔ node_operations.py (graphiti_core/prompts/extract_edges.py)
- Change coupling: summarize_nodes.py ↔ node_operations.py (graphiti_core/prompts/summarize_nodes.py)
- Duplicated block (10 lines × 2) (graphiti_core/driver/falkordb/operations/community_node_ops.py)
- Duplicated block (10 lines × 2) (graphiti_core/driver/falkordb/operations/saga_node_ops.py)
- Duplicated block (10 lines × 2) (graphiti_core/edges.py)
- Duplicated block (12 lines × 2) (graphiti_core/driver/falkordb/operations/community_node_ops.py)
- Duplicated block (12 lines × 2) (graphiti_core/driver/falkordb/operations/episode_node_ops.py)
- Duplicated block (12 lines × 2) (graphiti_core/driver/falkordb/operations/saga_node_ops.py)
- Duplicated block (13 lines × 2) (graphiti_core/driver/falkordb/operations/graph_ops.py)
- Duplicated block (14 lines × 2) (graphiti_core/driver/kuzu/operations/search_ops.py)
- Duplicated block (176–178 lines × 2) (graphiti_core/search/search_utils.py)
- Duplicated block (18–19 lines × 4) (graphiti_core/driver/falkordb/operations/search_ops.py)
- Duplicated block (19–20 lines × 3) (graphiti_core/edges.py)
- Duplicated block (19–29 lines × 2) (graphiti_core/utils/bulk_utils.py)
- Duplicated block (20 lines × 2) (graphiti_core/search/search_utils.py)
- Duplicated block (20 lines × 3) (examples/quickstart/quickstart_falkordb.py)
- Duplicated block (20 lines × 4) (graphiti_core/search/search_filters.py)
- Duplicated block (21–23 lines × 2) (graphiti_core/search/search_utils.py)
- Duplicated block (24 lines × 2) (graphiti_core/driver/falkordb/operations/community_node_ops.py)
- Duplicated block (24 lines × 2) (graphiti_core/driver/falkordb/operations/episode_node_ops.py)
- …and 21 more
New (105)
- Delta.match_nodes (cognitive 23) (graphiti_core/ingestion/delta.py)
- Duplicated block (13 lines × 2) (graphiti_core/driver/falkordb/operations/graph_ops.py)
- Duplicated block (131–132 lines × 2) (graphiti_core/search/search_utils.py)
- Duplicated block (15 lines × 2) (graphiti_core/graphiti.py)
- Duplicated block (15 lines × 2) (graphiti_core/ingestion/phases.py)
- Duplicated block (17 lines × 2) (graphiti_core/edges.py)
- Duplicated block (18–19 lines × 3) (graphiti_core/driver/falkordb/operations/search_ops.py)
- Duplicated block (20–22 lines × 2) (graphiti_core/ingestion/phases.py)
- Duplicated block (25 lines × 2) (graphiti_core/driver/falkordb/operations/search_ops.py)
- Edited copies of one member (3 members, 106+ corresponding lines) (graphiti_core/search/search_utils.py)
- Edited copies of one member (3 members, 12+ corresponding lines) (graphiti_core/driver/falkordb/operations/community_node_ops.py)
- Edited copies of one member (3 members, 12+ corresponding lines) (graphiti_core/driver/falkordb/operations/episode_node_ops.py)
- Edited copies of one member (3 members, 12+ corresponding lines) (graphiti_core/driver/falkordb/operations/episode_node_ops.py)
- Edited copies of one member (3 members, 12+ corresponding lines) (graphiti_core/driver/falkordb/operations/saga_node_ops.py)
- Edited copies of one member (3 members, 13+ corresponding lines) (graphiti_core/driver/neptune/operations/community_edge_ops.py)
- Edited copies of one member (3 members, 22+ corresponding lines) (graphiti_core/nodes.py)
- Edited copies of one member (3 members, 24+ corresponding lines) (graphiti_core/edges.py)
- Edited copies of one member (3 members, 27+ corresponding lines) (graphiti_core/edges.py)
- Edited copies of one member (3 members, 27+ corresponding lines) (mcp_server/src/graphiti_mcp_server.py)
- Edited copies of one member (3 members, 32+ corresponding lines) (graphiti_core/search/search_utils.py)
- …and 85 more
Changes since last survey
- 9 commits — 8 feature/other, 1 fixes
By area
- signatures/version1 — 6 commits
- graphiti_core/driver — 1 commit
- graphiti_core/utils — 1 commit
- tests/ingestion — 1 commit
Notable commits
- fix: Fix identity-property node merge through the public API (#2153)
- change: @Bensonluo has signed the CLA in getzep/graphiti#2143
- change: @Elon-Jiang has signed the CLA in getzep/graphiti#2148
- change: @HhH666-ux has signed the CLA in getzep/graphiti#2129
- change: @Ker102 has signed the CLA in getzep/graphiti#2094
- change: @Ovi-Poddar has signed the CLA in getzep/graphiti#2138
- change: @Wang-Zephyr has signed the CLA in getzep/graphiti#2146
- change: Add concurrent ingestion for one graph (#2154)
- change: Remove the Kuzu driver (#2151)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
getzep/graphiti was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 869c1b279e01a2767a464581e1cb657ce0e39271 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.73+preprod-52de90b74216.