Skip to content
CAI
Software that uses CAICheck a score

getzep/graphiti

51.2

Adequate · 15 November 2026

41.5k

lines of production code

Python

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

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.