graphiti-core 0.8.7__py3-none-any.whl → 0.9.0__py3-none-any.whl

graphiti_core/embedder/__init__.py

@@ -1,4 +1,8 @@
 from .client import EmbedderClient
 from .openai import OpenAIEmbedder, OpenAIEmbedderConfig
 
-__all__ = ['EmbedderClient', 'OpenAIEmbedder', 'OpenAIEmbedderConfig']
+__all__ = [
+    'EmbedderClient',
+    'OpenAIEmbedder',
+    'OpenAIEmbedderConfig',
+]

graphiti_core/embedder/gemini.py

@@ -0,0 +1,68 @@
+"""
+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.
+"""
+
+from collections.abc import Iterable
+
+from google import genai  # type: ignore
+from google.genai import types  # type: ignore
+from pydantic import Field
+
+from .client import EmbedderClient, EmbedderConfig
+
+DEFAULT_EMBEDDING_MODEL = 'embedding-001'
+
+
+class GeminiEmbedderConfig(EmbedderConfig):
+    embedding_model: str = Field(default=DEFAULT_EMBEDDING_MODEL)
+    api_key: str | None = None
+
+
+class GeminiEmbedder(EmbedderClient):
+    """
+    Google Gemini Embedder Client
+    """
+
+    def __init__(self, config: GeminiEmbedderConfig | None = None):
+        if config is None:
+            config = GeminiEmbedderConfig()
+        self.config = config
+
+        # Configure the Gemini API
+        self.client = genai.Client(
+            api_key=config.api_key,
+        )
+
+    async def create(
+        self, input_data: str | list[str] | Iterable[int] | Iterable[Iterable[int]]
+    ) -> list[float]:
+        """
+        Create embeddings for the given input data using Google's Gemini embedding model.
+
+        Args:
+            input_data: The input data to create embeddings for. Can be a string, list of strings,
+                       or an iterable of integers or iterables of integers.
+
+        Returns:
+            A list of floats representing the embedding vector.
+        """
+        # Generate embeddings
+        result = await self.client.aio.models.embed_content(
+            model=self.config.embedding_model or DEFAULT_EMBEDDING_MODEL,
+            contents=[input_data],
+            config=types.EmbedContentConfig(output_dimensionality=self.config.embedding_dim),
+        )
+
+        return result.embeddings[0].values

graphiti_core/errors.py

@@ -65,3 +65,11 @@ class SearchRerankerError(GraphitiError):
     def __init__(self, text: str):
         self.message = text
         super().__init__(self.message)
+
+
+class EntityTypeValidationError(GraphitiError):
+    """Raised when an entity type uses protected attribute names."""
+
+    def __init__(self, entity_type: str, entity_type_attribute: str):
+        self.message = f'{entity_type_attribute} cannot be used as an attribute for {entity_type} as it is a protected attribute name.'
+        super().__init__(self.message)

graphiti_core/graphiti.py

@@ -71,11 +71,9 @@ from graphiti_core.utils.maintenance.graph_data_operations import (
     build_indices_and_constraints,
     retrieve_episodes,
 )
-from graphiti_core.utils.maintenance.node_operations import (
-    extract_nodes,
-    resolve_extracted_nodes,
-)
+from graphiti_core.utils.maintenance.node_operations import extract_nodes, resolve_extracted_nodes
 from graphiti_core.utils.maintenance.temporal_operations import get_edge_contradictions
+from graphiti_core.utils.ontology_utils.entity_types_utils import validate_entity_types
 
 logger = logging.getLogger(__name__)
 
@@ -319,6 +317,8 @@ class Graphiti:
             entity_edges: list[EntityEdge] = []
             now = utc_now()
 
