graphiti-core 0.14.0__tar.gz → 0.15.0__tar.gz

graphiti_core-0.15.0/.github/workflows/typecheck.yml

@@ -0,0 +1,42 @@
+name: Pyright Type Check
+
+permissions:
+  contents: read
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  pyright:
+    runs-on: depot-ubuntu-22.04
+    environment: development
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        id: setup-python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+      - name: Install dependencies
+        run: uv sync --all-extras
+      - name: Run Pyright for graphiti-core
+        shell: bash
+        run: |
+          uv run pyright ./graphiti_core
+      - name: Install graph-service dependencies
+        shell: bash
+        run: |
+          cd server
+          uv sync --all-extras
+      - name: Run Pyright for graph-service
+        shell: bash
+        run: |
+          cd server
+          uv run pyright .

graphiti_core-0.15.0/.github/workflows/unit_tests.yml

@@ -0,0 +1,51 @@
+name: Unit Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: depot-ubuntu-22.04
+    environment:
+      name: development
+    services:
+      falkordb:
+        image: falkordb/falkordb:latest
+        ports:
+          - 6379:6379
+        options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+      - name: Install redis-cli for FalkorDB health check
+        run: sudo apt-get update && sudo apt-get install -y redis-tools
+      - name: Install dependencies
+        run: uv sync --all-extras
+      - name: Run non-integration tests
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+        run: |
+          uv run pytest -m "not integration"
+      - name: Wait for FalkorDB
+        run: |
+          timeout 60 bash -c 'until redis-cli -h localhost -p 6379 ping; do sleep 1; done'
+      - name: Run FalkorDB integration tests
+        env:
+          PYTHONPATH: ${{ github.workspace }}
+          FALKORDB_HOST: localhost
+          FALKORDB_PORT: 6379
+        run: |
+          uv run pytest tests/driver/test_falkordb_driver.py

{graphiti_core-0.14.0/server → graphiti_core-0.15.0}/Makefile

@@ -5,7 +5,7 @@ PYTHON = python3
 UV = uv
 PYTEST = $(UV) run pytest
 RUFF = $(UV) run ruff
-MYPY = $(UV) run mypy
+PYRIGHT = $(UV) run pyright
 
 # Default target
 all: format lint test
@@ -22,7 +22,7 @@ format:
 # Lint code
 lint:
 	$(RUFF) check
-	$(MYPY) . --show-column-numbers --show-error-codes --pretty 
+	$(PYRIGHT) ./graphiti_core 
 
 # Run tests
 test:

