graphiti-core 0.18.0__py3-none-any.whl → 0.18.2__py3-none-any.whl

graphiti_core/utils/maintenance/community_operations.py

@@ -34,7 +34,7 @@ async def get_community_clusters(
         group_id_values, _, _ = await driver.execute_query(
             """
         MATCH (n:Entity WHERE n.group_id IS NOT NULL)
-        RETURN 
+        RETURN
             collect(DISTINCT n.group_id) AS group_ids
         """,
         )
@@ -233,10 +233,10 @@ async def determine_entity_community(
         """
     MATCH (c:Community)-[:HAS_MEMBER]->(n:Entity {uuid: $entity_uuid})
     RETURN
-        c.uuid As uuid, 
+        c.uuid AS uuid,
         c.name AS name,
         c.group_id AS group_id,
-        c.created_at AS created_at, 
+        c.created_at AS created_at,
         c.summary AS summary
     """,
         entity_uuid=entity.uuid,
@@ -250,10 +250,10 @@ async def determine_entity_community(
         """
     MATCH (c:Community)-[:HAS_MEMBER]->(m:Entity)-[:RELATES_TO]-(n:Entity {uuid: $entity_uuid})
     RETURN
-        c.uuid As uuid, 
+        c.uuid AS uuid,
         c.name AS name,
         c.group_id AS group_id,
-        c.created_at AS created_at, 
+        c.created_at AS created_at,
         c.summary AS summary
     """,
         entity_uuid=entity.uuid,
@@ -286,11 +286,11 @@ async def determine_entity_community(
 
 async def update_community(
     driver: GraphDriver, llm_client: LLMClient, embedder: EmbedderClient, entity: EntityNode
-):
+) -> tuple[list[CommunityNode], list[CommunityEdge]]:
     community, is_new = await determine_entity_community(driver, entity)
 
     if community is None:
-        return
+        return [], []
 
     new_summary = await summarize_pair(llm_client, (entity.summary, community.summary))
     new_name = await generate_summary_description(llm_client, new_summary)
@@ -298,10 +298,14 @@ async def update_community(
     community.summary = new_summary
     community.name = new_name
 
+    community_edges = []
     if is_new:
         community_edge = (build_community_edges([entity], community, utc_now()))[0]
         await community_edge.save(driver)
+        community_edges.append(community_edge)
 
     await community.generate_name_embedding(embedder)
 
     await community.save(driver)
+
+    return [community], community_edges

graphiti_core/utils/maintenance/edge_operations.py

@@ -34,7 +34,7 @@ from graphiti_core.llm_client import LLMClient
 from graphiti_core.llm_client.config import ModelSize
 from graphiti_core.nodes import CommunityNode, EntityNode, EpisodicNode
 from graphiti_core.prompts import prompt_library
-from graphiti_core.prompts.dedupe_edges import EdgeDuplicate, UniqueFacts
+from graphiti_core.prompts.dedupe_edges import EdgeDuplicate
 from graphiti_core.prompts.extract_edges import ExtractedEdges, MissingFacts
 from graphiti_core.search.search_filters import SearchFilters
 from graphiti_core.search.search_utils import get_edge_invalidation_candidates, get_relevant_edges
@@ -114,7 +114,7 @@ async def extract_edges(
     previous_episodes: list[EpisodicNode],
     edge_type_map: dict[tuple[str, str], list[str]],
     group_id: str = '',
-    edge_types: dict[str, BaseModel] | None = None,
+    edge_types: dict[str, type[BaseModel]] | None = None,
 ) -> list[EntityEdge]:
     start = time()
 
@@ -161,9 +161,9 @@ async def extract_edges(
             response_model=ExtractedEdges,
             max_tokens=extract_edges_max_tokens,
         )
-        edges_data = llm_response.get('edges', [])
+        edges_data = ExtractedEdges(**llm_response).edges
 
-        context['extracted_facts'] = [edge_data.get('fact', '') for edge_data in edges_data]
+        context['extracted_facts'] = [edge_data.fact for edge_data in edges_data]
 
         reflexion_iterations += 1
         if reflexion_iterations < MAX_REFLEXION_ITERATIONS:
@@ -193,20 +193,20 @@ async def extract_edges(
     edges = []
     for edge_data in edges_data:
         # Validate Edge Date information
-        valid_at = edge_data.get('valid_at', None)
-        invalid_at = edge_data.get('invalid_at', None)
+        valid_at = edge_data.valid_at
+        invalid_at = edge_data.invalid_at
         valid_at_datetime = None
         invalid_at_datetime = None
 
-        source_node_idx = edge_data.get('source_entity_id', -1)
-        target_node_idx = edge_data.get('target_entity_id', -1)
+        source_node_idx = edge_data.source_entity_id
+        target_node_idx = edge_data.target_entity_id
         if not (-1 < source_node_idx < len(nodes) and -1 < target_node_idx < len(nodes)):
             logger.warning(
-                f'WARNING: source or target node not filled {edge_data.get("edge_name")}. source_node_uuid: {source_node_idx} and target_node_uuid: {target_node_idx} '
+                f'WARNING: source or target node not filled {edge_data.relation_type}. source_node_uuid: {source_node_idx} and target_node_uuid: {target_node_idx} '
             )
             continue
         source_node_uuid = nodes[source_node_idx].uuid
-        target_node_uuid = nodes[edge_data.get('target_entity_id')].uuid
+        target_node_uuid = nodes[edge_data.target_entity_id].uuid
 
         if valid_at:
             try:
@@ -226,9 +226,9 @@ async def extract_edges(
         edge = EntityEdge(
             source_node_uuid=source_node_uuid,
             target_node_uuid=target_node_uuid,
-            name=edge_data.get('relation_type', ''),
+            name=edge_data.relation_type,
             group_id=group_id,
-            fact=edge_data.get('fact', ''),
+            fact=edge_data.fact,
             episodes=[episode.uuid],
             created_at=utc_now(),
             valid_at=valid_at_datetime,
@@ -249,7 +249,7 @@ async def resolve_extracted_edges(
     extracted_edges: list[EntityEdge],
     episode: EpisodicNode,
     entities: list[EntityNode],
-    edge_types: dict[str, BaseModel],
+    edge_types: dict[str, type[BaseModel]],
     edge_type_map: dict[tuple[str, str], list[str]],
 ) -> tuple[list[EntityEdge], list[EntityEdge]]:
     driver = clients.driver
@@ -272,7 +272,7 @@ async def resolve_extracted_edges(
     uuid_entity_map: dict[str, EntityNode] = {entity.uuid: entity for entity in entities}
 
     # Determine which edge types are relevant for each edge
-    edge_types_lst: list[dict[str, BaseModel]] = []
+    edge_types_lst: list[dict[str, type[BaseModel]]] = []
     for extracted_edge in extracted_edges:
         source_node = uuid_entity_map.get(extracted_edge.source_node_uuid)
         target_node = uuid_entity_map.get(extracted_edge.target_node_uuid)
@@ -381,7 +381,7 @@ async def resolve_extracted_edge(
     related_edges: list[EntityEdge],
     existing_edges: list[EntityEdge],
     episode: EpisodicNode,
-    edge_types: dict[str, BaseModel] | None = None,
+    edge_types: dict[str, type[BaseModel]] | None = None,
 ) -> tuple[EntityEdge, list[EntityEdge], list[EntityEdge]]:
     if len(related_edges) == 0 and len(existing_edges) == 0:
         return extracted_edge, [], []
@@ -422,10 +422,10 @@ async def resolve_extracted_edge(
         response_model=EdgeDuplicate,
         model_size=ModelSize.small,
     )
+    response_object = EdgeDuplicate(**llm_response)
+    duplicate_facts = response_object.duplicate_facts
 
-    duplicate_fact_ids: list[int] = list(
-        filter(lambda i: 0 <= i < len(related_edges), llm_response.get('duplicate_facts', []))
-    )
+    duplicate_fact_ids: list[int] = [i for i in duplicate_facts if 0 <= i < len(related_edges)]
 
     resolved_edge = extracted_edge
     for duplicate_fact_id in duplicate_fact_ids:
@@ -435,11 +435,13 @@ async def resolve_extracted_edge(
     if duplicate_fact_ids and episode is not None:
         resolved_edge.episodes.append(episode.uuid)
 
-    contradicted_facts: list[int] = llm_response.get('contradicted_facts', [])
+    contradicted_facts: list[int] = response_object.contradicted_facts
 
-    invalidation_candidates: list[EntityEdge] = [existing_edges[i] for i in contradicted_facts]
+    invalidation_candidates: list[EntityEdge] = [
+        existing_edges[i] for i in contradicted_facts if 0 <= i < len(existing_edges)
+    ]
 
-    fact_type: str = str(llm_response.get('fact_type'))
+    fact_type: str = response_object.fact_type
     if fact_type.upper() != 'DEFAULT' and edge_types is not None:
         resolved_edge.name = fact_type
 
@@ -494,39 +496,6 @@ async def resolve_extracted_edge(
     return resolved_edge, invalidated_edges, duplicate_edges
 
 
-async def dedupe_edge_list(
-    llm_client: LLMClient,
-    edges: list[EntityEdge],
-) -> list[EntityEdge]:
-    start = time()
-
-    # Create edge map
-    edge_map = {}
-    for edge in edges:
-        edge_map[edge.uuid] = edge
-
-    # Prepare context for LLM
-    context = {'edges': [{'uuid': edge.uuid, 'fact': edge.fact} for edge in edges]}
-
-    llm_response = await llm_client.generate_response(
-        prompt_library.dedupe_edges.edge_list(context), response_model=UniqueFacts
-    )
-    unique_edges_data = llm_response.get('unique_facts', [])
-
-    end = time()
-    logger.debug(f'Extracted edge duplicates: {unique_edges_data} in {(end - start) * 1000} ms ')
-
-    # Get full edge data
-    unique_edges = []
-    for edge_data in unique_edges_data:
-        uuid = edge_data['uuid']
-        edge = edge_map[uuid]
-        edge.fact = edge_data['fact']
-        unique_edges.append(edge)
-
-    return unique_edges
-
-
 async def filter_existing_duplicate_of_edges(
     driver: GraphDriver, duplicates_node_tuples: list[tuple[EntityNode, EntityNode]]
 ) -> list[tuple[EntityNode, EntityNode]]:

graphiti_core/utils/maintenance/graph_data_operations.py

@@ -15,14 +15,15 @@ limitations under the License.
 """
 
 import logging
-from datetime import datetime, timezone
+from datetime import datetime
 
 from typing_extensions import LiteralString
 
 from graphiti_core.driver.driver import GraphDriver
 from graphiti_core.graph_queries import get_fulltext_indices, get_range_indices
-from graphiti_core.helpers import parse_db_date, semaphore_gather
-from graphiti_core.nodes import EpisodeType, EpisodicNode
+from graphiti_core.helpers import semaphore_gather
+from graphiti_core.models.nodes.node_db_queries import EPISODIC_NODE_RETURN
+from graphiti_core.nodes import EpisodeType, EpisodicNode, get_episodic_node_from_record
 
 EPISODE_WINDOW_LEN = 3
 
@@ -33,8 +34,8 @@ async def build_indices_and_constraints(driver: GraphDriver, delete_existing: bo
     if delete_existing:
         records, _, _ = await driver.execute_query(
             """
-        SHOW INDEXES YIELD name
-        """,
+            SHOW INDEXES YIELD name
+            """,
         )
         index_names = [record['name'] for record in records]
         await semaphore_gather(
@@ -108,19 +109,16 @@ async def retrieve_episodes(
 
     query: LiteralString = (
         """
-                                MATCH (e:Episodic) WHERE e.valid_at <= $reference_time
-                                """
+        MATCH (e:Episodic)
+        WHERE e.valid_at <= $reference_time
+        """
         + group_id_filter
         + source_filter
         + """
-        RETURN e.content AS content,
-            e.created_at AS created_at,
-            e.valid_at AS valid_at,
-            e.uuid AS uuid,
-            e.group_id AS group_id,
-            e.name AS name,
-            e.source_description AS source_description,
-            e.source AS source
+        RETURN
+        """
+        + EPISODIC_NODE_RETURN
+        + """
         ORDER BY e.valid_at DESC
         LIMIT $num_episodes
         """
@@ -133,18 +131,5 @@ async def retrieve_episodes(
         group_ids=group_ids,
     )
 
-    episodes = [
-        EpisodicNode(
-            content=record['content'],
-            created_at=parse_db_date(record['created_at'])
-            or datetime.min.replace(tzinfo=timezone.utc),
-            valid_at=parse_db_date(record['valid_at']) or datetime.min.replace(tzinfo=timezone.utc),
-            uuid=record['uuid'],
-            group_id=record['group_id'],
-            source=EpisodeType.from_str(record['source']),
-            name=record['name'],
-            source_description=record['source_description'],
-        )
-        for record in result
-    ]
+    episodes = [get_episodic_node_from_record(record) for record in result]
     return list(reversed(episodes))  # Return in chronological order

graphiti_core/utils/maintenance/node_operations.py

@@ -15,13 +15,10 @@ limitations under the License.
 """
 
 import logging
-from contextlib import suppress
 from time import time
 from typing import Any
-from uuid import uuid4
 
-import pydantic
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from graphiti_core.graphiti_types import GraphitiClients
 from graphiti_core.helpers import MAX_REFLEXION_ITERATIONS, semaphore_gather
@@ -29,8 +26,9 @@ from graphiti_core.llm_client import LLMClient
 from graphiti_core.llm_client.config import ModelSize
 from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode, create_entity_node_embeddings
 from graphiti_core.prompts import prompt_library
-from graphiti_core.prompts.dedupe_nodes import NodeResolutions
+from graphiti_core.prompts.dedupe_nodes import NodeDuplicate, NodeResolutions
 from graphiti_core.prompts.extract_nodes import (
+    EntitySummary,
     ExtractedEntities,
     ExtractedEntity,
     MissedEntities,
@@ -70,7 +68,7 @@ async def extract_nodes(
     clients: GraphitiClients,
     episode: EpisodicNode,
     previous_episodes: list[EpisodicNode],
-    entity_types: dict[str, BaseModel] | None = None,
+    entity_types: dict[str, type[BaseModel]] | None = None,
     excluded_entity_types: list[str] | None = None,
 ) -> list[EntityNode]:
     start = time()
@@ -125,10 +123,9 @@ async def extract_nodes(
                 prompt_library.extract_nodes.extract_json(context), response_model=ExtractedEntities
             )
 
-        extracted_entities: list[ExtractedEntity] = [
-            ExtractedEntity(**entity_types_context)
-            for entity_types_context in llm_response.get('extracted_entities', [])
-        ]
+        response_object = ExtractedEntities(**llm_response)
+
+        extracted_entities: list[ExtractedEntity] = response_object.extracted_entities
 
         reflexion_iterations += 1
         if reflexion_iterations < MAX_REFLEXION_ITERATIONS:
@@ -181,7 +178,7 @@ async def resolve_extracted_nodes(
     extracted_nodes: list[EntityNode],
     episode: EpisodicNode | None = None,
     previous_episodes: list[EpisodicNode] | None = None,
-    entity_types: dict[str, BaseModel] | None = None,
+    entity_types: dict[str, type[BaseModel]] | None = None,
     existing_nodes_override: list[EntityNode] | None = None,
 ) -> tuple[list[EntityNode], dict[str, str], list[tuple[EntityNode, EntityNode]]]:
     llm_client = clients.llm_client
@@ -224,7 +221,7 @@ async def resolve_extracted_nodes(
         ],
     )
 
-    entity_types_dict: dict[str, BaseModel] = entity_types if entity_types is not None else {}
+    entity_types_dict: dict[str, type[BaseModel]] = entity_types if entity_types is not None else {}
 
     # Prepare context for LLM
     extracted_nodes_context = [
@@ -254,14 +251,14 @@ async def resolve_extracted_nodes(
         response_model=NodeResolutions,
     )
 
-    node_resolutions: list = llm_response.get('entity_resolutions', [])
+    node_resolutions: list[NodeDuplicate] = NodeResolutions(**llm_response).entity_resolutions
 
     resolved_nodes: list[EntityNode] = []
     uuid_map: dict[str, str] = {}
     node_duplicates: list[tuple[EntityNode, EntityNode]] = []
     for resolution in node_resolutions:
-        resolution_id: int = resolution.get('id', -1)
-        duplicate_idx: int = resolution.get('duplicate_idx', -1)
+        resolution_id: int = resolution.id
+        duplicate_idx: int = resolution.duplicate_idx
 
         extracted_node = extracted_nodes[resolution_id]
 
@@ -276,7 +273,7 @@ async def resolve_extracted_nodes(
         resolved_nodes.append(resolved_node)
         uuid_map[extracted_node.uuid] = resolved_node.uuid
 
-        duplicates: list[int] = resolution.get('duplicates', [])
+        duplicates: list[int] = resolution.duplicates
         if duplicate_idx not in duplicates and duplicate_idx > -1:
             duplicates.append(duplicate_idx)
         for idx in duplicates:
@@ -298,7 +295,7 @@ async def extract_attributes_from_nodes(
     nodes: list[EntityNode],
     episode: EpisodicNode | None = None,
     previous_episodes: list[EpisodicNode] | None = None,
-    entity_types: dict[str, BaseModel] | None = None,
+    entity_types: dict[str, type[BaseModel]] | None = None,
 ) -> list[EntityNode]:
     llm_client = clients.llm_client
     embedder = clients.embedder
@@ -327,7 +324,7 @@ async def extract_attributes_from_node(
     node: EntityNode,
     episode: EpisodicNode | None = None,
     previous_episodes: list[EpisodicNode] | None = None,
-    entity_type: BaseModel | None = None,
+    entity_type: type[BaseModel] | None = None,
 ) -> EntityNode:
     node_context: dict[str, Any] = {
         'name': node.name,
@@ -336,25 +333,14 @@ async def extract_attributes_from_node(
         'attributes': node.attributes,
     }
 
-    attributes_definitions: dict[str, Any] = {
-        'summary': (
-            str,
-            Field(
-                description='Summary containing the important information about the entity. Under 250 words',
-            ),
-        )
+    attributes_context: dict[str, Any] = {
+        'node': node_context,
+        'episode_content': episode.content if episode is not None else '',
+        'previous_episodes': [ep.content for ep in previous_episodes]
+        if previous_episodes is not None
+        else [],
     }
 
-    if entity_type is not None:
-        for field_name, field_info in entity_type.model_fields.items():
-            attributes_definitions[field_name] = (
-                field_info.annotation,
-                Field(description=field_info.description),
-            )
-
-    unique_model_name = f'EntityAttributes_{uuid4().hex}'
-    entity_attributes_model = pydantic.create_model(unique_model_name, **attributes_definitions)
-
     summary_context: dict[str, Any] = {
         'node': node_context,
         'episode_content': episode.content if episode is not None else '',
@@ -363,63 +349,30 @@ async def extract_attributes_from_node(
         else [],
     }
 
-    llm_response = await llm_client.generate_response(
-        prompt_library.extract_nodes.extract_attributes(summary_context),
-        response_model=entity_attributes_model,
+    llm_response = (
+        (
+            await llm_client.generate_response(
+                prompt_library.extract_nodes.extract_attributes(attributes_context),
+                response_model=entity_type,
+                model_size=ModelSize.small,
+            )
+        )
+        if entity_type is not None
+        else {}
+    )
+
+    summary_response = await llm_client.generate_response(
+        prompt_library.extract_nodes.extract_summary(summary_context),
+        response_model=EntitySummary,
         model_size=ModelSize.small,
     )
 
-    node.summary = llm_response.get('summary', node.summary)
-    node_attributes = {key: value for key, value in llm_response.items()}
+    if entity_type is not None:
+        entity_type(**llm_response)
 
-    with suppress(KeyError):
-        del node_attributes['summary']
+    node.summary = summary_response.get('summary', '')
+    node_attributes = {key: value for key, value in llm_response.items()}
 
     node.attributes.update(node_attributes)
 
     return node
-
-
-async def dedupe_node_list(
-    llm_client: LLMClient,
-    nodes: list[EntityNode],
-) -> tuple[list[EntityNode], dict[str, str]]:
-    start = time()
-
-    # build node map
-    node_map = {}
-    for node in nodes:
-        node_map[node.uuid] = node
-
-    # Prepare context for LLM
-    nodes_context = [{'uuid': node.uuid, 'name': node.name, **node.attributes} for node in nodes]
-
-    context = {
-        'nodes': nodes_context,
-    }
-
-    llm_response = await llm_client.generate_response(
-        prompt_library.dedupe_nodes.node_list(context)
-    )
-
-    nodes_data = llm_response.get('nodes', [])
-
-    end = time()
-    logger.debug(f'Deduplicated nodes: {nodes_data} in {(end - start) * 1000} ms')
-
-    # Get full node data
-    unique_nodes = []
-    uuid_map: dict[str, str] = {}
-    for node_data in nodes_data:
-        node_instance: EntityNode | None = node_map.get(node_data['uuids'][0])
-        if node_instance is None:
-            logger.warning(f'Node {node_data["uuids"][0]} not found in node map')
-            continue
-        node_instance.summary = node_data['summary']
-        unique_nodes.append(node_instance)
-
-        for uuid in node_data['uuids'][1:]:
-            uuid_value = node_map[node_data['uuids'][0]].uuid
-            uuid_map[uuid] = uuid_value
-
-    return unique_nodes, uuid_map

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-0.18.0.dist-info → graphiti_core-0.18.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.18.0
+Version: 0.18.2
 Summary: A temporal graph building library
 Project-URL: Homepage, https://help.getzep.com/graphiti/graphiti/overview
 Project-URL: Repository, https://github.com/getzep/graphiti
@@ -106,9 +106,9 @@ nodes ("Kendra", "Adidas shoes"), and their relationship, or edge ("loves"). Kno
 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/).
@@ -219,6 +219,14 @@ pip install graphiti-core[anthropic,groq,google-genai]
 pip install graphiti-core[falkordb,anthropic,google-genai]
 ```
 
+## 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_core-0.18.0.dist-info → graphiti_core-0.18.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
 graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
-graphiti_core/edges.py,sha256=-SSP6rhk8Dl8LwUZ08GHymJTT5pNDtzb3BV-6z1fBYY,16030
+graphiti_core/edges.py,sha256=KpgCzHlNgEcTTbUE62RAXKKi2YbG_fIwilE_W1TARYI,14864
 graphiti_core/errors.py,sha256=cH_v9TPgEPeQE6GFOHIg5TvejpUCBddGarMY2Whxbwc,2707
-graphiti_core/graph_queries.py,sha256=KfWDp8xDnPa9bcHskw8NeMpeeHBtZWBCosVdu1Iwv34,7076
-graphiti_core/graphiti.py,sha256=fNBDDOtChAG9U0t4nFD1Il882mMlr2TedeTzMuvNfnM,39568
+graphiti_core/graph_queries.py,sha256=mkSE8JbH4dTysT1quxR_QqCU-P_MUogbj48-BVxAcY4,5316
+graphiti_core/graphiti.py,sha256=u9sDQ4iXxDjbI_G9FSs-xXi2xuNMZo-FvNW_sEBptYo,40129
 graphiti_core/graphiti_types.py,sha256=rL-9bvnLobunJfXU4hkD6mAj14pofKp_wq8QsFDZwDU,1035
-graphiti_core/helpers.py,sha256=YoMAEhe_aMPz_Cd_t1dnIffNwDpenINJu4URePglt2s,5247
-graphiti_core/nodes.py,sha256=AcqHvhNWyapQwBSuziMvPJ-HnOr4Pv1-OiYsEodJcAA,18613
+graphiti_core/helpers.py,sha256=oKcOQE_bvsdhBpPr1Ia2tylBq1svj3X1oBMSR7qdo00,5331
+graphiti_core/nodes.py,sha256=-RnBtqLx1ukbQQqjZval9fDAWIJUTWaKwSMPLJ9AzM4,17866
 graphiti_core/py.typed,sha256=vlmmzQOt7bmeQl9L3XJP4W6Ry0iiELepnOrinKz5KQg,79
 graphiti_core/cross_encoder/__init__.py,sha256=hry59vz21x-AtGZ0MJ7ugw0HTwJkXiddpp_Yqnwsen0,723
 graphiti_core/cross_encoder/bge_reranker_client.py,sha256=y3TfFxZh0Yvj6HUShmfUm6MC7OPXwWUlv1Qe5HF3S3I,1797
@@ -13,9 +13,9 @@ graphiti_core/cross_encoder/client.py,sha256=KLsbfWKOEaAV3adFe3XZlAeb-gje9_sVKCV
 graphiti_core/cross_encoder/gemini_reranker_client.py,sha256=hmITG5YIib52nrKvINwRi4xTfAO1U4jCCaEVIwImHw0,6208
 graphiti_core/cross_encoder/openai_reranker_client.py,sha256=hoaGyu9nCNMJyP8si0Bha5Q9CFszfiHQmLgE9IsX7sY,4653
 graphiti_core/driver/__init__.py,sha256=kCWimqQU19airu5gKwCmZtZuXkDfaQfKSUhMDoL-rTA,626
-graphiti_core/driver/driver.py,sha256=VndkriaEdTnafhVs1ks11klXQERqylV0X76Yc4WsAfU,1905
-graphiti_core/driver/falkordb_driver.py,sha256=lol0ahK_3pBhoBNQhchouWEM2YuJpNSpsycbWQfMwx8,6573
-graphiti_core/driver/neo4j_driver.py,sha256=0MCAWAPay0LdcqrFSkY91GooUtrn1yX1CTKuE4Lj_Po,2255
+graphiti_core/driver/driver.py,sha256=XFJzkyZKiqhwwW6G9enB2ouWxNB53PU58nhSCW_LOIc,2331
+graphiti_core/driver/falkordb_driver.py,sha256=YLNuPvPBM7Pgr3Pv9gDuTVDGeDgHvEg8xD58uDYNweM,6766
+graphiti_core/driver/neo4j_driver.py,sha256=LxYPJc8vUUBplVKLW9n2mofNzndFV4S2yHdAiT5gUJI,2323
 graphiti_core/embedder/__init__.py,sha256=EL564ZuE-DZjcuKNUK_exMn_XHXm2LdO9fzdXePVKL4,179
 graphiti_core/embedder/azure_openai.py,sha256=OyomPwC1fIsddI-3n6g00kQFdQznZorBhHwkQKCLUok,2384
 graphiti_core/embedder/client.py,sha256=qEpSHceL_Gc4QQPJWIOnuNLemNuR_TYA4r28t2Vldbg,1115
@@ -36,16 +36,16 @@ graphiti_core/llm_client/openai_generic_client.py,sha256=WElMnPqdb1CxzYH4p2-m_9r
 graphiti_core/llm_client/utils.py,sha256=zKpxXEbKa369m4W7RDEf-m56kH46V1Mx3RowcWZEWWs,1000
 graphiti_core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 graphiti_core/models/edges/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/models/edges/edge_db_queries.py,sha256=YyGc0UT4eeOHQrYuXfAGIwxiX4xCc4YHrz9c2bVT7Lw,2324
+graphiti_core/models/edges/edge_db_queries.py,sha256=OBFqT9m6JDmGwpqe5TkcaCT2KxUGdW8h4yIsoacB5Mw,4661
 graphiti_core/models/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/models/nodes/node_db_queries.py,sha256=AQgRGVO-GgFWfLq1G6k8s86WItwpXruy3Mj4DBli-vM,2145
+graphiti_core/models/nodes/node_db_queries.py,sha256=ADPkZzS4tq5i-8zvkocoiuOiDi64d5F2ChEY_JwLOwQ,4378
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
 graphiti_core/prompts/dedupe_edges.py,sha256=WlW18HjhuKOXjxSbvrmwk0yH0tqA4t89ntG7LOTq_k4,5724
-graphiti_core/prompts/dedupe_nodes.py,sha256=GBHSFfkumiQQU8qDnO-kUoSefzDNSzYUpzUl6hPcakc,7740
+graphiti_core/prompts/dedupe_nodes.py,sha256=T0LVocO5nfP4mOYpIcNMztLHjnRcE6zpYgT6OUCoujw,7783
 graphiti_core/prompts/eval.py,sha256=gnBQTmwsCl3Qvwpcm7aieVszzo6y1sMCUT8jQiKTvvE,5317
 graphiti_core/prompts/extract_edge_dates.py,sha256=3Drs3CmvP0gJN5BidWSxrNvLet3HPoTybU3BUIAoc0Y,4218
-graphiti_core/prompts/extract_edges.py,sha256=4C9sOqdoZCqVZbmkhNCPeNx3R80rzT8eXndySjVRsHc,6622
-graphiti_core/prompts/extract_nodes.py,sha256=bJ3Inp4tMDsXgTPHKOyAtasVHEeLjbY7wfV3LwdvCsc,9747
+graphiti_core/prompts/extract_edges.py,sha256=MY-GhBNxPhO07v6TZPE_dby-VevDHHmVXpyYm-khg04,6622
+graphiti_core/prompts/extract_nodes.py,sha256=v7DMOmscAY2j2eiZr5cNmz_kT3UmjvKpT-OOwmhzUik,11020
 graphiti_core/prompts/invalidate_edges.py,sha256=yfpcs_pyctnoM77ULPZXEtKW0oHr1MeLsJzC5yrE-o4,3547
 graphiti_core/prompts/lib.py,sha256=DCyHePM4_q-CptTpEXGO_dBv9k7xDtclEaB1dGu7EcI,4092
 graphiti_core/prompts/models.py,sha256=NgxdbPHJpBEcpbXovKyScgpBc73Q-GIW-CBDlBtDjto,894
@@ -55,23 +55,23 @@ graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 graphiti_core/search/search.py,sha256=u-kTmSu3VlRHYlQhuYsbwDQ-AKKCp3BZ9JZNRv3ttVY,16720
 graphiti_core/search/search_config.py,sha256=v_rUHsu1yo5OuPfEm21lSuXexQs-o8qYwSSemW2QWhU,4165
 graphiti_core/search/search_config_recipes.py,sha256=4GquRphHhJlpXQhAZOySYnCzBWYoTwxlJj44eTOavZQ,7443
-graphiti_core/search/search_filters.py,sha256=cxiFkqB-r7QzVMh8nmujECLhzgsbeCpBHUQqDXnCQ3A,6383
+graphiti_core/search/search_filters.py,sha256=Xc8hNVqbPrCd8-Zql0rtf1ztjzC_0FgAqGj9vxgNwLM,6383
 graphiti_core/search/search_helpers.py,sha256=G5Ceaq5Pfgx0Weelqgeylp_pUHwiBnINaUYsDbURJbE,2636
-graphiti_core/search/search_utils.py,sha256=nz1Z2HrOt3ay64x_HXaFBPyBNMecyoIqzhc-7Ac0rws,34894
+graphiti_core/search/search_utils.py,sha256=D6J93x0ol4Kd_zVo-dX0MRG0BZjLvG-mCdi-vjjDTfE,32104
 graphiti_core/telemetry/__init__.py,sha256=5kALLDlU9bb2v19CdN7qVANsJWyfnL9E60J6FFgzm3o,226
 graphiti_core/telemetry/telemetry.py,sha256=47LrzOVBCcZxsYPsnSxWFiztHoxYKKxPwyRX0hnbDGc,3230
 graphiti_core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/utils/bulk_utils.py,sha256=jMpGEyiAd1uCllGzxEpsV8pwLOq0DbWK4Ph_QhdAsz4,15069
+graphiti_core/utils/bulk_utils.py,sha256=noYG8MQZK-8_YEVOGT0ci7VUB31Mrx29OHdaGOZXQMA,15049
 graphiti_core/utils/datetime_utils.py,sha256=Ti-2tnrDFRzBsbfblzsHybsM3jaDLP4-VT2t0VhpIzU,1357
 graphiti_core/utils/maintenance/__init__.py,sha256=vW4H1KyapTl-OOz578uZABYcpND4wPx3Vt6aAPaXh78,301
-graphiti_core/utils/maintenance/community_operations.py,sha256=ROKo9_5Jj3RqfTrD9wJjlDRSF6iUyXUY4czkc9RGVdw,9905
-graphiti_core/utils/maintenance/edge_operations.py,sha256=gVSNC-GWZ0Ud-ONfhUDlHlIb2z1mI6SYtZPptPXSTeQ,19471
-graphiti_core/utils/maintenance/graph_data_operations.py,sha256=4czJPiHZpaqhKYYcXonErYQV2tV86ai2H-cg6dK8u60,5192
-graphiti_core/utils/maintenance/node_operations.py,sha256=ZnopNRTNdBjBotQ2uQiI7EYtVhs__b8C9QfRvNiMG6Q,14580
+graphiti_core/utils/maintenance/community_operations.py,sha256=jAY_WdmvjxJG4MxAsXzTaETTjvX6G8YuKVq9FzvQQuc,10071
+graphiti_core/utils/maintenance/edge_operations.py,sha256=YRyjWXy9MT3YlmVB9OHUN8R2idYyf-jteq-5tLy4LOs,18574
+graphiti_core/utils/maintenance/graph_data_operations.py,sha256=joNZxL_OIFdXHBGkwtB57ar7nGmbq4Z8ItgqFWL45kw,4530
+graphiti_core/utils/maintenance/node_operations.py,sha256=mNqonVTNLtw0gK7tflhoCFQ9dNrDfJq94cv3_aEwSiI,13129
 graphiti_core/utils/maintenance/temporal_operations.py,sha256=mJkw9xLB4W2BsLfC5POr0r-PHWL9SIfNj_l_xu0B5ug,3410
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/utils/ontology_utils/entity_types_utils.py,sha256=QJX5cG0GSSNF_Mm_yrldr69wjVAbN_MxLhOSznz85Hk,1279
-graphiti_core-0.18.0.dist-info/METADATA,sha256=dexXmf1OnLDXtkztEYhSDUufywjqUA5mOLWkLB9wqPc,23812
-graphiti_core-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-graphiti_core-0.18.0.dist-info/licenses/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.18.0.dist-info/RECORD,,
+graphiti_core/utils/ontology_utils/entity_types_utils.py,sha256=4eVgxLWY6Q8k9cRJ5pW59IYF--U4nXZsZIGOVb_yHfQ,1285
+graphiti_core-0.18.2.dist-info/METADATA,sha256=TLIGRsoZ0nYbqBSvd_qWUkd2sAXBLTyJ4hV4j-S97cY,24621
+graphiti_core-0.18.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+graphiti_core-0.18.2.dist-info/licenses/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.18.2.dist-info/RECORD,,