or embedded version (requires Python 3.12+)

pip install graphiti-core[falkordblite]

Or use embedded FalkorDB Lite (requires Python 3.12+)

Installation

Requirements:

- Python 3.10 or higher - Neo4j 5.26 / FalkorDB 1.1.2 / Amazon Neptune Database Cluster or Neptune Analytics Graph + Amazon OpenSearch Serverless collection (serves as the full text search backend) / Kuzu 0.11.2 (deprecated, see below) - OpenAI API key (Graphiti defaults to OpenAI for LLM inference and embedding)

[!IMPORTANT] Graphiti works best with LLM services that support Structured Output (such as OpenAI, Anthropic, and Gemini). Using other services may result in incorrect output schemas and ingestion failures. This is particularly problematic when using smaller models.

Optional:

• Google Gemini, Anthropic, or Groq API key (for alternative LLM providers)

[!TIP] The simplest way to install Neo4j is via Neo4j Desktop. It provides a user-friendly interface to manage Neo4j instances and databases. Alternatively, you can use FalkorDB on-premises via Docker and instantly start with the quickstart example:

> docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
> 

pip install graphiti-core

or

uv add graphiti-core

Installing with FalkorDB Support

If you plan to use FalkorDB as your graph database backend, install with the FalkorDB extra:

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

Installing with Kuzu Support

[!WARNING] Kuzu is deprecated and will be removed in a future release — the upstream Kuzu project is no longer maintained. New projects should use Neo4j or FalkorDB. The driver still ships for now but emits a DeprecationWarning.

If you plan to use Kuzu as your graph database backend, install with the Kuzu extra:

```bash pip install graphiti-core[kuzu]

Installing with Amazon Neptune Support

If you plan to use Amazon Neptune as your graph database backend, install with the Amazon Neptune extra:

```bash pip install graphiti-core[neptune]

You can also install optional LLM providers as extras:

```bash

Install with Anthropic support

pip install graphiti-core[anthropic]

Install with Groq support

pip install graphiti-core[groq]

Install with Google Gemini support

pip install graphiti-core[google-genai]

Install with multiple providers

pip install graphiti-core[anthropic,groq,google-genai]

Install with FalkorDB and LLM providers

pip install graphiti-core[falkordb,anthropic,google-genai]

Install with Amazon Neptune

pip install graphiti-core[neptune] ```

Running with Docker Compose

You can use Docker Compose to quickly start the required services:

• Neo4j Docker:

  docker compose up
  

This will start the Neo4j Docker service and related components.

• FalkorDB Docker:

  docker compose --profile falkordb up
  

This will start the FalkorDB Docker service and related components.

Quick Start

[!IMPORTANT] Graphiti defaults to using OpenAI for LLM inference and embedding. Ensure that an OPENAI_API_KEY is set in your environment. Support for Anthropic, Gemini, and Groq is available, too. Other LLM providers — both hosted OpenAI-compatible APIs (DeepSeek, Together, OpenRouter, …) and local servers (Ollama, vLLM, llama.cpp, LM Studio) — may be used via their OpenAI-compatible endpoints; see Using Graphiti with OpenAI-compatible providers and local LLMs.

For a complete working example, see the Quickstart Example in the examples directory. The quickstart demonstrates:

1. Connecting to a Neo4j, Amazon Neptune, FalkorDB, or Kuzu database
2. Initializing Graphiti indices and constraints
3. Adding episodes to the graph (both text and structured JSON)
4. Searching for relationships (edges) using hybrid search
5. Reranking search results using graph distance
6. Searching for nodes using predefined search recipes

The example is fully documented with clear explanations of each functionality and includes a comprehensive README with setup instructions and next steps.

Quick Start

```python from openai import AsyncOpenAI from graphiti_core import Graphiti from graphiti_core.llm_client.azure_openai_client import AzureOpenAILLMClient from graphiti_core.llm_client.config import LLMConfig from graphiti_core.embedder.azure_openai import AzureOpenAIEmbedderClient

Optional Environment Variables

In addition to the Neo4j and OpenAi-compatible credentials, Graphiti also has a few optional environment variables. If you are using one of our supported models, such as Anthropic or Voyage models, the necessary environment variables must be set.

Database Configuration

Database names are configured directly in the driver constructors:

• Neo4j: Database name defaults to neo4j (hardcoded in Neo4jDriver)
• FalkorDB: Database name defaults to default_db (hardcoded in FalkorDriver)

As of v0.17.0, if you need to customize your database configuration, you can instantiate a database driver and pass it to the Graphiti constructor using the graph_driver parameter.

Neo4j with Custom Database Name

```python from graphiti_core import Graphiti from graphiti_core.driver.neo4j_driver import Neo4jDriver

Google API key configuration

api_key = "<your-google-api-key>"

Configure Ollama LLM client

llm_config = LLMConfig( api_key="ollama", # Ollama doesn't require a real API key, but some placeholder is needed model="deepseek-r1:7b", small_model="deepseek-r1:7b", base_url="http://localhost:11434/v1", # Ollama's OpenAI-compatible endpoint )

llm_client = OpenAIGenericClient(config=llm_config)

with Azure's v1 API endpoint

azure_client = AsyncOpenAI( base_url="https://your-resource-name.openai.azure.com/openai/v1/", api_key="your-api-key", )

Now you can use Graphiti with Google Gemini for all components

```

The Gemini reranker uses the gemini-2.5-flash-lite model by default, which is optimized for cost-effective and low-latency classification tasks. It uses the same boolean classification approach as the OpenAI reranker, leveraging Gemini's log probabilities feature to rank passage relevance.

Zep vs Graphiti

Graphiti vs. GraphRAG

Graphiti is specifically designed to address the challenges of dynamic and frequently updated datasets, making it particularly suitable for applications requiring real-time interaction and precise historical queries.