graphiti-core 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

graphiti_core/utils/maintenance/node_operations.py

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+import asyncio
 import logging
 from datetime import datetime
 from time import time
@@ -27,7 +28,7 @@ logger = logging.getLogger(__name__)
 
 
 async def extract_message_nodes(
-    llm_client: LLMClient, episode: EpisodicNode, previous_episodes: list[EpisodicNode]
+        llm_client: LLMClient, episode: EpisodicNode, previous_episodes: list[EpisodicNode]
 ) -> list[dict[str, Any]]:
     # Prepare context for LLM
     context = {
@@ -48,8 +49,8 @@ async def extract_message_nodes(
 
 
 async def extract_json_nodes(
-    llm_client: LLMClient,
-    episode: EpisodicNode,
+        llm_client: LLMClient,
+        episode: EpisodicNode,
 ) -> list[dict[str, Any]]:
     # Prepare context for LLM
     context = {
@@ -66,9 +67,9 @@ async def extract_json_nodes(
 
 
 async def extract_nodes(
-    llm_client: LLMClient,
-    episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
+        llm_client: LLMClient,
+        episode: EpisodicNode,
+        previous_episodes: list[EpisodicNode],
 ) -> list[EntityNode]:
     start = time()
     extracted_node_data: list[dict[str, Any]] = []
@@ -95,29 +96,24 @@ async def extract_nodes(
 
 
 async def dedupe_extracted_nodes(
-    llm_client: LLMClient,
-    extracted_nodes: list[EntityNode],
-    existing_nodes: list[EntityNode],
-) -> tuple[list[EntityNode], dict[str, str], list[EntityNode]]:
+        llm_client: LLMClient,
+        extracted_nodes: list[EntityNode],
+        existing_nodes: list[EntityNode],
+) -> tuple[list[EntityNode], dict[str, str]]:
     start = time()
 
     # build existing node map
     node_map: dict[str, EntityNode] = {}
     for node in existing_nodes:
-        node_map[node.name] = node
-
-    # Temp hack
-    new_nodes_map: dict[str, EntityNode] = {}
-    for node in extracted_nodes:
-        new_nodes_map[node.name] = node
+        node_map[node.uuid] = node
 
     # Prepare context for LLM
     existing_nodes_context = [
-        {'name': node.name, 'summary': node.summary} for node in existing_nodes
+        {'uuid': node.uuid, 'name': node.name, 'summary': node.summary} for node in existing_nodes
     ]
 
     extracted_nodes_context = [
-        {'name': node.name, 'summary': node.summary} for node in extracted_nodes
+        {'uuid': node.uuid, 'name': node.name, 'summary': node.summary} for node in extracted_nodes
     ]
 
     context = {
@@ -134,42 +130,104 @@ async def dedupe_extracted_nodes(
 
     uuid_map: dict[str, str] = {}
     for duplicate in duplicate_data:
-        uuid = new_nodes_map[duplicate['name']].uuid
-        uuid_value = node_map[duplicate['duplicate_of']].uuid
-        uuid_map[uuid] = uuid_value
+        uuid_value = duplicate['duplicate_of']
+        uuid_map[duplicate['uuid']] = uuid_value
 
     nodes: list[EntityNode] = []
-    brand_new_nodes: list[EntityNode] = []
     for node in extracted_nodes:
         if node.uuid in uuid_map:
             existing_uuid = uuid_map[node.uuid]
-            # TODO(Preston): This is a bit of a hack I implemented because we were getting incorrect uuids for existing nodes,
-            # can you revisit the node dedup function and make it somewhat cleaner and add more comments/tests please?
-            # find an existing node by the uuid from the nodes_map (each key is name, so we need to iterate by uuid value)
-            existing_node = next((v for k, v in node_map.items() if v.uuid == existing_uuid), None)
-            if existing_node:
-                nodes.append(existing_node)
+            existing_node = node_map[existing_uuid]
+            nodes.append(existing_node)
+        else:
+            nodes.append(node)
+
+    return nodes, uuid_map
+
+
+async def resolve_extracted_nodes(
+        llm_client: LLMClient,
+        extracted_nodes: list[EntityNode],
+        existing_nodes_lists: list[list[EntityNode]],
+) -> tuple[list[EntityNode], dict[str, str]]:
+    uuid_map: dict[str, str] = {}
+    resolved_nodes: list[EntityNode] = []
+    results: list[tuple[EntityNode, dict[str, str]]] = list(
+        await asyncio.gather(
+            *[
+                resolve_extracted_node(llm_client, extracted_node, existing_nodes)
+                for extracted_node, existing_nodes in zip(extracted_nodes, existing_nodes_lists)
+            ]
+        )
+    )
+
+    for result in results:
+        uuid_map.update(result[1])
+        resolved_nodes.append(result[0])
+
+    return resolved_nodes, uuid_map
+
+
+async def resolve_extracted_node(
+        llm_client: LLMClient, extracted_node: EntityNode, existing_nodes: list[EntityNode]
+) -> tuple[EntityNode, dict[str, str]]:
+    start = time()
+
+    # Prepare context for LLM
+    existing_nodes_context = [
+        {'uuid': node.uuid, 'name': node.name, 'summary': node.summary} for node in existing_nodes
+    ]
+
+    extracted_node_context = {
+        'uuid': extracted_node.uuid,
+        'name': extracted_node.name,
+        'summary': extracted_node.summary,
+    }
+
+    context = {
+        'existing_nodes': existing_nodes_context,
+        'extracted_nodes': extracted_node_context,
+    }
+
+    llm_response = await llm_client.generate_response(prompt_library.dedupe_nodes.v3(context))
+
+    is_duplicate: bool = llm_response.get('is_duplicate', False)
+    uuid: str | None = llm_response.get('uuid', None)
+    summary = llm_response.get('summary', '')
+
+    node = extracted_node
+    uuid_map: dict[str, str] = {}
+    if is_duplicate:
+        for existing_node in existing_nodes:
+            if existing_node.uuid != uuid:
+                continue
+            node = existing_node
+            node.summary = summary
+            uuid_map[extracted_node.uuid] = existing_node.uuid
 
-            continue
-        brand_new_nodes.append(node)
-        nodes.append(node)
+    end = time()
+    logger.info(
+        f'Resolved node: {extracted_node.name} is {node.name}, in {(end - start) * 1000} ms'
+    )
 
-    return nodes, uuid_map, brand_new_nodes
+    return node, uuid_map
 
 
 async def dedupe_node_list(
-    llm_client: LLMClient,
-    nodes: list[EntityNode],
+        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.name] = node
+        node_map[node.uuid] = node
 
     # Prepare context for LLM
-    nodes_context = [{'name': node.name, 'summary': node.summary} for node in nodes]
+    nodes_context = [
+        {'uuid': node.uuid, 'name': node.name, 'summary': node.summary} for node in nodes
+    ]
 
     context = {
         'nodes': nodes_context,
@@ -188,12 +246,12 @@ async def dedupe_node_list(
     unique_nodes = []
     uuid_map: dict[str, str] = {}
     for node_data in nodes_data:
-        node = node_map[node_data['names'][0]]
+        node = node_map[node_data['uuids'][0]]
+        node.summary = node_data['summary']
         unique_nodes.append(node)
 
-        for name in node_data['names'][1:]:
-            uuid = node_map[name].uuid
-            uuid_value = node_map[node_data['names'][0]].uuid
+        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/maintenance/temporal_operations.py

@@ -147,16 +147,15 @@ def process_edge_invalidation_llm_response(
 async def extract_edge_dates(
     llm_client: LLMClient,
     edge: EntityEdge,
-    reference_time: datetime,
     current_episode: EpisodicNode,
     previous_episodes: List[EpisodicNode],
-) -> tuple[datetime | None, datetime | None, str]:
+) -> tuple[datetime | None, datetime | None]:
     context = {
         'edge_name': edge.name,
         'edge_fact': edge.fact,
         'current_episode': current_episode.content,
         'previous_episodes': [ep.content for ep in previous_episodes],
-        'reference_timestamp': reference_time.isoformat(),
+        'reference_timestamp': current_episode.valid_at.isoformat(),
     }
     llm_response = await llm_client.generate_response(prompt_library.extract_edge_dates.v1(context))
 
@@ -181,4 +180,4 @@ async def extract_edge_dates(
 
     logger.info(f'Edge date extraction explanation: {explanation}')
 
-    return valid_at_datetime, invalid_at_datetime, explanation
+    return valid_at_datetime, invalid_at_datetime

graphiti_core/utils/utils.py

@@ -15,8 +15,9 @@ limitations under the License.
 """
 
 import logging
+from collections import defaultdict
 
-from graphiti_core.edges import EpisodicEdge
+from graphiti_core.edges import EntityEdge, EpisodicEdge
 from graphiti_core.nodes import EntityNode, EpisodicNode
 
 logger = logging.getLogger(__name__)
@@ -37,3 +38,23 @@ def build_episodic_edges(
         )
 
     return edges
+
+
+def chunk_edges_by_nodes(edges: list[EntityEdge]) -> list[list[EntityEdge]]:
+    # We only want to dedupe edges that are between the same pair of nodes
+    # We build a map of the edges based on their source and target nodes.
+    edge_chunk_map: dict[str, list[EntityEdge]] = defaultdict(list)
+    for edge in edges:
+        # We drop loop edges
+        if edge.source_node_uuid == edge.target_node_uuid:
+            continue
+
+        # Keep the order of the two nodes consistent, we want to be direction agnostic during edge resolution
+        pointers = [edge.source_node_uuid, edge.target_node_uuid]
+        pointers.sort()
+
+        edge_chunk_map[pointers[0] + pointers[1]].append(edge)
+
+    edge_chunks = [chunk for chunk in edge_chunk_map.values()]
+
+    return edge_chunks

{graphiti_core-0.1.0.dist-info → graphiti_core-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.1.0
+Version: 0.2.0
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -17,64 +17,67 @@ Requires-Dist: neo4j (>=5.23.0,<6.0.0)
 Requires-Dist: openai (>=1.38.0,<2.0.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
 Requires-Dist: sentence-transformers (>=3.0.1,<4.0.0)
-Requires-Dist: tenacity (>=9.0.0,<10.0.0)
+Requires-Dist: tenacity (<9.0.0)
 Description-Content-Type: text/markdown
 
 <div align="center">
 
-# graphiti
+# Graphiti
 
 ## Temporal Knowledge Graphs for Agentic Applications
 
 <br />
 
 [![Discord](https://dcbadge.vercel.app/api/server/W8Kw6bsgXQ?style=flat)](https://discord.com/invite/W8Kw6bsgXQ)
-[![Lint](https://github.com/getzep/graphiti/actions/workflows/lint.yml/badge.svg)](https://github.com/getzep/graphiti/actions/workflows/lint.yml)
-[![Unit Tests](https://github.com/getzep/graphiti/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/getzep/graphiti/actions/workflows/unit_tests.yml)
-[![MyPy Check](https://github.com/getzep/graphiti/actions/workflows/typecheck.yml/badge.svg)](https://github.com/getzep/graphiti/actions/workflows/typecheck.yml)
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/getzep/graphiti)
+[![Lint](https://github.com/getzep/Graphiti/actions/workflows/lint.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/lint.yml)
+[![Unit Tests](https://github.com/getzep/Graphiti/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/unit_tests.yml)
+[![MyPy Check](https://github.com/getzep/Graphiti/actions/workflows/typecheck.yml/badge.svg)](https://github.com/getzep/Graphiti/actions/workflows/typecheck.yml)
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/getzep/Graphiti)
 
 <br />
 
 </div>
 
-graphiti builds dynamic, temporally aware knowledge graphs that represent complex, evolving relationships between entities over time. graphiti ingests both unstructured and structured data and the resulting graph may be queried using a fusion of time, full-text, semantic, and graph algorithm approaches.
+Graphiti builds dynamic, temporally aware Knowledge Graphs that represent complex, evolving relationships between entities over time. Graphiti ingests both unstructured and structured data, and the resulting graph may be queried using a fusion of time, full-text, semantic, and graph algorithm approaches.
 
 <br />
 
- 
 <p align="center">
-    <img src="/images/graphiti-intro-slides-stock-2.gif" alt="graphiti demo slides" width="700px">   
+    <img src="/images/graphiti-graph-intro.gif" alt="Graphiti temporal walkthrough" width="700px">   
 </p>
 
 <br />
- 
-With graphiti, you can build LLM applications such as:
+
+Graphiti helps you create and query Knowledge Graphs that evolve over time. 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.
+
+With Graphiti, you can build LLM applications such as:
 
 - Assistants that learn from user interactions, fusing personal knowledge with dynamic data from business systems like CRMs and billing platforms.
 - Agents that autonomously execute complex tasks, reasoning with state changes from multiple dynamic sources.
 
-graphiti supports a wide range of applications in sales, customer service, health, finance, and more, enabling long-term recall and state-based reasoning for both assistants and agents.
-
-## Why graphiti?
+Graphiti supports a wide range of applications in sales, customer service, health, finance, and more, enabling long-term recall and state-based reasoning for both assistants and agents.
 
-graphiti is designed for dynamic data and agentic use:
+## Why Graphiti?
 
-- **Smart Graph Updates**: Automatically evaluates new entities against the current graph, revising both to reflect the latest context.
-- **Rich Edge Semantics**: Generates human-readable, semantic, and full-text searchable representations for edges during graph construction, enabling search and enhancing interpretability.
-- **Temporal Awareness**: Extracts and updates time-based edge metadata from input data, enabling reasoning over changing relationships.
-- **Hybrid Search**: Offers semantic, BM25, and graph-based search with the ability to fuse results.
-- **Fast**: Search results in < 100ms, with latency primarily determined by the 3rd-party embedding API call.
-- **Schema Consistency**: Maintains a coherent graph structure by reusing existing schema, preventing unnecessary proliferation of node and edge types.
+We were intrigued by Microsoft’s GraphRAG, which expanded on RAG text chunking by using a graph to better model a document corpus and making this representation available via semantic and graph search techniques. However, GraphRAG did not address our core problem: It's primarily designed for static documents and doesn't inherently handle temporal aspects of data.
 
+Graphiti is designed from the ground up to handle constantly changing information, hybrid semantic and graph search, and scale:
 
-## graphiti and Zep Memory
+- **Temporal Awareness:** Tracks changes in facts and relationships over time, enabling point-in-time queries. Graph edges include temporal metadata to record relationship lifecycles.
+- **Episodic Processing:** Ingests data as discrete episodes, maintaining data provenance and allowing incremental entity and relationship extraction.
+- **Hybrid Search:** Combines semantic and BM25 full-text search, with the ability to rerank results by distance from a central node e.g. “Kendra”.
+- **Scalable:** Designed for processing large datasets, with parallelization of LLM calls for bulk processing while preserving the chronology of events.
+- **Supports Varied Sources:** Can ingest both unstructured text and structured JSON data.
 
-graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for LLM-powered Assistants and Agents.
+<p align="center">
+    <img src="/images/graphiti-intro-slides-stock-2.gif" alt="Graphiti structured + unstructured demo" width="700px">   
+</p>
 
-We're excited to open-source graphiti, believing its potential reaches far beyond memory applications.
+## Graphiti and Zep Memory
 
+Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for LLM-powered Assistants and Agents.
 
+We're excited to open-source Graphiti, believing its potential reaches far beyond memory applications.
 
 ## Installation
 
@@ -101,12 +104,10 @@ or
 poetry add graphiti-core
 ```
 
-
-
 ## Quick Start
 
 > [!IMPORTANT]
-> graphiti uses 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.
+> Graphiti uses 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.
 
 ```python
 from graphiti_core import Graphiti
@@ -116,6 +117,9 @@ from datetime import datetime
 # Initialize Graphiti
 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 "
@@ -161,24 +165,21 @@ results = await graphiti.search('Who was the California Attorney General?')
 # 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 client.search('Who was the California Attorney General?', center_node_uuid)
+await graphiti.search('Who was the California Attorney General?', center_node_uuid)
 
 # Close the connection
 graphiti.close()
 ```
 
-
-
 ## Documentation
 
-Visit the Zep knowledge base for graphiti [Guides and API documentation](https://help.getzep.com/graphiti/graphiti).
-
+Visit the Zep knowledge base for Graphiti [Guides and API documentation](https://help.getzep.com/Graphiti/Graphiti).
 
 ## Status and Roadmap
 
-graphiti is under active development. We aim to maintain API stability while working on:
+Graphiti is under active development. We aim to maintain API stability while working on:
 
-- [ ] Implementing node and edge CRUD operations
+- [x] Implementing node and edge CRUD operations
 - [ ] Improving performance and scalability
 - [ ] Achieving good performance with different LLM and embedding models
 - [ ] Creating a dedicated embedder interface
@@ -188,12 +189,11 @@ graphiti is under active development. We aim to maintain API stability while wor
 - [ ] Enhancing retrieval capabilities with more robust and configurable options
 - [ ] Expanding test coverage to ensure reliability and catch edge cases
 
-
 ## Contributing
 
-We encourage and appreciate all forms of contributions, whether it's code, documentation, addressing GitHub Issues, or answering questions in the graphiti Discord channel. For detailed guidelines on code contributions, please refer to [CONTRIBUTING](CONTRIBUTING.md).
+We encourage and appreciate all forms of contributions, whether it's code, documentation, addressing GitHub Issues, or answering questions in the Graphiti Discord channel. For detailed guidelines on code contributions, please refer to [CONTRIBUTING](CONTRIBUTING.md).
 
 ## Support
 
-Join the [Zep Discord server](https://discord.com/invite/W8Kw6bsgXQ) and make your way to the **#graphiti** channel!
+Join the [Zep Discord server](https://discord.com/invite/W8Kw6bsgXQ) and make your way to the **#Graphiti** channel!
 

{graphiti_core-0.1.0.dist-info → graphiti_core-0.2.0.dist-info}/RECORD

@@ -1,37 +1,37 @@
 graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
 graphiti_core/edges.py,sha256=Sxsqw7WZAC6YJKftMaF9t69o7HV_GM6m6ULjtLhZg0M,7484
-graphiti_core/graphiti.py,sha256=HQUKURAzCZAFMtqWXP-l9QwEGGmkF6iFbguJIGyiGZk,23347
+graphiti_core/graphiti.py,sha256=BuKFvBA6tqcYKlwGexKQZ0sLNavEvDRzAMo_umlFVcM,23450
 graphiti_core/helpers.py,sha256=EAeC3RrcecjiTGN2vxergN5RHTy2_jhFXA5PQVT3toU,200
 graphiti_core/llm_client/__init__.py,sha256=f4OSk82jJ70wZ2HOuQu6-RQWkkf7HIB0FCT6xOuxZkQ,154
 graphiti_core/llm_client/anthropic_client.py,sha256=C8lOLm7in_eNfOP7s8gjMM0Y99-TzKWlGaPuVGceX68,2180
 graphiti_core/llm_client/client.py,sha256=ysBf3zDOVbgBgwHbHB478TCVnOBjIwTELNsBovUh35g,3135
 graphiti_core/llm_client/config.py,sha256=d1oZ9tt7QBQlbph7v-0HjItb6otK9_-IwF8kkRYL2rc,2359
 graphiti_core/llm_client/groq_client.py,sha256=qscr5-190wBTUCBL31EAjQTLytK9AF75-y9GsVRvGJU,2206
-graphiti_core/llm_client/openai_client.py,sha256=vnO_KyWnL5BOT8btb4nZQRLggt5hcH1AJ7-iKXl17FU,2246
+graphiti_core/llm_client/openai_client.py,sha256=Bkrp_mKzAxK6kgPzv1UtVUgr1ZvvJhE2H39hgAwWrsI,2211
 graphiti_core/llm_client/utils.py,sha256=H8-Kwa5SyvIYDNIas8O4bHJ6jsOL49li44VoDEMyauY,555
 graphiti_core/nodes.py,sha256=lUSGkWs7EN88qQ1kwwun-t1SWNmTL4z8fOg1dOCqwl0,7879
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
-graphiti_core/prompts/dedupe_edges.py,sha256=0aLQsm6nH-_hZSCKh7UB2bR6VlNt7uztu0JO9mIi8pI,4962
-graphiti_core/prompts/dedupe_nodes.py,sha256=jpHJ97w9nh0RMyVIG3K_6O6zjgHtXTJ8Fk4exZfkvLc,4734
+graphiti_core/prompts/dedupe_edges.py,sha256=FuZQVZlXTYjskaRUYblToLw4cFjyDp4ECrSf-Y8Z4sU,6530
+graphiti_core/prompts/dedupe_nodes.py,sha256=BZ9S-PB9SSGjc5Oo8ivdgA6rZx3OGOFhKtwrBlQ0bm0,7269
 graphiti_core/prompts/extract_edge_dates.py,sha256=G-Gnsyt8pYx9lFJEwlIsTdADF3ESDe26WSsrAGmvlYk,3086
-graphiti_core/prompts/extract_edges.py,sha256=pa9Wd2UJzpb-Ye10yvcNXeTilD_0cmqkhfl46w9u7mg,5259
-graphiti_core/prompts/extract_nodes.py,sha256=VU3uqj3cWALOYA_FuaJ8I6pALG-52ZL5qxsTVmxepxs,5106
+graphiti_core/prompts/extract_edges.py,sha256=AQ8xYbAv_RKXAT6WMwXs1_GvUdLtM_lhLNbt3SkOAmk,5348
+graphiti_core/prompts/extract_nodes.py,sha256=isYly1Yq9tpD-Dlj2JNvKMdsJUqjWMSO16ZFinFxWic,5304
 graphiti_core/prompts/invalidate_edges.py,sha256=-BJ5j73fDAhRJa1abs35rKYyo-_OSZYTlQNphfo5Kuk,2993
 graphiti_core/prompts/lib.py,sha256=RR8f8DQfioUK5bJonMzn02pKLxJlaENv1VocpvRJ488,3532
 graphiti_core/prompts/models.py,sha256=cvx_Bv5RMFUD_5IUawYrbpOKLPHogai7_bm7YXrSz84,867
 graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/search/search.py,sha256=1tURWlCnFvPW6cEOxBot9svutVnIlLNsB15Uj0LCGYA,4438
-graphiti_core/search/search_utils.py,sha256=BNGYPCE2AbdvJQBf0Uutd4GIhju-vbwoSj4Mn225K3I,14456
+graphiti_core/search/search.py,sha256=kL3bTnDUwi2-yCWA9RX9JZrbEnk3FVB1RfcEw5naWtY,4414
+graphiti_core/search/search_utils.py,sha256=F1zA_kN3CSwkgKRUohEN0E5H7TWuC6bo879NwprKGpY,15170
 graphiti_core/utils/__init__.py,sha256=cJAcMnBZdHBQmWrZdU1PQ1YmaL75bhVUkyVpIPuOyns,260
-graphiti_core/utils/bulk_utils.py,sha256=dNO2CYAAp5ViTy-BE3jjQrR60Lpry5YiiX3x5rqIbxQ,7284
+graphiti_core/utils/bulk_utils.py,sha256=rArgax8-OpC7MEay0BUzHXZIZKyl3luUiUm3gtrB6kc,11671
 graphiti_core/utils/maintenance/__init__.py,sha256=4b9sfxqyFZMLwxxS2lnQ6_wBr3xrJRIqfAWOidK8EK0,388
-graphiti_core/utils/maintenance/edge_operations.py,sha256=xI2aC_Ys5fwbHAO0wWqNp1kkf1QHxoudxY5oJ4nF7TI,5171
+graphiti_core/utils/maintenance/edge_operations.py,sha256=Z9t9Rwnpjcc2obcOG6kAxeqrfQCNak54hT8do2RrITs,7201
 graphiti_core/utils/maintenance/graph_data_operations.py,sha256=ggzCWezFyLC29VZBiYHvanOpSRLaPtcmbgHgcl-qHy8,5321
-graphiti_core/utils/maintenance/node_operations.py,sha256=WS_GOtR1E2YXZn55bmI9bmS0JWVm_Yn2UFQEpW6QPm4,6516
-graphiti_core/utils/maintenance/temporal_operations.py,sha256=4iAwWfMvVPWiRQNai73402GmCXof31Am9-hTY0XXAn4,6903
+graphiti_core/utils/maintenance/node_operations.py,sha256=K2O_8Ey2ugBW9DkEUjy4p53qeJ5mbPAEGX7XzN9HF54,8016
+graphiti_core/utils/maintenance/temporal_operations.py,sha256=XIo3xSYQ_4LFiRDBJ-V03l2-rYeIcq6Id0O1o53yWWY,6865
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/utils/utils.py,sha256=em03o4Ekc8ALP6a0Vq1O5AqRUo14g7wQbxGb2eVidDw,1130
-graphiti_core-0.1.0.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.1.0.dist-info/METADATA,sha256=aJb1Ee0CRP8rFZiTlCf3NzkJpJ1jVHF8zKzXw9magmE,7869
-graphiti_core-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.1.0.dist-info/RECORD,,
+graphiti_core/utils/utils.py,sha256=LguHvEDi9JruXKWXXHaz2f4vpezdfgY-rpxjPq0dao8,1959
+graphiti_core-0.2.0.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.2.0.dist-info/METADATA,sha256=ce4A0ZTcN36eNCvy0G8BbTy1l5Epr3WqEbIrgaNtOuQ,9040
+graphiti_core-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.2.0.dist-info/RECORD,,