+            validate_entity_types(entity_types)
+
             previous_episodes = (
                 await self.retrieve_episodes(
                     reference_time, last_n=RELEVANT_SCHEMA_LIMIT, group_ids=[group_id]

graphiti_core/llm_client/gemini_client.py

@@ -0,0 +1,186 @@
+"""
+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 json
+import logging
+import typing
+
+from google import genai  # type: ignore
+from google.genai import types  # type: ignore
+from pydantic import BaseModel
+
+from ..prompts.models import Message
+from .client import LLMClient
+from .config import DEFAULT_MAX_TOKENS, LLMConfig
+from .errors import RateLimitError
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL = 'gemini-2.0-flash'
+
+
+class GeminiClient(LLMClient):
+    """
+    GeminiClient is a client class for interacting with Google's Gemini language models.
+
+    This class extends the LLMClient and provides methods to initialize the client
+    and generate responses from the Gemini language model.
+
+    Attributes:
+        model (str): The model name to use for generating responses.
+        temperature (float): The temperature to use for generating responses.
+        max_tokens (int): The maximum number of tokens to generate in a response.
+
+    Methods:
+        __init__(config: LLMConfig | None = None, cache: bool = False):
+            Initializes the GeminiClient with the provided configuration and cache setting.
+
+        _generate_response(messages: list[Message]) -> dict[str, typing.Any]:
+            Generates a response from the language model based on the provided messages.
+    """
+
+    def __init__(
+        self,
+        config: LLMConfig | None = None,
+        cache: bool = False,
+        max_tokens: int = DEFAULT_MAX_TOKENS,
+    ):
+        """
+        Initialize the GeminiClient with the provided configuration and cache setting.
+
+        Args:
+            config (LLMConfig | None): The configuration for the LLM client, including API key, model, temperature, and max tokens.
+            cache (bool): Whether to use caching for responses. Defaults to False.
+        """
+        if config is None:
+            config = LLMConfig()
+
+        super().__init__(config, cache)
+
+        self.model = config.model
+        # Configure the Gemini API
+        self.client = genai.Client(
+            api_key=config.api_key,
+        )
+        self.max_tokens = max_tokens
+
+    async def _generate_response(
+        self,
+        messages: list[Message],
+        response_model: type[BaseModel] | None = None,
+        max_tokens: int = DEFAULT_MAX_TOKENS,
+    ) -> dict[str, typing.Any]:
+        """
+        Generate a response from the Gemini language model.
+
+        Args:
+            messages (list[Message]): A list of messages to send to the language model.
+            response_model (type[BaseModel] | None): An optional Pydantic model to parse the response into.
+            max_tokens (int): The maximum number of tokens to generate in the response.
+
+        Returns:
+            dict[str, typing.Any]: The response from the language model.
+
+        Raises:
+            RateLimitError: If the API rate limit is exceeded.
+            RefusalError: If the content is blocked by the model.
+            Exception: If there is an error generating the response.
+        """
+        try:
+            gemini_messages: list[types.Content] = []
+            # If a response model is provided, add schema for structured output
+            system_prompt = ''
+            if response_model is not None:
+                # Get the schema from the Pydantic model
+                pydantic_schema = response_model.model_json_schema()
+
+                # Create instruction to output in the desired JSON format
+                system_prompt += (
+                    f'Output ONLY valid JSON matching this schema: {json.dumps(pydantic_schema)}.\n'
+                    'Do not include any explanatory text before or after the JSON.\n\n'
+                )
+
+            # Add messages content
+            # First check for a system message
+            if messages and messages[0].role == 'system':
+                system_prompt = f'{messages[0].content}\n\n {system_prompt}'
+                messages = messages[1:]
+
+            # Add the rest of the messages
+            for m in messages:
+                m.content = self._clean_input(m.content)
+                gemini_messages.append(
+                    types.Content(role=m.role, parts=[types.Part.from_text(text=m.content)])
+                )
+
+            # Create generation config
+            generation_config = types.GenerateContentConfig(
+                temperature=self.temperature,
+                max_output_tokens=max_tokens or self.max_tokens,
+                response_mime_type='application/json' if response_model else None,
+                response_schema=response_model if response_model else None,
+                system_instruction=system_prompt,
+            )
+
+            # Generate content using the simple string approach
+            response = await self.client.aio.models.generate_content(
+                model=self.model or DEFAULT_MODEL,
+                contents=gemini_messages,
+                config=generation_config,
+            )
+
+            # If this was a structured output request, parse the response into the Pydantic model
+            if response_model is not None:
+                try:
+                    validated_model = response_model.model_validate(json.loads(response.text))
+
+                    # Return as a dictionary for API consistency
+                    return validated_model.model_dump()
+                except Exception as e:
+                    raise Exception(f'Failed to parse structured response: {e}') from e
+
+            # Otherwise, return the response text as a dictionary
+            return {'content': response.text}
+
+        except Exception as e:
+            # Check if it's a rate limit error
+            if 'rate limit' in str(e).lower() or 'quota' in str(e).lower():
+                raise RateLimitError from e
+            logger.error(f'Error in generating LLM response: {e}')
+            raise
+
+    async def generate_response(
+        self,
+        messages: list[Message],
+        response_model: type[BaseModel] | None = None,
+        max_tokens: int = DEFAULT_MAX_TOKENS,
+    ) -> dict[str, typing.Any]:
+        """
+        Generate a response from the Gemini language model.
+        This method overrides the parent class method to provide a direct implementation.
+
+        Args:
+            messages (list[Message]): A list of messages to send to the language model.
+            response_model (type[BaseModel] | None): An optional Pydantic model to parse the response into.
+            max_tokens (int): The maximum number of tokens to generate in the response.
+
+        Returns:
+            dict[str, typing.Any]: The response from the language model.
+        """
+        # Call the internal _generate_response method
+        return await self._generate_response(
+            messages=messages, response_model=response_model, max_tokens=max_tokens
+        )

graphiti_core/prompts/lib.py

@@ -16,63 +16,27 @@ limitations under the License.
 
 from typing import Any, Protocol, TypedDict
 
-from .dedupe_edges import (
-    Prompt as DedupeEdgesPrompt,
-)
-from .dedupe_edges import (
-    Versions as DedupeEdgesVersions,
-)
-from .dedupe_edges import (
-    versions as dedupe_edges_versions,
-)
-from .dedupe_nodes import (
-    Prompt as DedupeNodesPrompt,
-)
-from .dedupe_nodes import (
-    Versions as DedupeNodesVersions,
-)
-from .dedupe_nodes import (
-    versions as dedupe_nodes_versions,
-)
+from .dedupe_edges import Prompt as DedupeEdgesPrompt
+from .dedupe_edges import Versions as DedupeEdgesVersions
+from .dedupe_edges import versions as dedupe_edges_versions
+from .dedupe_nodes import Prompt as DedupeNodesPrompt
+from .dedupe_nodes import Versions as DedupeNodesVersions
+from .dedupe_nodes import versions as dedupe_nodes_versions
 from .eval import Prompt as EvalPrompt
 from .eval import Versions as EvalVersions
 from .eval import versions as eval_versions
-from .extract_edge_dates import (
-    Prompt as ExtractEdgeDatesPrompt,
-)
-from .extract_edge_dates import (
-    Versions as ExtractEdgeDatesVersions,
-)
-from .extract_edge_dates import (
-    versions as extract_edge_dates_versions,
-)
-from .extract_edges import (
-    Prompt as ExtractEdgesPrompt,
-)
-from .extract_edges import (
-    Versions as ExtractEdgesVersions,
-)
-from .extract_edges import (
-    versions as extract_edges_versions,
-)
-from .extract_nodes import (
-    Prompt as ExtractNodesPrompt,
-)
-from .extract_nodes import (
-    Versions as ExtractNodesVersions,
-)
-from .extract_nodes import (
-    versions as extract_nodes_versions,
-)
-from .invalidate_edges import (
-    Prompt as InvalidateEdgesPrompt,
-)
-from .invalidate_edges import (
-    Versions as InvalidateEdgesVersions,
-)
-from .invalidate_edges import (
-    versions as invalidate_edges_versions,
-)
+from .extract_edge_dates import Prompt as ExtractEdgeDatesPrompt
+from .extract_edge_dates import Versions as ExtractEdgeDatesVersions
+from .extract_edge_dates import versions as extract_edge_dates_versions
+from .extract_edges import Prompt as ExtractEdgesPrompt
+from .extract_edges import Versions as ExtractEdgesVersions
+from .extract_edges import versions as extract_edges_versions
+from .extract_nodes import Prompt as ExtractNodesPrompt
+from .extract_nodes import Versions as ExtractNodesVersions
+from .extract_nodes import versions as extract_nodes_versions
+from .invalidate_edges import Prompt as InvalidateEdgesPrompt
+from .invalidate_edges import Versions as InvalidateEdgesVersions
+from .invalidate_edges import versions as invalidate_edges_versions
 from .models import Message, PromptFunction
 from .prompt_helpers import DO_NOT_ESCAPE_UNICODE
 from .summarize_nodes import Prompt as SummarizeNodesPrompt

graphiti_core/utils/maintenance/__init__.py

@@ -1,8 +1,5 @@
 from .edge_operations import build_episodic_edges, extract_edges
-from .graph_data_operations import (
-    clear_data,
-    retrieve_episodes,
-)
+from .graph_data_operations import clear_data, retrieve_episodes
 from .node_operations import extract_nodes
 
 __all__ = [

graphiti_core/utils/maintenance/community_operations.py

@@ -9,11 +9,7 @@ from graphiti_core.edges import CommunityEdge
 from graphiti_core.embedder import EmbedderClient
 from graphiti_core.helpers import DEFAULT_DATABASE, semaphore_gather
 from graphiti_core.llm_client import LLMClient
-from graphiti_core.nodes import (
-    CommunityNode,
-    EntityNode,
-    get_community_node_from_record,
-)
+from graphiti_core.nodes import CommunityNode, EntityNode, get_community_node_from_record
 from graphiti_core.prompts import prompt_library
 from graphiti_core.prompts.summarize_nodes import Summary, SummaryDescription
 from graphiti_core.utils.datetime_utils import utc_now

graphiti_core/utils/maintenance/node_operations.py

@@ -26,11 +26,7 @@ from graphiti_core.llm_client import LLMClient
 from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode
 from graphiti_core.prompts import prompt_library
 from graphiti_core.prompts.dedupe_nodes import NodeDuplicate
-from graphiti_core.prompts.extract_nodes import (
-    EntityClassification,
-    ExtractedNodes,
-    MissedEntities,
-)
+from graphiti_core.prompts.extract_nodes import EntityClassification, ExtractedNodes, MissedEntities
 from graphiti_core.prompts.summarize_nodes import Summary
 from graphiti_core.utils.datetime_utils import utc_now
 

graphiti_core/utils/ontology_utils/entity_types_utils.py

@@ -0,0 +1,37 @@
+"""
+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.
+"""
+
+from pydantic import BaseModel
+
+from graphiti_core.errors import EntityTypeValidationError
+from graphiti_core.nodes import EntityNode
+
+
+def validate_entity_types(
+    entity_types: dict[str, BaseModel] | None,
+) -> bool:
+    if entity_types is None:
+        return True
+
+    entity_node_field_names = EntityNode.model_fields.keys()
+
+    for entity_type_name, entity_type_model in entity_types.items():
+        entity_type_field_names = entity_type_model.model_fields.keys()
+        for entity_type_field_name in entity_type_field_names:
+            if entity_type_field_name in entity_node_field_names:
+                raise EntityTypeValidationError(entity_type_name, entity_type_field_name)
+
+    return True

{graphiti_core-0.8.7.dist-info → graphiti_core-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.8.7
+Version: 0.9.0
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -11,7 +11,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: anthropic (>=0.49.0,<0.50.0)
+Provides-Extra: anthropic
+Provides-Extra: google-genai
+Provides-Extra: groq
 Requires-Dist: diskcache (>=5.6.3,<6.0.0)
 Requires-Dist: neo4j (>=5.23.0,<6.0.0)
 Requires-Dist: numpy (>=1.0.0)
@@ -58,8 +60,8 @@ Use Graphiti to:
 
 <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
-nodes (_”Kendra”_, _“Adidas shoes”_), and their relationship, or edge (_”loves”_). Knowledge Graphs have been explored
+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.
 
@@ -119,7 +121,7 @@ Requirements:
 
 Optional:
 
-- Anthropic or Groq API key (for alternative LLM providers)
+- Google Gemini, Anthropic, or Groq API key (for alternative LLM providers)
 
 > [!TIP]
 > The simplest way to install Neo4j is via [Neo4j Desktop](https://neo4j.com/download/). It provides a user-friendly
@@ -135,6 +137,22 @@ or
 poetry add graphiti-core
 ```
 
+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]
+```
+
 ## Quick Start
 
 > [!IMPORTANT]
@@ -142,67 +160,16 @@ poetry add graphiti-core
 > Support for Anthropic and Groq LLM inferences is available, too. Other LLM providers may be supported via OpenAI
 > compatible APIs.
 
-```python
-from graphiti_core import Graphiti
-from graphiti_core.nodes import EpisodeType
-from datetime import datetime, timezone
-
-# Initialize Graphiti as Your Memory Layer
-graphiti = Graphiti("bolt://localhost:7687", "neo4j", "password")
-
-# Initialize the graph database with Graphiti's indices. This only needs to be done once.
-graphiti.build_indices_and_constraints()
-
-# Add episodes
-episodes = [
-    "Kamala Harris is the Attorney General of California. She was previously "
-    "the district attorney for San Francisco.",
-    "As AG, Harris was in office from January 3, 2011 – January 3, 2017",
-]
-for i, episode in enumerate(episodes):
-    await graphiti.add_episode(
-        name=f"Freakonomics Radio {i}",
-        episode_body=episode,
-        source=EpisodeType.text,
-        source_description="podcast",
-        reference_time=datetime.now(timezone.utc)
-    )
+For a complete working example, see the [Quickstart Example](./examples/quickstart/README.md) in the examples directory. The quickstart demonstrates:
 
-# Search the graph for semantic memory retrieval
-# Execute a hybrid search combining semantic similarity and BM25 retrieval
-# Results are combined and reranked using Reciprocal Rank Fusion
-results = await graphiti.search('Who was the California Attorney General?')
-[
-    EntityEdge(
-│   uuid = '3133258f738e487383f07b04e15d4ac0',
-│   source_node_uuid = '2a85789b318d4e418050506879906e62',
-│   target_node_uuid = 'baf7781f445945989d6e4f927f881556',
-│   created_at = datetime.datetime(2024, 8, 26, 13, 13, 24, 861097),
-│   name = 'HELD_POSITION',
-# the fact reflects the updated state that Harris is
-# no longer the AG of California
-│   fact = 'Kamala Harris was the Attorney General of California',
-│   fact_embedding = [
-│   │   -0.009955154731869698,
-│       ...
-│   │   0.00784289836883545
-│],
-│   episodes = ['b43e98ad0a904088a76c67985caecc22'],
-│   expired_at = datetime.datetime(2024, 8, 26, 20, 18, 1, 53812),
-# These dates represent the date this edge was true.
-│   valid_at = datetime.datetime(2011, 1, 3, 0, 0, tzinfo= < UTC >),
-│   invalid_at = datetime.datetime(2017, 1, 3, 0, 0, tzinfo= < UTC >)
-)
-]
+1. Connecting to a Neo4j 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
 
-# Rerank search results based on graph distance
-# Provide a node UUID to prioritize results closer to that node in the graph.
-# Results are weighted by their proximity, with distant edges receiving lower scores.
-await graphiti.search('Who was the California Attorney General?', center_node_uuid)
-
-# Close the connection when chat state management is complete
-graphiti.close()
-```
+The example is fully documented with clear explanations of each functionality and includes a comprehensive README with setup instructions and next steps.
 
 ## Graph Service
 
@@ -285,6 +252,42 @@ graphiti = Graphiti(
 
 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.
 
+## 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.
+
+```python
+from graphiti_core import Graphiti
+from graphiti_core.llm_client.gemini_client import GeminiClient, LLMConfig
+from graphiti_core.embedder.gemini import GeminiEmbedder, GeminiEmbedderConfig
+
+# Google API key configuration
+api_key = "<your-google-api-key>"
+
+# Initialize Graphiti with Gemini clients
+graphiti = Graphiti(
+    "bolt://localhost:7687",
+    "neo4j",
+    "password",
+    llm_client=GeminiClient(
+        config=LLMConfig(
+            api_key=api_key,
+            model="gemini-2.0-flash"
+        )
+    ),
+    embedder=GeminiEmbedder(
+        config=GeminiEmbedderConfig(
+            api_key=api_key,
+            embedding_model="embedding-001"
+        )
+    )
+)
+
+# Now you can use Graphiti with Google Gemini
+```
+
+Make sure to replace the placeholder value with your actual Google API key. You can find more details in the example file at `examples/gemini_example.py`.
+
 ## Documentation
 
 - [Guides and API documentation](https://help.getzep.com/graphiti).

{graphiti_core-0.8.7.dist-info → graphiti_core-0.9.0.dist-info}/RECORD

@@ -4,18 +4,20 @@ graphiti_core/cross_encoder/bge_reranker_client.py,sha256=xgXZqB_qoaWQPjnmuf1ne3
 graphiti_core/cross_encoder/client.py,sha256=KLsbfWKOEaAV3adFe3XZlAeb-gje9_sVKCVZTaJP3ac,1441
 graphiti_core/cross_encoder/openai_reranker_client.py,sha256=e-QCftckZ7GLQgJ-ijljw6vzVa6H417cZ3cISB70M5g,4377
 graphiti_core/edges.py,sha256=pVaQUmxUH7ZwETdaTaoBsmmd5MMis1v7L-0tHBzUuHc,15657
-graphiti_core/embedder/__init__.py,sha256=eWd-0sPxflnYXLoWNT9sxwCIFun5JNO9Fk4E-ZXXf8Y,164
+graphiti_core/embedder/__init__.py,sha256=EL564ZuE-DZjcuKNUK_exMn_XHXm2LdO9fzdXePVKL4,179
 graphiti_core/embedder/client.py,sha256=HKIlpPLnzFT81jurPkry6z8F8nxfZVfejdcfxHVUSFU,995
+graphiti_core/embedder/gemini.py,sha256=nE0XH8wYVGcPSO7DaNQ7kdsQLFSoH4FQOu2HMQUy2ss,2200
 graphiti_core/embedder/openai.py,sha256=23BnPA10eiaa1HkxHKYSj75-0PymczPK2FNNIz8Txbc,1910
 graphiti_core/embedder/voyage.py,sha256=7kqrLG75J3Q6cdA2Nlx1JSYtpk2141ckdl3OtDDw0vU,1882
-graphiti_core/errors.py,sha256=cSOXXkydihNd6OHXzkwJvciRmR7EoFMq57AzUYVg0gc,2040
-graphiti_core/graphiti.py,sha256=FXkfgaib_JcVPHCBnJP__a4kJBlDs00ctvrtDCLHyoE,29588
+graphiti_core/errors.py,sha256=Nib1uQx2cO_VOizupmRjpFfmuRg-hFAVqTtZAuBehR8,2405
+graphiti_core/graphiti.py,sha256=hygm_1MPbi4jlAplAoLjrzC_45_0VKcIrZ3ll3Fi3bo,29712
 graphiti_core/helpers.py,sha256=7BQzUBFmoBDA2OIDdFtoN4W-vXOhPRIsF0uDb7PsNi0,2913
 graphiti_core/llm_client/__init__.py,sha256=PA80TSMeX-sUXITXEAxMDEt3gtfZgcJrGJUcyds1mSo,207
 graphiti_core/llm_client/anthropic_client.py,sha256=dTM8rKhk9TZAU4O-0jFMivOwJvWM-gHpp5gLmuJHiGQ,2723
 graphiti_core/llm_client/client.py,sha256=sqtdkySL_QnlZUyMhLvtbSPzGI1y8Ryq5a0IqOPZ2Ps,5252
 graphiti_core/llm_client/config.py,sha256=PxbjQWNjYQJKA7Pws28jJ0TsSZijOUds8GD9Yvu7xUE,2338
 graphiti_core/llm_client/errors.py,sha256=Vk0mj2SgNDg8E8p7m1UyUaerqLPNLCDKPVsMEnOSBdQ,1028
+graphiti_core/llm_client/gemini_client.py,sha256=uibmwppDgkEv60FsIhS-oakuafTUFgpu3qr5Kdcbhz4,7321
 graphiti_core/llm_client/groq_client.py,sha256=EesX0_iFOIvvIc3ql6Xa8EOm0dbGJ_o3VpqyDM83mKg,2498
 graphiti_core/llm_client/openai_client.py,sha256=_kLK35oSwhP20RQ9n20P8m5QxjmqqqmvU4UlOOhoLhw,6798
 graphiti_core/llm_client/openai_generic_client.py,sha256=PtMtOaophf2T2-W_O7KitsQIN2C2pl7Qzs-ToYADurM,6648
@@ -34,7 +36,7 @@ graphiti_core/prompts/extract_edge_dates.py,sha256=td2yx2wnX-nLioMa0mtla3WcRyO71
 graphiti_core/prompts/extract_edges.py,sha256=vyEdW7JAPOT_eLWUi6nRmxbvucyVoyoYX2SxXfknRUg,3467
 graphiti_core/prompts/extract_nodes.py,sha256=fSi07hGnlo7L5t9c0Q5zcBxDSki7QQKWhex9DFsVWW8,7048
 graphiti_core/prompts/invalidate_edges.py,sha256=DV2mEyIhhjc0hdKEMFLQMeG0FiUCkv_X0ctCliYjQ2c,3577
-graphiti_core/prompts/lib.py,sha256=oxhlpGEgV15VOLEZiwirxmIJBIdfzfiyL58iyzFDskE,4254
+graphiti_core/prompts/lib.py,sha256=DCyHePM4_q-CptTpEXGO_dBv9k7xDtclEaB1dGu7EcI,4092
 graphiti_core/prompts/models.py,sha256=cvx_Bv5RMFUD_5IUawYrbpOKLPHogai7_bm7YXrSz84,867
 graphiti_core/prompts/prompt_helpers.py,sha256=-9TABwIcIQUVHcNANx6wIZd-FT2DgYKyGTfx4IGYq2I,64
 graphiti_core/prompts/summarize_nodes.py,sha256=PeA1Taov5KBNNBKgrCPeF1tLg4_SMgT-Ilz2P6xbx-M,4051
@@ -48,14 +50,15 @@ graphiti_core/search/search_utils.py,sha256=Bywp7trqP_gEwqH8I-JHuj3Mljw9P2K6_Xoo
 graphiti_core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 graphiti_core/utils/bulk_utils.py,sha256=P4LKO46Yle4tBdNcQ3hDHcSQFaR8UBLfoL-z1M2Wua0,14690
 graphiti_core/utils/datetime_utils.py,sha256=Ti-2tnrDFRzBsbfblzsHybsM3jaDLP4-VT2t0VhpIzU,1357
-graphiti_core/utils/maintenance/__init__.py,sha256=TRY3wWWu5kn3Oahk_KKhltrWnh0NACw0FskjqF6OtlA,314
-graphiti_core/utils/maintenance/community_operations.py,sha256=gIw1M5HGgc2c3TXag5ygPPpAv5WsG-yoC8Lhmfr6FMs,10011
+graphiti_core/utils/maintenance/__init__.py,sha256=vW4H1KyapTl-OOz578uZABYcpND4wPx3Vt6aAPaXh78,301
+graphiti_core/utils/maintenance/community_operations.py,sha256=KV5TmpQoBLHDAE5BatUPdzjWYr-DG3ypfXKgbZUMSAA,9994
 graphiti_core/utils/maintenance/edge_operations.py,sha256=tNw56vN586JYZMgie6RLRTiHZ680-kWzDIxW8ucL6SU,12780
 graphiti_core/utils/maintenance/graph_data_operations.py,sha256=UJlIAawswJ7eO70oS5ueX-zjGHSaTWLsMbeYje67WTY,6895
-graphiti_core/utils/maintenance/node_operations.py,sha256=yo5Qt7i5WN3J3rB_9RJ0TJ1ZG1cGFWUKGrktMDwmXyE,15521
+graphiti_core/utils/maintenance/node_operations.py,sha256=gtc5EhEUqC57VPBMOLsRFsJITyM2Sxsn0fJ99JMBWio,15504
 graphiti_core/utils/maintenance/temporal_operations.py,sha256=RdNtubCyYhOVrvcOIq2WppHls1Q-BEjtsN8r38l-Rtc,3691
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core-0.8.7.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.8.7.dist-info/METADATA,sha256=XrGUFhTTqF1IyDIuugdQeUTPaxyXEk-FkuyhqbBQmMw,14351
-graphiti_core-0.8.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.8.7.dist-info/RECORD,,
+graphiti_core/utils/ontology_utils/entity_types_utils.py,sha256=QJX5cG0GSSNF_Mm_yrldr69wjVAbN_MxLhOSznz85Hk,1279
+graphiti_core-0.9.0.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.9.0.dist-info/METADATA,sha256=0jvS49ZVOwOiP-r5WmLVohmZaqs0ZnuwdbxQZzjTmr4,14064
+graphiti_core-0.9.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.9.0.dist-info/RECORD,,