graphiti-core 0.3.20__py3-none-any.whl → 0.4.0__py3-none-any.whl

graphiti_core/utils/maintenance/community_operations.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from collections import defaultdict
-from datetime import datetime
+from datetime import datetime, timezone
 
 from neo4j import AsyncDriver
 from pydantic import BaseModel
@@ -178,7 +178,7 @@ async def build_community(
 
     summary = summaries[0]
     name = await generate_summary_description(llm_client, summary)
-    now = datetime.now()
+    now = datetime.now(timezone.utc)
     community_node = CommunityNode(
         name=name,
         group_id=community_cluster[0].group_id,
@@ -305,7 +305,7 @@ async def update_community(
     community.name = new_name
 
     if is_new:
-        community_edge = (build_community_edges([entity], community, datetime.now()))[0]
+        community_edge = (build_community_edges([entity], community, datetime.now(timezone.utc)))[0]
         await community_edge.save(driver)
 
     await community.generate_name_embedding(embedder)

graphiti_core/utils/maintenance/edge_operations.py

@@ -16,11 +16,12 @@ limitations under the License.
 
 import asyncio
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from time import time
 from typing import List
 
 from graphiti_core.edges import CommunityEdge, EntityEdge, EpisodicEdge
+from graphiti_core.helpers import MAX_REFLEXION_ITERATIONS
 from graphiti_core.llm_client import LLMClient
 from graphiti_core.nodes import CommunityNode, EntityNode, EpisodicNode
 from graphiti_core.prompts import prompt_library
@@ -77,24 +78,41 @@ async def extract_edges(
 ) -> list[EntityEdge]:
     start = time()
 
+    node_uuids_by_name_map = {node.name: node.uuid for node in nodes}
+
     # Prepare context for LLM
     context = {
         'episode_content': episode.content,
-        'episode_timestamp': (episode.valid_at.isoformat() if episode.valid_at else None),
-        'nodes': [
-            {'uuid': node.uuid, 'name': node.name, 'summary': node.summary} for node in nodes
-        ],
-        'previous_episodes': [
-            {
-                'content': ep.content,
-                'timestamp': ep.valid_at.isoformat() if ep.valid_at else None,
-            }
-            for ep in previous_episodes
-        ],
+        'nodes': [node.name for node in nodes],
+        'previous_episodes': [ep.content for ep in previous_episodes],
+        'custom_prompt': '',
     }
 
-    llm_response = await llm_client.generate_response(prompt_library.extract_edges.v2(context))
-    edges_data = llm_response.get('edges', [])
+    facts_missed = True
+    reflexion_iterations = 0
+    while facts_missed and reflexion_iterations < MAX_REFLEXION_ITERATIONS:
+        llm_response = await llm_client.generate_response(
+            prompt_library.extract_edges.edge(context)
+        )
+        edges_data = llm_response.get('edges', [])
+
+        context['extracted_facts'] = [edge_data.get('fact', '') for edge_data in edges_data]
+
+        reflexion_iterations += 1
+        if reflexion_iterations < MAX_REFLEXION_ITERATIONS:
+            reflexion_response = await llm_client.generate_response(
+                prompt_library.extract_edges.reflexion(context)
+            )
+
+            missing_facts = reflexion_response.get('missing_facts', [])
+
+            custom_prompt = 'The following facts were missed in a previous extraction: '
+            for fact in missing_facts:
+                custom_prompt += f'\n{fact},'
+
+            context['custom_prompt'] = custom_prompt
+
+            facts_missed = len(missing_facts) != 0
 
     end = time()
     logger.debug(f'Extracted new edges: {edges_data} in {(end - start) * 1000} ms')
@@ -102,22 +120,25 @@ async def extract_edges(
     # Convert the extracted data into EntityEdge objects
     edges = []
     for edge_data in edges_data:
-        if edge_data['target_node_uuid'] and edge_data['source_node_uuid']:
-            edge = EntityEdge(
-                source_node_uuid=edge_data['source_node_uuid'],
-                target_node_uuid=edge_data['target_node_uuid'],
-                name=edge_data['relation_type'],
-                group_id=group_id,
-                fact=edge_data['fact'],
-                episodes=[episode.uuid],
-                created_at=datetime.now(),
-                valid_at=None,
-                invalid_at=None,
-            )
-            edges.append(edge)
-            logger.debug(
-                f'Created new edge: {edge.name} from (UUID: {edge.source_node_uuid}) to (UUID: {edge.target_node_uuid})'
-            )
+        edge = EntityEdge(
+            source_node_uuid=node_uuids_by_name_map.get(
+                edge_data.get('source_entity_name', ''), ''
+            ),
+            target_node_uuid=node_uuids_by_name_map.get(
+                edge_data.get('target_entity_name', ''), ''
+            ),
+            name=edge_data.get('relation_type', ''),
+            group_id=group_id,
+            fact=edge_data.get('fact', ''),
+            episodes=[episode.uuid],
+            created_at=datetime.now(timezone.utc),
+            valid_at=None,
+            invalid_at=None,
+        )
+        edges.append(edge)
+        logger.debug(
+            f'Created new edge: {edge.name} from (UUID: {edge.source_node_uuid}) to (UUID: {edge.target_node_uuid})'
+        )
 
     return edges
 
@@ -142,7 +163,7 @@ async def dedupe_extracted_edges(
         ],
     }
 
-    llm_response = await llm_client.generate_response(prompt_library.dedupe_edges.v1(context))
+    llm_response = await llm_client.generate_response(prompt_library.dedupe_edges.edge(context))
     duplicate_data = llm_response.get('duplicates', [])
     logger.debug(f'Extracted unique edges: {duplicate_data}')
 
@@ -205,6 +226,38 @@ async def resolve_extracted_edges(
     return resolved_edges, invalidated_edges
 
 
+def resolve_edge_contradictions(
+    resolved_edge: EntityEdge, invalidation_candidates: list[EntityEdge]
+) -> list[EntityEdge]:
+    # Determine which contradictory edges need to be expired
+    invalidated_edges: list[EntityEdge] = []
+    for edge in invalidation_candidates:
+        # (Edge invalid before new edge becomes valid) or (new edge invalid before edge becomes valid)
+        if (
+            edge.invalid_at is not None
+            and resolved_edge.valid_at is not None
+            and edge.invalid_at <= resolved_edge.valid_at
+        ) or (
+            edge.valid_at is not None
+            and resolved_edge.invalid_at is not None
+            and resolved_edge.invalid_at <= edge.valid_at
+        ):
+            continue
+        # New edge invalidates edge
+        elif (
+            edge.valid_at is not None
+            and resolved_edge.valid_at is not None
+            and edge.valid_at < resolved_edge.valid_at
+        ):
+            edge.invalid_at = resolved_edge.valid_at
+            edge.expired_at = (
+                edge.expired_at if edge.expired_at is not None else datetime.now(timezone.utc)
+            )
+            invalidated_edges.append(edge)
+
+    return invalidated_edges
+
+
 async def resolve_extracted_edge(
     llm_client: LLMClient,
     extracted_edge: EntityEdge,
@@ -219,7 +272,7 @@ async def resolve_extracted_edge(
         get_edge_contradictions(llm_client, extracted_edge, existing_edges),
     )
 
-    now = datetime.now()
+    now = datetime.now(timezone.utc)
 
     resolved_edge.valid_at = valid_at if valid_at is not None else resolved_edge.valid_at
     resolved_edge.invalid_at = invalid_at if invalid_at is not None else resolved_edge.invalid_at
@@ -239,28 +292,7 @@ async def resolve_extracted_edge(
                 break
 
     # Determine which contradictory edges need to be expired
-    invalidated_edges: list[EntityEdge] = []
-    for edge in invalidation_candidates:
-        # (Edge invalid before new edge becomes valid) or (new edge invalid before edge becomes valid)
-        if (
-            edge.invalid_at is not None
-            and resolved_edge.valid_at is not None
-            and edge.invalid_at <= resolved_edge.valid_at
-        ) or (
-            edge.valid_at is not None
-            and resolved_edge.invalid_at is not None
-            and resolved_edge.invalid_at <= edge.valid_at
-        ):
-            continue
-        # New edge invalidates edge
-        elif (
-            edge.valid_at is not None
-            and resolved_edge.valid_at is not None
-            and edge.valid_at < resolved_edge.valid_at
-        ):
-            edge.invalid_at = resolved_edge.valid_at
-            edge.expired_at = edge.expired_at if edge.expired_at is not None else now
-            invalidated_edges.append(edge)
+    invalidated_edges = resolve_edge_contradictions(resolved_edge, invalidation_candidates)
 
     return resolved_edge, invalidated_edges
 
@@ -286,7 +318,7 @@ async def dedupe_extracted_edge(
         'extracted_edges': extracted_edge_context,
     }
 
-    llm_response = await llm_client.generate_response(prompt_library.dedupe_edges.v3(context))
+    llm_response = await llm_client.generate_response(prompt_library.dedupe_edges.edge(context))
 
     is_duplicate: bool = llm_response.get('is_duplicate', False)
     uuid: str | None = llm_response.get('uuid', None)

graphiti_core/utils/maintenance/node_operations.py

@@ -16,10 +16,10 @@ limitations under the License.
 
 import asyncio
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from time import time
-from typing import Any
 
+from graphiti_core.helpers import MAX_REFLEXION_ITERATIONS
 from graphiti_core.llm_client import LLMClient
 from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode
 from graphiti_core.prompts import prompt_library
@@ -28,65 +28,84 @@ logger = logging.getLogger(__name__)
 
 
 async def extract_message_nodes(
-    llm_client: LLMClient, episode: EpisodicNode, previous_episodes: list[EpisodicNode]
-) -> list[dict[str, Any]]:
+    llm_client: LLMClient,
+    episode: EpisodicNode,
+    previous_episodes: list[EpisodicNode],
+    custom_prompt='',
+) -> list[str]:
     # Prepare context for LLM
     context = {
         'episode_content': episode.content,
         'episode_timestamp': episode.valid_at.isoformat(),
-        'previous_episodes': [
-            {
-                'content': ep.content,
-                'timestamp': ep.valid_at.isoformat(),
-            }
-            for ep in previous_episodes
-        ],
+        'previous_episodes': [ep.content for ep in previous_episodes],
+        'custom_prompt': custom_prompt,
     }
 
-    llm_response = await llm_client.generate_response(prompt_library.extract_nodes.v2(context))
-    extracted_node_data = llm_response.get('extracted_nodes', [])
-    return extracted_node_data
+    llm_response = await llm_client.generate_response(
+        prompt_library.extract_nodes.extract_message(context)
+    )
+    extracted_node_names = llm_response.get('extracted_node_names', [])
+    return extracted_node_names
 
 
 async def extract_text_nodes(
-    llm_client: LLMClient, episode: EpisodicNode, previous_episodes: list[EpisodicNode]
-) -> list[dict[str, Any]]:
+    llm_client: LLMClient,
+    episode: EpisodicNode,
+    previous_episodes: list[EpisodicNode],
+    custom_prompt='',
+) -> list[str]:
     # Prepare context for LLM
     context = {
         'episode_content': episode.content,
         'episode_timestamp': episode.valid_at.isoformat(),
-        'previous_episodes': [
-            {
-                'content': ep.content,
-                'timestamp': ep.valid_at.isoformat(),
-            }
-            for ep in previous_episodes
-        ],
+        'previous_episodes': [ep.content for ep in previous_episodes],
+        'custom_prompt': custom_prompt,
     }
 
     llm_response = await llm_client.generate_response(
         prompt_library.extract_nodes.extract_text(context)
     )
-    extracted_node_data = llm_response.get('extracted_nodes', [])
-    return extracted_node_data
+    extracted_node_names = llm_response.get('extracted_node_names', [])
+    return extracted_node_names
 
 
 async def extract_json_nodes(
-    llm_client: LLMClient,
-    episode: EpisodicNode,
-) -> list[dict[str, Any]]:
+    llm_client: LLMClient, episode: EpisodicNode, custom_prompt=''
+) -> list[str]:
     # Prepare context for LLM
     context = {
         'episode_content': episode.content,
         'episode_timestamp': episode.valid_at.isoformat(),
         'source_description': episode.source_description,
+        'custom_prompt': custom_prompt,
     }
 
     llm_response = await llm_client.generate_response(
         prompt_library.extract_nodes.extract_json(context)
     )
-    extracted_node_data = llm_response.get('extracted_nodes', [])
-    return extracted_node_data
+    extracted_node_names = llm_response.get('extracted_node_names', [])
+    return extracted_node_names
+
+
+async def extract_nodes_reflexion(
+    llm_client: LLMClient,
+    episode: EpisodicNode,
+    previous_episodes: list[EpisodicNode],
+    node_names: list[str],
+) -> list[str]:
+    # Prepare context for LLM
+    context = {
+        'episode_content': episode.content,
+        'previous_episodes': [ep.content for ep in previous_episodes],
+        'extracted_entities': node_names,
+    }
+
+    llm_response = await llm_client.generate_response(
+        prompt_library.extract_nodes.reflexion(context)
+    )
+    missed_entities = llm_response.get('missed_entities', [])
+
+    return missed_entities
 
 
 async def extract_nodes(
@@ -95,25 +114,45 @@ async def extract_nodes(
     previous_episodes: list[EpisodicNode],
 ) -> list[EntityNode]:
     start = time()
-    extracted_node_data: list[dict[str, Any]] = []
-    if episode.source == EpisodeType.message:
-        extracted_node_data = await extract_message_nodes(llm_client, episode, previous_episodes)
-    elif episode.source == EpisodeType.text:
-        extracted_node_data = await extract_text_nodes(llm_client, episode, previous_episodes)
-    elif episode.source == EpisodeType.json:
-        extracted_node_data = await extract_json_nodes(llm_client, episode)
+    extracted_node_names: list[str] = []
+    custom_prompt = ''
+    entities_missed = True
+    reflexion_iterations = 0
+    while entities_missed and reflexion_iterations < MAX_REFLEXION_ITERATIONS:
+        if episode.source == EpisodeType.message:
+            extracted_node_names = await extract_message_nodes(
+                llm_client, episode, previous_episodes, custom_prompt
+            )
+        elif episode.source == EpisodeType.text:
+            extracted_node_names = await extract_text_nodes(
+                llm_client, episode, previous_episodes, custom_prompt
+            )
+        elif episode.source == EpisodeType.json:
+            extracted_node_names = await extract_json_nodes(llm_client, episode, custom_prompt)
+
+        reflexion_iterations += 1
+        if reflexion_iterations < MAX_REFLEXION_ITERATIONS:
+            missing_entities = await extract_nodes_reflexion(
+                llm_client, episode, previous_episodes, extracted_node_names
+            )
+
+            entities_missed = len(missing_entities) != 0
+
+            custom_prompt = 'The following entities were missed in a previous extraction: '
+            for entity in missing_entities:
+                custom_prompt += f'\n{entity},'
 
     end = time()
-    logger.debug(f'Extracted new nodes: {extracted_node_data} in {(end - start) * 1000} ms')
+    logger.debug(f'Extracted new nodes: {extracted_node_names} in {(end - start) * 1000} ms')
     # Convert the extracted data into EntityNode objects
     new_nodes = []
-    for node_data in extracted_node_data:
+    for name in extracted_node_names:
         new_node = EntityNode(
-            name=node_data['name'],
+            name=name,
             group_id=episode.group_id,
-            labels=node_data['labels'],
-            summary=node_data['summary'],
-            created_at=datetime.now(),
+            labels=['Entity'],
+            summary='',
+            created_at=datetime.now(timezone.utc),
         )
         new_nodes.append(new_node)
         logger.debug(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
@@ -147,7 +186,7 @@ async def dedupe_extracted_nodes(
         'extracted_nodes': extracted_nodes_context,
     }
 
-    llm_response = await llm_client.generate_response(prompt_library.dedupe_nodes.v2(context))
+    llm_response = await llm_client.generate_response(prompt_library.dedupe_nodes.node(context))
 
     duplicate_data = llm_response.get('duplicates', [])
 
@@ -175,13 +214,17 @@ async def resolve_extracted_nodes(
     llm_client: LLMClient,
     extracted_nodes: list[EntityNode],
     existing_nodes_lists: list[list[EntityNode]],
+    episode: EpisodicNode | None = None,
+    previous_episodes: list[EpisodicNode] | None = None,
 ) -> 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)
+                resolve_extracted_node(
+                    llm_client, extracted_node, existing_nodes, episode, previous_episodes
+                )
                 for extracted_node, existing_nodes in zip(extracted_nodes, existing_nodes_lists)
             ]
         )
@@ -195,14 +238,16 @@ async def resolve_extracted_nodes(
 
 
 async def resolve_extracted_node(
-    llm_client: LLMClient, extracted_node: EntityNode, existing_nodes: list[EntityNode]
+    llm_client: LLMClient,
+    extracted_node: EntityNode,
+    existing_nodes: list[EntityNode],
+    episode: EpisodicNode | None = None,
+    previous_episodes: list[EpisodicNode] | None = None,
 ) -> 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
-    ]
+    existing_nodes_context = [{'uuid': node.uuid, 'name': node.name} for node in existing_nodes]
 
     extracted_node_context = {
         'uuid': extracted_node.uuid,
@@ -213,13 +258,32 @@ async def resolve_extracted_node(
     context = {
         'existing_nodes': existing_nodes_context,
         'extracted_nodes': extracted_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 [],
     }
 
-    llm_response = await llm_client.generate_response(prompt_library.dedupe_nodes.v3(context))
+    summary_context = {
+        'node_name': extracted_node.name,
+        '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 [],
+    }
+
+    llm_response, node_summary_response = await asyncio.gather(
+        llm_client.generate_response(prompt_library.dedupe_nodes.node(context)),
+        llm_client.generate_response(
+            prompt_library.summarize_nodes.summarize_context(summary_context)
+        ),
+    )
+
+    extracted_node.summary = node_summary_response.get('summary', '')
 
     is_duplicate: bool = llm_response.get('is_duplicate', False)
     uuid: str | None = llm_response.get('uuid', None)
-    summary = llm_response.get('summary', '')
+    name = llm_response.get('name', '')
 
     node = extracted_node
     uuid_map: dict[str, str] = {}
@@ -227,8 +291,14 @@ async def resolve_extracted_node(
         for existing_node in existing_nodes:
             if existing_node.uuid != uuid:
                 continue
+            summary_response = await llm_client.generate_response(
+                prompt_library.summarize_nodes.summarize_pair(
+                    {'node_summaries': [extracted_node.summary, existing_node.summary]}
+                )
+            )
             node = existing_node
-            node.summary = summary
+            node.name = name
+            node.summary = summary_response.get('summary', '')
             uuid_map[extracted_node.uuid] = existing_node.uuid
 
     end = time()

{graphiti_core-0.3.20.dist-info → graphiti_core-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.3.20
+Version: 0.4.0
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -14,9 +14,10 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: diskcache (>=5.6.3,<6.0.0)
 Requires-Dist: neo4j (>=5.23.0,<6.0.0)
 Requires-Dist: numpy (>=1.0.0)
-Requires-Dist: openai (>=1.52.2,<2.0.0)
+Requires-Dist: openai (>=1.53.0,<2.0.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
-Requires-Dist: tenacity (<9.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: tenacity (==9.0.0)
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -129,7 +130,7 @@ poetry add graphiti-core
 ```python
 from graphiti_core import Graphiti
 from graphiti_core.nodes import EpisodeType
-from datetime import datetime
+from datetime import datetime, timezone
 
 # Initialize Graphiti
 graphiti = Graphiti("bolt://localhost:7687", "neo4j", "password")
@@ -149,7 +150,7 @@ for i, episode in enumerate(episodes):
         episode_body=episode,
         source=EpisodeType.text,
         source_description="podcast",
-        reference_time=datetime.now()
+        reference_time=datetime.now(timezone.utc)
     )
 
 # Search the graph

{graphiti_core-0.3.20.dist-info → graphiti_core-0.4.0.dist-info}/RECORD

@@ -2,15 +2,15 @@ graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
 graphiti_core/cross_encoder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 graphiti_core/cross_encoder/bge_reranker_client.py,sha256=jsXBUHfFpGsNASHaRnfz1_miQ3x070DdU8QS4J3DciI,1466
 graphiti_core/cross_encoder/client.py,sha256=PyFYYsALQAD9wu0gL5uquPsulmaBZ0AZkJmLq2DFA-c,1472
-graphiti_core/cross_encoder/openai_reranker_client.py,sha256=ij1E1Y5G9GNP3h3h8nSUF-ZJrQ921B54uudZUsCUaDc,4063
+graphiti_core/cross_encoder/openai_reranker_client.py,sha256=F0S9ksusyxdlcRp4yRJuCyAEg-YqgdCwXjZbH8L-Xxo,4063
 graphiti_core/edges.py,sha256=wKXmNXtu1deT5MfcqUNGHQlBLgwt3MJ_3j35ibNbpi8,13087
 graphiti_core/embedder/__init__.py,sha256=eWd-0sPxflnYXLoWNT9sxwCIFun5JNO9Fk4E-ZXXf8Y,164
 graphiti_core/embedder/client.py,sha256=gVr_xdN-d0UQfeE4Nyoa4pL3M8UxllNH4eFqmarxwys,1011
 graphiti_core/embedder/openai.py,sha256=yYUYPymx_lBlxDTGrlc03yNhPFyGG-etM2sszRK2G2U,1618
 graphiti_core/embedder/voyage.py,sha256=_eGFI5_NjNG8z7qG3jTWCdE7sAs1Yb8fiSZSJlQLD9o,1879
 graphiti_core/errors.py,sha256=ddHrHGQxhwkVAtSph4AV84UoOlgwZufMczXPwB7uqPo,1795
-graphiti_core/graphiti.py,sha256=MIwkprC9L9FVj7cGrAzrNbpgkpPtUPPofLlfCrtXLHU,27584
-graphiti_core/helpers.py,sha256=6N5nNgyXiHWsMXHxm9M_S6Og7_TuejE5GuyV6EtZgVw,2178
+graphiti_core/graphiti.py,sha256=-dJUa_spL0yRbGCUqWaAtZ1hlA2FaIzoHcIMT57KQYY,26919
+graphiti_core/helpers.py,sha256=0kkfmswLxRek27WpeUolTBNyyu3_XQwl8xOLRSkAwqk,2207
 graphiti_core/llm_client/__init__.py,sha256=PA80TSMeX-sUXITXEAxMDEt3gtfZgcJrGJUcyds1mSo,207
 graphiti_core/llm_client/anthropic_client.py,sha256=4l2PbCjIoeRr7UJ2DUh2grYLTtE2vNaWlo72IIRQDeI,2405
 graphiti_core/llm_client/client.py,sha256=WAnX0e4EuCFHXdFHeq_O1HZsW1STSByvDCFUHMAHEFU,3394
@@ -21,37 +21,37 @@ graphiti_core/llm_client/openai_client.py,sha256=xLkbpusRVFRK0zPr3kOqY31HK_XCXrp
 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=0T1OSSQeP63OjoMTrscqVhq0gNRRxh3-n1sNxo0kTJE,2102
+graphiti_core/models/edges/edge_db_queries.py,sha256=2UoLkmazO-FJYqjc3g0LuL-pyjekzQxxed_XHVv_HZE,2671
 graphiti_core/models/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/models/nodes/node_db_queries.py,sha256=zIEKhodGOEYQ2ZdH766t-QRSk2xZNmtmAaPv60pvepM,1688
-graphiti_core/nodes.py,sha256=xlObDAC6Osp6L0wwqREuzBlIFlOzuUs9lN3ZpIv4seM,13844
+graphiti_core/models/nodes/node_db_queries.py,sha256=I0top_N23FN0U5ZbypaS5IXvtfx2zgJmKUCT_7mpUdo,2257
+graphiti_core/nodes.py,sha256=sIEa8QzF2w-qlxUakISoVb8oRsntc4xDU90q0kO9_pk,13866
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
-graphiti_core/prompts/dedupe_edges.py,sha256=DUNHdIudj50FAjkla4nc68tSFSD2yjmYHBw-Bb7ph20,6529
-graphiti_core/prompts/dedupe_nodes.py,sha256=BZ9S-PB9SSGjc5Oo8ivdgA6rZx3OGOFhKtwrBlQ0bm0,7269
+graphiti_core/prompts/dedupe_edges.py,sha256=7jff4x60p6x8K1Oy7EN8twdOvsTt67_SwoF-lvf2c-8,3539
+graphiti_core/prompts/dedupe_nodes.py,sha256=_2zD0VcygH1Sut3FwRrKSBALFaxhnnO3JOFJkwHhEVo,4130
 graphiti_core/prompts/eval.py,sha256=9gavc4SKAPdsrhpN8NEUTc632erkaifyOf0hevmdeKY,3657
-graphiti_core/prompts/extract_edge_dates.py,sha256=pb5Oe5WTZ468REmWNR2NAEHHYMt5GpiJVUAqpVI3aBI,3622
-graphiti_core/prompts/extract_edges.py,sha256=pGmYcl1zKIuu-HmHUkbkThJ5QKED3efMtDlKoT0wBRM,5448
-graphiti_core/prompts/extract_nodes.py,sha256=VIr0Nh0mSiodI3iGOQFszh7DOni4mufOKJDuGkMysl8,6889
+graphiti_core/prompts/extract_edge_dates.py,sha256=fg5CPofLIuPR6x15ED4vwZQeRMcdfNrr1GDy_GTnfxg,3785
+graphiti_core/prompts/extract_edges.py,sha256=6dVIKDxht5eQ3jlCRojUj0fZKtF_w-1ONmSlrpZ25uM,3461
+graphiti_core/prompts/extract_nodes.py,sha256=OJ9zzU3VuuQXloNxDnn_BDB9z2lzpy8dL5O02ODNpzI,5494
 graphiti_core/prompts/invalidate_edges.py,sha256=2vhi9TsL9poAHqApfk_Us0VveG0-T8cZymfBwOgA8tc,4341
 graphiti_core/prompts/lib.py,sha256=ZOE6nNoI_wQ12Sufx7rQkQtkIm_eTAL7pCiYGU2hcMI,4054
 graphiti_core/prompts/models.py,sha256=cvx_Bv5RMFUD_5IUawYrbpOKLPHogai7_bm7YXrSz84,867
-graphiti_core/prompts/summarize_nodes.py,sha256=FLuZpGTABgcxuIDkx_IKH115nHEw0rIaFhcGlWveAMc,2357
+graphiti_core/prompts/summarize_nodes.py,sha256=lNpagCq6Pz71vipBonQZUxBZG6OY4bQbyGZ5UEgdL4s,3488
 graphiti_core/py.typed,sha256=vlmmzQOt7bmeQl9L3XJP4W6Ry0iiELepnOrinKz5KQg,79
 graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/search/search.py,sha256=Fz45sXToQ6KN_y2k94kg9UyUZeqsS14jfaGfQ5KGifQ,11176
+graphiti_core/search/search.py,sha256=qkiAZCYhKhTkzyGuSH9j_W2Kz60TGyhLM1hZNCaCeUs,11996
 graphiti_core/search/search_config.py,sha256=UZN8jFA4pBlw2O5N1cuhVRBdTwMLR9N3Oyo6sQ4MDVw,3117
-graphiti_core/search/search_config_recipes.py,sha256=20jS7veJExDnXA-ovJSUJfyDHKt7GW-nng-eoiT7ATA,5810
-graphiti_core/search/search_utils.py,sha256=gqBlhnb75srhymQ4_yzb7o019UxtE3e7eHHK9NL6nCc,22916
+graphiti_core/search/search_config_recipes.py,sha256=yUqiLnn9vFg39M8eVwjVKfBCL_ptGrfDMQ47m_Blb0g,6885
+graphiti_core/search/search_utils.py,sha256=8Ro90L7fqtw5tsdusIhS_pdYcLX2JVIDiH5dD04G7ug,22968
 graphiti_core/utils/__init__.py,sha256=cJAcMnBZdHBQmWrZdU1PQ1YmaL75bhVUkyVpIPuOyns,260
-graphiti_core/utils/bulk_utils.py,sha256=azn8xlUT9u5-CFDkLSAY4y5zt5uvOvKBzatZZKDvp1g,13994
+graphiti_core/utils/bulk_utils.py,sha256=AMi42deCXjIIgdpLEiD5SYCMZfX8XKoOsVYEwXVTX5A,14016
 graphiti_core/utils/maintenance/__init__.py,sha256=TRY3wWWu5kn3Oahk_KKhltrWnh0NACw0FskjqF6OtlA,314
-graphiti_core/utils/maintenance/community_operations.py,sha256=Ltx8cQJcFDXcQs17lHDkh2r3qmJalzpRdA3Azl2U3m8,9804
-graphiti_core/utils/maintenance/edge_operations.py,sha256=htG9h32u0O1g7ZdR-jFSHuzDgiO4MChYJsNuvrRMTu8,11270
+graphiti_core/utils/maintenance/community_operations.py,sha256=a2ICCNwEognGx2oBL43Y6R4nNZYo-6Siia2kDVlwu_U,9838
+graphiti_core/utils/maintenance/edge_operations.py,sha256=3VkyKfMPwH0ziCQRRsnmnCZXMSfOh2vFhBJSL3JEljU,12387
 graphiti_core/utils/maintenance/graph_data_operations.py,sha256=w66_SLlvPapuG91YGGfR3bG2sM6cJ2XPHIaxM0slAdE,6526
-graphiti_core/utils/maintenance/node_operations.py,sha256=h5nlRojbXOGJs-alpv6z6WnZ1UCixVGlAQYBQUqz8Bs,9030
+graphiti_core/utils/maintenance/node_operations.py,sha256=m0q-PPCI5LM0dZMkrcyUENw6WfDBMO61DQ7S6MuNQ8E,11624
 graphiti_core/utils/maintenance/temporal_operations.py,sha256=MvaRLWrBlDeYw8CQrKish1xbYcY5ovpfdqA2hSX7v5k,3367
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core-0.3.20.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.3.20.dist-info/METADATA,sha256=8blBjJ96r7tU5KvPdExNKHuIgknP-EGuGlXPHW1UlPk,9990
-graphiti_core-0.3.20.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.3.20.dist-info/RECORD,,
+graphiti_core-0.4.0.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.4.0.dist-info/METADATA,sha256=URZ0gW5i_Q9aOe5M60tsxFsYbAwqoW7HJc8oVyrzuFk,10058
+graphiti_core-0.4.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.4.0.dist-info/RECORD,,