{graphiti_core-0.14.0 → graphiti_core-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.14.0
+Version: 0.15.0
 Summary: A temporal graph building library
 Project-URL: Homepage, https://help.getzep.com/graphiti/graphiti/overview
 Project-URL: Repository, https://github.com/getzep/graphiti
@@ -29,7 +29,7 @@ Requires-Dist: langchain-anthropic>=0.2.4; 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: mypy>=1.11.1; extra == 'dev'
+Requires-Dist: pyright>=1.1.380; 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'
@@ -153,7 +153,7 @@ Requirements:
 
 - Python 3.10 or higher
 - Neo4j 5.26 / FalkorDB 1.1.2 or higher (serves as the embeddings storage backend)
-- OpenAI API key (for LLM inference and embedding)
+- 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 and Gemini).
@@ -167,6 +167,12 @@ Optional:
 > [!TIP]
 > The simplest way to install Neo4j is via [Neo4j Desktop](https://neo4j.com/download/). 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:
+
+```bash
+docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
+
+```
 
 ```bash
 pip install graphiti-core
@@ -197,13 +203,13 @@ pip install graphiti-core[anthropic,groq,google-genai]
 ## Quick Start
 
 > [!IMPORTANT]
-> Graphiti uses 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:
 
-1. Connecting to a Neo4j database
+1. Connecting to a Neo4j or FalkorDB 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
@@ -247,7 +253,7 @@ as such this feature is off by default.
 
 ## Using Graphiti with Azure OpenAI
 
-Graphiti supports Azure OpenAI for both LLM inference and embeddings. To use Azure OpenAI, you'll need to configure both the LLM client and embedder with your Azure OpenAI credentials.
+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.
 
 ```python
 from openai import AsyncAzureOpenAI
@@ -256,19 +262,26 @@ 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
 
-# Azure OpenAI configuration
+# Azure OpenAI configuration - use separate endpoints for different services
 api_key = "<your-api-key>"
 api_version = "<your-api-version>"
-azure_endpoint = "<your-azure-endpoint>"
+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 Azure OpenAI client for LLM
-azure_openai_client = AsyncAzureOpenAI(
+embedding_client_azure = AsyncAzureOpenAI(
     api_key=api_key,
     api_version=api_version,
-    azure_endpoint=azure_endpoint
+    azure_endpoint=embedding_endpoint
 )
 
-# Create LLM Config with your Azure deployed model names
+# Create LLM Config with your Azure deployment names
 azure_llm_config = LLMConfig(
     small_model="gpt-4.1-nano",
     model="gpt-4.1-mini",
@@ -281,29 +294,30 @@ graphiti = Graphiti(
     "password",
     llm_client=OpenAIClient(
         llm_config=azure_llm_config,
-        client=azure_openai_client
+        client=llm_client_azure
     ),
     embedder=OpenAIEmbedder(
         config=OpenAIEmbedderConfig(
-            embedding_model="text-embedding-3-small"  # Use your Azure deployed embedding model name
+            embedding_model="text-embedding-3-small-deployment"  # Your Azure embedding deployment name
         ),
-        client=azure_openai_client
+        client=embedding_client_azure
     ),
-    # Optional: Configure the OpenAI cross encoder with Azure OpenAI
     cross_encoder=OpenAIRerankerClient(
-        llm_config=azure_llm_config,
-        client=azure_openai_client
+        llm_config=LLMConfig(
+            model=azure_llm_config.small_model  # Use small model for reranking
+        ),
+        client=llm_client_azure
     )
 )
 
 # Now you can use Graphiti with Azure OpenAI
 ```
 
-Make sure to replace the placeholder values with your actual Azure OpenAI credentials and specify the correct embedding model name that's deployed in your Azure OpenAI service.
+Make sure to replace the placeholder values with your actual Azure OpenAI credentials and deployment names that match your Azure OpenAI service configuration.
 
 ## Using Graphiti with Google Gemini
 
-Graphiti supports Google's Gemini models for both LLM inference and embeddings. To use Gemini, you'll need to configure both the LLM client and embedder 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:
 
@@ -319,6 +333,7 @@ pip install "graphiti-core[google-genai]"
 from graphiti_core import Graphiti
 from graphiti_core.llm_client.gemini_client import GeminiClient, LLMConfig
 from graphiti_core.embedder.gemini import GeminiEmbedder, GeminiEmbedderConfig
+from graphiti_core.cross_encoder.gemini_reranker_client import GeminiRerankerClient
 
 # Google API key configuration
 api_key = "<your-google-api-key>"
@@ -339,12 +354,20 @@ graphiti = Graphiti(
             api_key=api_key,
             embedding_model="embedding-001"
         )
+    ),
+    cross_encoder=GeminiRerankerClient(
+        config=LLMConfig(
+            api_key=api_key,
+            model="gemini-2.5-flash-lite-preview-06-17"
+        )
     )
 )
 
-# Now you can use Graphiti with Google Gemini
+# 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.
+
 ## 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_core-0.14.0 → graphiti_core-0.15.0}/README.md

@@ -106,7 +106,7 @@ Requirements:
 
 - Python 3.10 or higher
 - Neo4j 5.26 / FalkorDB 1.1.2 or higher (serves as the embeddings storage backend)
-- OpenAI API key (for LLM inference and embedding)
+- 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 and Gemini).
@@ -120,6 +120,12 @@ Optional:
 > [!TIP]
 > The simplest way to install Neo4j is via [Neo4j Desktop](https://neo4j.com/download/). 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:
+
+```bash
+docker run -p 6379:6379 -p 3000:3000 -it --rm falkordb/falkordb:latest
+
+```
 
 ```bash
 pip install graphiti-core
@@ -150,13 +156,13 @@ pip install graphiti-core[anthropic,groq,google-genai]
 ## Quick Start
 
 > [!IMPORTANT]
-> Graphiti uses 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:
 
-1. Connecting to a Neo4j database
+1. Connecting to a Neo4j or FalkorDB 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
@@ -200,7 +206,7 @@ as such this feature is off by default.
 
 ## Using Graphiti with Azure OpenAI
 
-Graphiti supports Azure OpenAI for both LLM inference and embeddings. To use Azure OpenAI, you'll need to configure both the LLM client and embedder with your Azure OpenAI credentials.
+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.
 
 ```python
 from openai import AsyncAzureOpenAI
@@ -209,19 +215,26 @@ 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
 
-# Azure OpenAI configuration
+# Azure OpenAI configuration - use separate endpoints for different services
 api_key = "<your-api-key>"
 api_version = "<your-api-version>"
-azure_endpoint = "<your-azure-endpoint>"
+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 Azure OpenAI client for LLM
-azure_openai_client = AsyncAzureOpenAI(
+embedding_client_azure = AsyncAzureOpenAI(
     api_key=api_key,
     api_version=api_version,
-    azure_endpoint=azure_endpoint
+    azure_endpoint=embedding_endpoint
 )
 
-# Create LLM Config with your Azure deployed model names
+# Create LLM Config with your Azure deployment names
 azure_llm_config = LLMConfig(
     small_model="gpt-4.1-nano",
     model="gpt-4.1-mini",
@@ -234,29 +247,30 @@ graphiti = Graphiti(
     "password",
     llm_client=OpenAIClient(
         llm_config=azure_llm_config,
-        client=azure_openai_client
+        client=llm_client_azure
     ),
     embedder=OpenAIEmbedder(
         config=OpenAIEmbedderConfig(
-            embedding_model="text-embedding-3-small"  # Use your Azure deployed embedding model name
+            embedding_model="text-embedding-3-small-deployment"  # Your Azure embedding deployment name
         ),
-        client=azure_openai_client
+        client=embedding_client_azure
     ),
-    # Optional: Configure the OpenAI cross encoder with Azure OpenAI
     cross_encoder=OpenAIRerankerClient(
-        llm_config=azure_llm_config,
-        client=azure_openai_client
+        llm_config=LLMConfig(
+            model=azure_llm_config.small_model  # Use small model for reranking
+        ),
+        client=llm_client_azure
     )
 )
 
 # Now you can use Graphiti with Azure OpenAI
 ```
 
-Make sure to replace the placeholder values with your actual Azure OpenAI credentials and specify the correct embedding model name that's deployed in your Azure OpenAI service.
+Make sure to replace the placeholder values with your actual Azure OpenAI credentials and deployment names that match your Azure OpenAI service configuration.
 
 ## Using Graphiti with Google Gemini
 
-Graphiti supports Google's Gemini models for both LLM inference and embeddings. To use Gemini, you'll need to configure both the LLM client and embedder 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:
 
@@ -272,6 +286,7 @@ pip install "graphiti-core[google-genai]"
 from graphiti_core import Graphiti
 from graphiti_core.llm_client.gemini_client import GeminiClient, LLMConfig
 from graphiti_core.embedder.gemini import GeminiEmbedder, GeminiEmbedderConfig
+from graphiti_core.cross_encoder.gemini_reranker_client import GeminiRerankerClient
 
 # Google API key configuration
 api_key = "<your-google-api-key>"
@@ -292,12 +307,20 @@ graphiti = Graphiti(
             api_key=api_key,
             embedding_model="embedding-001"
         )
+    ),
+    cross_encoder=GeminiRerankerClient(
+        config=LLMConfig(
+            api_key=api_key,
+            model="gemini-2.5-flash-lite-preview-06-17"
+        )
     )
 )
 
-# Now you can use Graphiti with Google Gemini
+# 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.
+
 ## 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_core-0.14.0 → graphiti_core-0.15.0}/examples/quickstart/quickstart_falkordb.py

@@ -46,14 +46,20 @@ logger = logging.getLogger(__name__)
 load_dotenv()
 
 # FalkorDB connection parameters
-# Make sure FalkorDB on premises is running, see https://docs.falkordb.com/
-falkor_uri = os.environ.get('FALKORDB_URI', 'falkor://localhost:6379')
-falkor_user = os.environ.get('FALKORDB_USER', 'falkor')
-falkor_password = os.environ.get('FALKORDB_PASSWORD', '')
-
-if not falkor_uri:
-    raise ValueError('FALKORDB_URI must be set')
-
+# Make sure FalkorDB (on-premises) is running — see https://docs.falkordb.com/
+# By default, FalkorDB does not require a username or password,
+# but you can set them via environment variables for added security.
+# 
+# If you're using FalkorDB Cloud, set the environment variables accordingly.
+# For on-premises use, you can leave them as None or set them to your preferred values.
+#
+# The default host and port are 'localhost' and '6379', respectively.
+# You can override these values in your environment variables or directly in the code.
+
+falkor_username = os.environ.get('FALKORDB_USERNAME', None)
+falkor_password = os.environ.get('FALKORDB_PASSWORD', None)
+falkor_host = os.environ.get('FALKORDB_HOST', 'localhost')
+falkor_port = os.environ.get('FALKORDB_PORT', '6379')
 
 async def main():
     #################################################
@@ -65,8 +71,8 @@ async def main():
     #################################################
 
     # Initialize Graphiti with FalkorDB connection
-    falkor_driver = FalkorDriver(uri=falkor_uri, user=falkor_user, password=falkor_password)
-    graphiti = Graphiti(uri=falkor_uri, graph_driver=falkor_driver)
+    falkor_driver = FalkorDriver(host=falkor_host, port=falkor_port, username=falkor_username, password=falkor_password)
+    graphiti = Graphiti(graph_driver=falkor_driver)
 
     try:
         # Initialize the graph database with graphiti's indices. This only needs to be done once.

{graphiti_core-0.14.0 → graphiti_core-0.15.0}/graphiti_core/cross_encoder/__init__.py

@@ -15,6 +15,7 @@ limitations under the License.
 """
 
 from .client import CrossEncoderClient
+from .gemini_reranker_client import GeminiRerankerClient
 from .openai_reranker_client import OpenAIRerankerClient
 
-__all__ = ['CrossEncoderClient', 'OpenAIRerankerClient']
+__all__ = ['CrossEncoderClient', 'GeminiRerankerClient', 'OpenAIRerankerClient']

graphiti_core-0.15.0/graphiti_core/cross_encoder/gemini_reranker_client.py

@@ -0,0 +1,146 @@
+"""
+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 logging
+import re
+
+from google import genai  # type: ignore
+from google.genai import types  # type: ignore
+
+from ..helpers import semaphore_gather
+from ..llm_client import LLMConfig, RateLimitError
+from .client import CrossEncoderClient
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL = 'gemini-2.5-flash-lite-preview-06-17'
+
+
+class GeminiRerankerClient(CrossEncoderClient):
+    def __init__(
+        self,
+        config: LLMConfig | None = None,
+        client: genai.Client | None = None,
+    ):
+        """
+        Initialize the GeminiRerankerClient with the provided configuration and client.
+
+        The Gemini Developer API does not yet support logprobs. Unlike the OpenAI reranker,
+        this reranker uses the Gemini API to perform direct relevance scoring of passages.
+        Each passage is scored individually on a 0-100 scale.
+
+        Args:
+            config (LLMConfig | None): The configuration for the LLM client, including API key, model, base URL, temperature, and max tokens.
+            client (genai.Client | None): An optional async client instance to use. If not provided, a new genai.Client is created.
+        """
+        if config is None:
+            config = LLMConfig()
+
+        self.config = config
+        if client is None:
+            self.client = genai.Client(api_key=config.api_key)
+        else:
+            self.client = client
+
+    async def rank(self, query: str, passages: list[str]) -> list[tuple[str, float]]:
+        """
+        Rank passages based on their relevance to the query using direct scoring.
+
+        Each passage is scored individually on a 0-100 scale, then normalized to [0,1].
+        """
+        if len(passages) <= 1:
+            return [(passage, 1.0) for passage in passages]
+
+        # Generate scoring prompts for each passage
+        scoring_prompts = []
+        for passage in passages:
+            prompt = f"""Rate how well this passage answers or relates to the query. Use a scale from 0 to 100.
+
+Query: {query}
+
+Passage: {passage}
+
+Provide only a number between 0 and 100 (no explanation, just the number):"""
+
+            scoring_prompts.append(
+                [
+                    types.Content(
+                        role='user',
+                        parts=[types.Part.from_text(text=prompt)],
+                    ),
+                ]
+            )
+
+        try:
+            # Execute all scoring requests concurrently - O(n) API calls
+            responses = await semaphore_gather(
+                *[
+                    self.client.aio.models.generate_content(
+                        model=self.config.model or DEFAULT_MODEL,
+                        contents=prompt_messages,  # type: ignore
+                        config=types.GenerateContentConfig(
+                            system_instruction='You are an expert at rating passage relevance. Respond with only a number from 0-100.',
+                            temperature=0.0,
+                            max_output_tokens=3,
+                        ),
+                    )
+                    for prompt_messages in scoring_prompts
+                ]
+            )
+
+            # Extract scores and create results
+            results = []
+            for passage, response in zip(passages, responses, strict=True):
+                try:
+                    if hasattr(response, 'text') and response.text:
+                        # Extract numeric score from response
+                        score_text = response.text.strip()
+                        # Handle cases where model might return non-numeric text
+                        score_match = re.search(r'\b(\d{1,3})\b', score_text)
+                        if score_match:
+                            score = float(score_match.group(1))
+                            # Normalize to [0, 1] range and clamp to valid range
+                            normalized_score = max(0.0, min(1.0, score / 100.0))
+                            results.append((passage, normalized_score))
+                        else:
+                            logger.warning(
+                                f'Could not extract numeric score from response: {score_text}'
+                            )
+                            results.append((passage, 0.0))
+                    else:
+                        logger.warning('Empty response from Gemini for passage scoring')
+                        results.append((passage, 0.0))
+                except (ValueError, AttributeError) as e:
+                    logger.warning(f'Error parsing score from Gemini response: {e}')
+                    results.append((passage, 0.0))
+
+            # Sort by score in descending order (highest relevance first)
+            results.sort(reverse=True, key=lambda x: x[1])
+            return results
+
+        except Exception as e:
+            # Check if it's a rate limit error based on Gemini API error codes
+            error_message = str(e).lower()
+            if (
+                'rate limit' in error_message
+                or 'quota' in error_message
+                or 'resource_exhausted' in error_message
+                or '429' in str(e)
+            ):
+                raise RateLimitError from e
+
+            logger.error(f'Error in generating LLM response: {e}')
+            raise

{graphiti_core-0.14.0 → graphiti_core-0.15.0}/graphiti_core/driver/__init__.py

@@ -14,4 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-__all__ = ['GraphDriver', 'Neo4jDriver', 'FalkorDriver']
+from falkordb import FalkorDB
+from neo4j import Neo4jDriver
+
+__all__ = ['Neo4jDriver', 'FalkorDB']