graphiti-core 0.17.4__py3-none-any.whl → 0.24.3__py3-none-any.whl

graphiti_core/utils/ontology_utils/entity_types_utils.py

@@ -21,7 +21,7 @@ from graphiti_core.nodes import EntityNode
 
 
 def validate_entity_types(
-    entity_types: dict[str, BaseModel] | None,
+    entity_types: dict[str, type[BaseModel]] | None,
 ) -> bool:
     if entity_types is None:
         return True

graphiti_core/utils/text_utils.py

@@ -0,0 +1,53 @@
+"""
+Copyright 2024, Zep Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import re
+
+# Maximum length for entity/node summaries
+MAX_SUMMARY_CHARS = 500
+
+
+def truncate_at_sentence(text: str, max_chars: int) -> str:
+    """
+    Truncate text at or about max_chars while respecting sentence boundaries.
+
+    Attempts to truncate at the last complete sentence before max_chars.
+    If no sentence boundary is found before max_chars, truncates at max_chars.
+
+    Args:
+        text: The text to truncate
+        max_chars: Maximum number of characters
+
+    Returns:
+        Truncated text
+    """
+    if not text or len(text) <= max_chars:
+        return text
+
+    # Find all sentence boundaries (., !, ?) up to max_chars
+    truncated = text[:max_chars]
+
+    # Look for sentence boundaries: period, exclamation, or question mark followed by space or end
+    sentence_pattern = r'[.!?](?:\s|$)'
+    matches = list(re.finditer(sentence_pattern, truncated))
+
+    if matches:
+        # Truncate at the last sentence boundary found
+        last_match = matches[-1]
+        return text[: last_match.end()].rstrip()
+
+    # No sentence boundary found, truncate at max_chars
+    return truncated.rstrip()

{graphiti_core-0.17.4.dist-info → graphiti_core-0.24.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.17.4
+Version: 0.24.3
 Summary: A temporal graph building library
 Project-URL: Homepage, https://help.getzep.com/graphiti/graphiti/overview
 Project-URL: Repository, https://github.com/getzep/graphiti
@@ -20,17 +20,22 @@ Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
 Provides-Extra: dev
 Requires-Dist: anthropic>=0.49.0; extra == 'dev'
+Requires-Dist: boto3>=1.39.16; extra == 'dev'
 Requires-Dist: diskcache-stubs>=5.6.3.6.20240818; extra == 'dev'
 Requires-Dist: falkordb<2.0.0,>=1.1.2; extra == 'dev'
 Requires-Dist: google-genai>=1.8.0; extra == 'dev'
 Requires-Dist: groq>=0.2.0; extra == 'dev'
 Requires-Dist: ipykernel>=6.29.5; extra == 'dev'
 Requires-Dist: jupyterlab>=4.2.4; extra == 'dev'
+Requires-Dist: kuzu>=0.11.3; extra == 'dev'
 Requires-Dist: langchain-anthropic>=0.2.4; extra == 'dev'
+Requires-Dist: langchain-aws>=0.2.29; extra == 'dev'
 Requires-Dist: langchain-openai>=0.2.6; extra == 'dev'
 Requires-Dist: langgraph>=0.2.15; extra == 'dev'
 Requires-Dist: langsmith>=0.1.108; extra == 'dev'
-Requires-Dist: pyright>=1.1.380; extra == 'dev'
+Requires-Dist: opensearch-py>=3.0.0; extra == 'dev'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'dev'
+Requires-Dist: pyright>=1.1.404; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
 Requires-Dist: pytest-xdist>=3.6.1; extra == 'dev'
 Requires-Dist: pytest>=8.3.3; extra == 'dev'
@@ -44,8 +49,20 @@ Provides-Extra: google-genai
 Requires-Dist: google-genai>=1.8.0; extra == 'google-genai'
 Provides-Extra: groq
 Requires-Dist: groq>=0.2.0; extra == 'groq'
+Provides-Extra: kuzu
+Requires-Dist: kuzu>=0.11.3; extra == 'kuzu'
+Provides-Extra: neo4j-opensearch
+Requires-Dist: boto3>=1.39.16; extra == 'neo4j-opensearch'
+Requires-Dist: opensearch-py>=3.0.0; extra == 'neo4j-opensearch'
+Provides-Extra: neptune
+Requires-Dist: boto3>=1.39.16; extra == 'neptune'
+Requires-Dist: langchain-aws>=0.2.29; extra == 'neptune'
+Requires-Dist: opensearch-py>=3.0.0; extra == 'neptune'
 Provides-Extra: sentence-transformers
 Requires-Dist: sentence-transformers>=3.2.1; extra == 'sentence-transformers'
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'tracing'
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'tracing'
 Provides-Extra: voyageai
 Requires-Dist: voyageai>=0.2.3; extra == 'voyageai'
 Description-Content-Type: text/markdown
@@ -83,9 +100,15 @@ Graphiti
 <br />
 
 > [!TIP]
-> Check out the new [MCP server for Graphiti](mcp_server/README.md)! Give Claude, Cursor, and other MCP clients powerful Knowledge Graph-based memory.
+> Check out the new [MCP server for Graphiti](mcp_server/README.md)! Give Claude, Cursor, and other MCP clients powerful
+> Knowledge Graph-based memory.
 
-Graphiti is a framework for building and querying temporally-aware knowledge graphs, specifically tailored for AI agents operating in dynamic environments. Unlike traditional retrieval-augmented generation (RAG) methods, Graphiti continuously integrates user interactions, structured and unstructured enterprise data, and external information into a coherent, queryable graph. The framework supports incremental data updates, efficient retrieval, and precise historical queries without requiring complete graph recomputation, making it suitable for developing interactive, context-aware AI applications.
+Graphiti is a framework for building and querying temporally-aware knowledge graphs, specifically tailored for AI agents
+operating in dynamic environments. Unlike traditional retrieval-augmented generation (RAG) methods, Graphiti
+continuously integrates user interactions, structured and unstructured enterprise data, and external information into a
+coherent, queryable graph. The framework supports incremental data updates, efficient retrieval, and precise historical
+queries without requiring complete graph recomputation, making it suitable for developing interactive, context-aware AI
+applications.
 
 Use Graphiti to:
 
@@ -96,19 +119,21 @@ Use Graphiti to:
 <br />
 
 <p align="center">
-    <img src="images/graphiti-graph-intro.gif" alt="Graphiti temporal walkthrough" width="700px">   
+    <img src="images/graphiti-graph-intro.gif" alt="Graphiti temporal walkthrough" width="700px">
 </p>
 
 <br />
 
-A knowledge graph is a network of interconnected facts, such as _"Kendra loves Adidas shoes."_ Each fact is a "triplet" represented by two entities, or
+A knowledge graph is a network of interconnected facts, such as _"Kendra loves Adidas shoes."_ Each fact is a "triplet"
+represented by two entities, or
 nodes ("Kendra", "Adidas shoes"), and their relationship, or edge ("loves"). Knowledge Graphs have been explored
 extensively for information retrieval. What makes Graphiti unique is its ability to autonomously build a knowledge graph
 while handling changing relationships and maintaining historical context.
 
-## Graphiti and Zep Memory
+## Graphiti and Zep's Context Engineering Platform.
 
-Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for AI Agents.
+Graphiti powers the core of [Zep](https://www.getzep.com), a turn-key context engineering platform for AI Agents. Zep
+offers agent memory, Graph RAG for dynamic data, and context retrieval and assembly.
 
 Using Graphiti, we've demonstrated Zep is
 the [State of the Art in Agent Memory](https://blog.getzep.com/state-of-the-art-agent-memory/).
@@ -121,24 +146,45 @@ We're excited to open-source Graphiti, believing its potential reaches far beyon
     <a href="https://arxiv.org/abs/2501.13956"><img src="images/arxiv-screenshot.png" alt="Zep: A Temporal Knowledge Graph Architecture for Agent Memory" width="700px"></a>
 </p>
 
+## Zep vs Graphiti
+
+| Aspect | Zep | Graphiti |
+|--------|-----|----------|
+| **What they are** | Fully managed platform for context engineering and AI memory | Open-source graph framework |
+| **User & conversation management** | Built-in users, threads, and message storage | Build your own |
+| **Retrieval & performance** | Pre-configured, production-ready retrieval with sub-200ms performance at scale | Custom implementation required; performance depends on your setup |
+| **Developer tools** | Dashboard with graph visualization, debug logs, API logs; SDKs for Python, TypeScript, and Go | Build your own tools |
+| **Enterprise features** | SLAs, support, security guarantees | Self-managed |
+| **Deployment** | Fully managed or in your cloud | Self-hosted only |
+
+### When to choose which
+
+**Choose Zep** if you want a turnkey, enterprise-grade platform with security, performance, and support baked in.
+
+**Choose Graphiti** if you want a flexible OSS core and you're comfortable building/operating the surrounding system.
+
 ## Why Graphiti?
 
-Traditional RAG approaches often rely on batch processing and static data summarization, making them inefficient for frequently changing data. Graphiti addresses these challenges by providing:
+Traditional RAG approaches often rely on batch processing and static data summarization, making them inefficient for
+frequently changing data. Graphiti addresses these challenges by providing:
 
 - **Real-Time Incremental Updates:** Immediate integration of new data episodes without batch recomputation.
-- **Bi-Temporal Data Model:** Explicit tracking of event occurrence and ingestion times, allowing accurate point-in-time queries.
-- **Efficient Hybrid Retrieval:** Combines semantic embeddings, keyword (BM25), and graph traversal to achieve low-latency queries without reliance on LLM summarization.
-- **Custom Entity Definitions:** Flexible ontology creation and support for developer-defined entities through straightforward Pydantic models.
+- **Bi-Temporal Data Model:** Explicit tracking of event occurrence and ingestion times, allowing accurate point-in-time
+  queries.
+- **Efficient Hybrid Retrieval:** Combines semantic embeddings, keyword (BM25), and graph traversal to achieve
+  low-latency queries without reliance on LLM summarization.
+- **Custom Entity Definitions:** Flexible ontology creation and support for developer-defined entities through
+  straightforward Pydantic models.
 - **Scalability:** Efficiently manages large datasets with parallel processing, suitable for enterprise environments.
 
 <p align="center">
-    <img src="/images/graphiti-intro-slides-stock-2.gif" alt="Graphiti structured + unstructured demo" width="700px">   
+    <img src="/images/graphiti-intro-slides-stock-2.gif" alt="Graphiti structured + unstructured demo" width="700px">
 </p>
 
 ## Graphiti vs. GraphRAG
 
 | Aspect                     | GraphRAG                              | Graphiti                                         |
-| -------------------------- | ------------------------------------- | ------------------------------------------------ |
+|----------------------------|---------------------------------------|--------------------------------------------------|
 | **Primary Use**            | Static document summarization         | Dynamic data management                          |
 | **Data Handling**          | Batch-oriented processing             | Continuous, incremental updates                  |
 | **Knowledge Structure**    | Entity clusters & community summaries | Episodic data, semantic entities, communities    |
@@ -150,14 +196,16 @@ Traditional RAG approaches often rely on batch processing and static data summar
 | **Custom Entity Types**    | No                                    | Yes, customizable                                |
 | **Scalability**            | Moderate                              | High, optimized for large datasets               |
 
-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.
+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.
 
 ## Installation
 
 Requirements:
 
 - Python 3.10 or higher
-- Neo4j 5.26 / FalkorDB 1.1.2 or higher (serves as the embeddings storage backend)
+- Neo4j 5.26 / FalkorDB 1.1.2 / Kuzu 0.11.2 / Amazon Neptune Database Cluster or Neptune Analytics Graph + Amazon
+  OpenSearch Serverless collection (serves as the full text search backend)
 - OpenAI API key (Graphiti defaults to OpenAI for LLM inference and embedding)
 
 > [!IMPORTANT]
@@ -200,6 +248,28 @@ pip install graphiti-core[falkordb]
 uv add graphiti-core[falkordb]
 ```
 
+### Installing with Kuzu Support
+
+If you plan to use Kuzu as your graph database backend, install with the Kuzu extra:
+
+```bash
+pip install graphiti-core[kuzu]
+
+# or with uv
+uv add 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]
+
+# or with uv
+uv add graphiti-core[neptune]
+```
+
 ### You can also install optional LLM providers as extras:
 
 ```bash
@@ -217,29 +287,64 @@ 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]
 ```
 
+## Default to Low Concurrency; LLM Provider 429 Rate Limit Errors
+
+Graphiti's ingestion pipelines are designed for high concurrency. By default, concurrency is set low to avoid LLM
+Provider 429 Rate Limit Errors. If you find Graphiti slow, please increase concurrency as described below.
+
+Concurrency controlled by the `SEMAPHORE_LIMIT` environment variable. By default, `SEMAPHORE_LIMIT` is set to `10`
+concurrent operations to help prevent `429` rate limit errors from your LLM provider. If you encounter such errors, try
+lowering this value.
+
+If your LLM provider allows higher throughput, you can increase `SEMAPHORE_LIMIT` to boost episode ingestion
+performance.
+
 ## Quick Start
 
 > [!IMPORTANT]
-> Graphiti defaults to using OpenAI for LLM inference and embedding. Ensure that an `OPENAI_API_KEY` is set in your environment.
+> Graphiti defaults to using OpenAI for LLM inference and embedding. Ensure that an `OPENAI_API_KEY` is set in your
+> environment.
 > Support for Anthropic and Groq LLM inferences is available, too. Other LLM providers may be supported via OpenAI
 > compatible APIs.
 
-For a complete working example, see the [Quickstart Example](./examples/quickstart/README.md) in the examples directory. The quickstart demonstrates:
+For a complete working example, see the [Quickstart Example](./examples/quickstart/README.md) in the examples directory.
+The quickstart demonstrates:
 
-1. Connecting to a Neo4j or FalkorDB database
+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.
+The example is fully documented with clear explanations of each functionality and includes a comprehensive README with
+setup instructions and next steps.
+
+### Running with Docker Compose
+
+You can use Docker Compose to quickly start the required services:
+
+- **Neo4j Docker:**
+  ```sh
+  docker compose up
+  ```
+  This will start the Neo4j Docker service and related components.
+
+- **FalkorDB Docker:**
+  ```sh
+  docker compose --profile falkordb up
+  ```
+  This will start the FalkorDB Docker service and related components.
 
 ## MCP Server
 
-The `mcp_server` directory contains a Model Context Protocol (MCP) server implementation for Graphiti. This server allows AI assistants to interact with Graphiti's knowledge graph capabilities through the MCP protocol.
+The `mcp_server` directory contains a Model Context Protocol (MCP) server implementation for Graphiti. This server
+allows AI assistants to interact with Graphiti's knowledge graph capabilities through the MCP protocol.
 
 Key features of the MCP server include:
 
@@ -249,7 +354,8 @@ Key features of the MCP server include:
 - Group management for organizing related data
 - Graph maintenance operations
 
-The MCP server can be deployed using Docker with Neo4j, making it easy to integrate Graphiti into your AI assistant workflows.
+The MCP server can be deployed using Docker with Neo4j, making it easy to integrate Graphiti into your AI assistant
+workflows.
 
 For detailed setup instructions and usage examples, see the [MCP server README](./mcp_server/README.md).
 
@@ -272,7 +378,8 @@ 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.
+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
 
@@ -311,48 +418,71 @@ driver = FalkorDriver(
 graphiti = Graphiti(graph_driver=driver)
 ```
 
+#### Kuzu
 
-### Performance Configuration
+```python
+from graphiti_core import Graphiti
+from graphiti_core.driver.kuzu_driver import KuzuDriver
 
-`USE_PARALLEL_RUNTIME` is an optional boolean variable that can be set to true if you wish
-to enable Neo4j's parallel runtime feature for several of our search queries.
-Note that this feature is not supported for Neo4j Community edition or for smaller AuraDB instances,
-as such this feature is off by default.
+# Create a Kuzu driver
+driver = KuzuDriver(db="/tmp/graphiti.kuzu")
 
-## Using Graphiti with Azure OpenAI
+# Pass the driver to Graphiti
+graphiti = Graphiti(graph_driver=driver)
+```
 
-Graphiti supports Azure OpenAI for both LLM inference and embeddings. Azure deployments often require different endpoints for LLM and embedding services, and separate deployments for default and small models.
+#### Amazon Neptune
 
 ```python
-from openai import AsyncAzureOpenAI
 from graphiti_core import Graphiti
-from graphiti_core.llm_client import LLMConfig, OpenAIClient
-from graphiti_core.embedder.openai import OpenAIEmbedder, OpenAIEmbedderConfig
-from graphiti_core.cross_encoder.openai_reranker_client import OpenAIRerankerClient
+from graphiti_core.driver.neptune_driver import NeptuneDriver
 
-# Azure OpenAI configuration - use separate endpoints for different services
-api_key = "<your-api-key>"
-api_version = "<your-api-version>"
-llm_endpoint = "<your-llm-endpoint>"  # e.g., "https://your-llm-resource.openai.azure.com/"
-embedding_endpoint = "<your-embedding-endpoint>"  # e.g., "https://your-embedding-resource.openai.azure.com/"
-
-# Create separate Azure OpenAI clients for different services
-llm_client_azure = AsyncAzureOpenAI(
-    api_key=api_key,
-    api_version=api_version,
-    azure_endpoint=llm_endpoint
+# Create a FalkorDB driver with custom database name
+driver = NeptuneDriver(
+    host= < NEPTUNE
+ENDPOINT >,
+aoss_host = < Amazon
+OpenSearch
+Serverless
+Host >,
+port = < PORT >  # Optional, defaults to 8182,
+         aoss_port = < PORT >  # Optional, defaults to 443
 )
 
-embedding_client_azure = AsyncAzureOpenAI(
-    api_key=api_key,
-    api_version=api_version,
-    azure_endpoint=embedding_endpoint
+driver = NeptuneDriver(host=neptune_uri, aoss_host=aoss_host, port=neptune_port)
+
+# Pass the driver to Graphiti
+graphiti = Graphiti(graph_driver=driver)
+```
+
+## Using Graphiti with Azure OpenAI
+
+Graphiti supports Azure OpenAI for both LLM inference and embeddings using Azure's OpenAI v1 API compatibility layer.
+
+### 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
+
+# Initialize Azure OpenAI client using the standard OpenAI client
+# 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",
 )
 
-# Create LLM Config with your Azure deployment names
-azure_llm_config = LLMConfig(
-    small_model="gpt-4.1-nano",
-    model="gpt-4.1-mini",
+# Create LLM and Embedder clients
+llm_client = AzureOpenAILLMClient(
+    azure_client=azure_client,
+    config=LLMConfig(model="gpt-5-mini", small_model="gpt-5-mini")  # Your Azure deployment name
+)
+embedder_client = AzureOpenAIEmbedderClient(
+    azure_client=azure_client,
+    model="text-embedding-3-small"  # Your Azure embedding deployment name
 )
 
 # Initialize Graphiti with Azure OpenAI clients
@@ -360,32 +490,24 @@ graphiti = Graphiti(
     "bolt://localhost:7687",
     "neo4j",
     "password",
-    llm_client=OpenAIClient(
-        llm_config=azure_llm_config,
-        client=llm_client_azure
-    ),
-    embedder=OpenAIEmbedder(
-        config=OpenAIEmbedderConfig(
-            embedding_model="text-embedding-3-small-deployment"  # Your Azure embedding deployment name
-        ),
-        client=embedding_client_azure
-    ),
-    cross_encoder=OpenAIRerankerClient(
-        llm_config=LLMConfig(
-            model=azure_llm_config.small_model  # Use small model for reranking
-        ),
-        client=llm_client_azure
-    )
+    llm_client=llm_client,
+    embedder=embedder_client,
 )
 
 # Now you can use Graphiti with Azure OpenAI
 ```
 
-Make sure to replace the placeholder values with your actual Azure OpenAI credentials and deployment names that match your Azure OpenAI service configuration.
+**Key Points:**
+- Use the standard `AsyncOpenAI` client with Azure's v1 API endpoint format: `https://your-resource-name.openai.azure.com/openai/v1/`
+- The deployment names (e.g., `gpt-5-mini`, `text-embedding-3-small`) should match your Azure OpenAI deployment names
+- See `examples/azure-openai/` for a complete working example
+
+Make sure to replace the placeholder values with your actual Azure OpenAI credentials and deployment names.
 
 ## Using Graphiti with Google Gemini
 
-Graphiti supports Google's Gemini models for LLM inference, embeddings, and cross-encoding/reranking. To use Gemini, you'll need to configure the LLM client, embedder, and the cross-encoder with your Google API key.
+Graphiti supports Google's Gemini models for LLM inference, embeddings, and cross-encoding/reranking. To use Gemini,
+you'll need to configure the LLM client, embedder, and the cross-encoder with your Google API key.
 
 Install Graphiti:
 
@@ -426,7 +548,7 @@ graphiti = Graphiti(
     cross_encoder=GeminiRerankerClient(
         config=LLMConfig(
             api_key=api_key,
-            model="gemini-2.5-flash-lite-preview-06-17"
+            model="gemini-2.5-flash-lite"
         )
     )
 )
@@ -434,32 +556,40 @@ graphiti = Graphiti(
 # Now you can use Graphiti with Google Gemini for all components
 ```
 
-The Gemini reranker uses the `gemini-2.5-flash-lite-preview-06-17` 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.
+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.
 
 ## Using Graphiti with Ollama (Local LLM)
 
-Graphiti supports Ollama for running local LLMs and embedding models via Ollama's OpenAI-compatible API. This is ideal for privacy-focused applications or when you want to avoid API costs.
+Graphiti supports Ollama for running local LLMs and embedding models via Ollama's OpenAI-compatible API. This is ideal
+for privacy-focused applications or when you want to avoid API costs.
+
+**Note:** Use `OpenAIGenericClient` (not `OpenAIClient`) for Ollama and other OpenAI-compatible providers like LM Studio. The `OpenAIGenericClient` is optimized for local models with a higher default max token limit (16K vs 8K) and full support for structured outputs.
 
 Install the models:
+
+```bash
 ollama pull deepseek-r1:7b # LLM
 ollama pull nomic-embed-text # embeddings
+```
 
 ```python
 from graphiti_core import Graphiti
 from graphiti_core.llm_client.config import LLMConfig
-from graphiti_core.llm_client.openai_client import OpenAIClient
+from graphiti_core.llm_client.openai_generic_client import OpenAIGenericClient
 from graphiti_core.embedder.openai import OpenAIEmbedder, OpenAIEmbedderConfig
 from graphiti_core.cross_encoder.openai_reranker_client import OpenAIRerankerClient
 
 # Configure Ollama LLM client
 llm_config = LLMConfig(
-    api_key="abc",  # Ollama doesn't require a real API key
+    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 provides this port
+    base_url="http://localhost:11434/v1",  # Ollama's OpenAI-compatible endpoint
 )
 
-llm_client = OpenAIClient(config=llm_config)
+llm_client = OpenAIGenericClient(config=llm_config)
 
 # Initialize Graphiti with Ollama clients
 graphiti = Graphiti(
@@ -469,7 +599,7 @@ graphiti = Graphiti(
     llm_client=llm_client,
     embedder=OpenAIEmbedder(
         config=OpenAIEmbedderConfig(
-            api_key="abc",
+            api_key="ollama",  # Placeholder API key
             embedding_model="nomic-embed-text",
             embedding_dim=768,
             base_url="http://localhost:11434/v1",
@@ -487,11 +617,12 @@ Ensure Ollama is running (`ollama serve`) and that you have pulled the models yo
 
 - [Guides and API documentation](https://help.getzep.com/graphiti).
 - [Quick Start](https://help.getzep.com/graphiti/graphiti/quick-start)
-- [Building an agent with LangChain's LangGraph and Graphiti](https://help.getzep.com/graphiti/graphiti/lang-graph-agent)
+- [Building an agent with LangChain's LangGraph and Graphiti](https://help.getzep.com/graphiti/integrations/lang-graph-agent)
 
 ## Telemetry
 
-Graphiti collects anonymous usage statistics to help us understand how the framework is being used and improve it for everyone. We believe transparency is important, so here's exactly what we collect and why.
+Graphiti collects anonymous usage statistics to help us understand how the framework is being used and improve it for
+everyone. We believe transparency is important, so here's exactly what we collect and why.
 
 ### What We Collect
 
@@ -501,9 +632,9 @@ When you initialize a Graphiti instance, we collect:
 - **System information**: Operating system, Python version, and system architecture
 - **Graphiti version**: The version you're using
 - **Configuration choices**:
-  - LLM provider type (OpenAI, Azure, Anthropic, etc.)
-  - Database backend (Neo4j, FalkorDB)
-  - Embedder provider (OpenAI, Azure, Voyage, etc.)
+    - LLM provider type (OpenAI, Azure, Anthropic, etc.)
+    - Database backend (Neo4j, FalkorDB, Kuzu, Amazon Neptune Database or Neptune Analytics)
+    - Embedder provider (OpenAI, Azure, Voyage, etc.)
 
 ### What We Don't Collect
 
@@ -555,10 +686,12 @@ echo 'export GRAPHITI_TELEMETRY_ENABLED=false' >> ~/.zshrc
 
 ```python
 import os
+
 os.environ['GRAPHITI_TELEMETRY_ENABLED'] = 'false'
 
 # Then initialize Graphiti as usual
 from graphiti_core import Graphiti
+
 graphiti = Graphiti(...)
 ```
 
@@ -567,7 +700,8 @@ Telemetry is automatically disabled during test runs (when `pytest` is detected)
 ### Technical Details
 
 - Telemetry uses PostHog for anonymous analytics collection
-- All telemetry operations are designed to fail silently - they will never interrupt your application or affect Graphiti functionality
+- All telemetry operations are designed to fail silently - they will never interrupt your application or affect Graphiti
+  functionality
 - The anonymous ID is stored locally and is not tied to any personal information
 
 ## Status and Roadmap
@@ -575,8 +709,8 @@ Telemetry is automatically disabled during test runs (when `pytest` is detected)
 Graphiti is under active development. We aim to maintain API stability while working on:
 
 - [x] Supporting custom graph schemas:
-  - Allow developers to provide their own defined node and edge classes when ingesting episodes
-  - Enable more flexible knowledge representation tailored to specific use cases
+    - Allow developers to provide their own defined node and edge classes when ingesting episodes
+    - Enable more flexible knowledge representation tailored to specific use cases
 - [x] Enhancing retrieval capabilities with more robust and configurable options
 - [x] Graphiti MCP Server
 - [ ] Expanding test coverage to ensure reliability and catch edge cases