graphiti-core 0.24.3__py3-none-any.whl → 0.25.3__py3-none-any.whl

graphiti_core/utils/maintenance/edge_operations.py

@@ -29,13 +29,13 @@ from graphiti_core.edges import (
     create_entity_edge_embeddings,
 )
 from graphiti_core.graphiti_types import GraphitiClients
-from graphiti_core.helpers import MAX_REFLEXION_ITERATIONS, semaphore_gather
+from graphiti_core.helpers import semaphore_gather
 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
-from graphiti_core.prompts.extract_edges import ExtractedEdges, MissingFacts
+from graphiti_core.prompts.extract_edges import ExtractedEdges
 from graphiti_core.search.search import search
 from graphiti_core.search.search_config import SearchResults
 from graphiti_core.search.search_config_recipes import EDGE_HYBRID_SEARCH_RRF
@@ -94,6 +94,7 @@ async def extract_edges(
     edge_type_map: dict[tuple[str, str], list[str]],
     group_id: str = '',
     edge_types: dict[str, type[BaseModel]] | None = None,
+    custom_extraction_instructions: str | None = None,
 ) -> list[EntityEdge]:
     start = time()
 
@@ -129,42 +130,17 @@ async def extract_edges(
         'previous_episodes': [ep.content for ep in previous_episodes],
         'reference_time': episode.valid_at,
         'edge_types': edge_types_context,
-        'custom_prompt': '',
+        'custom_extraction_instructions': custom_extraction_instructions or '',
     }
 
-    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),
-            response_model=ExtractedEdges,
-            max_tokens=extract_edges_max_tokens,
-            group_id=group_id,
-            prompt_name='extract_edges.edge',
-        )
-        edges_data = ExtractedEdges(**llm_response).edges
-
-        context['extracted_facts'] = [edge_data.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),
-                response_model=MissingFacts,
-                max_tokens=extract_edges_max_tokens,
-                group_id=group_id,
-                prompt_name='extract_edges.reflexion',
-            )
-
-            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
+    llm_response = await llm_client.generate_response(
+        prompt_library.extract_edges.edge(context),
+        response_model=ExtractedEdges,
+        max_tokens=extract_edges_max_tokens,
+        group_id=group_id,
+        prompt_name='extract_edges.edge',
+    )
+    edges_data = ExtractedEdges(**llm_response).edges
 
     end = time()
     logger.debug(f'Extracted new edges: {edges_data} in {(end - start) * 1000} ms')
@@ -313,6 +289,20 @@ async def resolve_extracted_edges(
     # Build entity hash table
     uuid_entity_map: dict[str, EntityNode] = {entity.uuid: entity for entity in entities}
 
+    # Collect all node UUIDs referenced by edges that are not in the entities list
+    referenced_node_uuids = set()
+    for extracted_edge in extracted_edges:
+        if extracted_edge.source_node_uuid not in uuid_entity_map:
+            referenced_node_uuids.add(extracted_edge.source_node_uuid)
+        if extracted_edge.target_node_uuid not in uuid_entity_map:
+            referenced_node_uuids.add(extracted_edge.target_node_uuid)
+
+    # Fetch missing nodes from the database
+    if referenced_node_uuids:
+        missing_nodes = await EntityNode.get_by_uuids(driver, list(referenced_node_uuids))
+        for node in missing_nodes:
+            uuid_entity_map[node.uuid] = node
+
     # Determine which edge types are relevant for each edge.
     # `edge_types_lst` stores the subset of custom edge definitions whose
     # node signature matches each extracted edge. Anything outside this subset

graphiti_core/utils/maintenance/node_operations.py

@@ -22,7 +22,7 @@ from typing import Any
 from pydantic import BaseModel
 
 from graphiti_core.graphiti_types import GraphitiClients
-from graphiti_core.helpers import MAX_REFLEXION_ITERATIONS, semaphore_gather
+from graphiti_core.helpers import semaphore_gather
 from graphiti_core.llm_client import LLMClient
 from graphiti_core.llm_client.config import ModelSize
 from graphiti_core.nodes import (
@@ -43,6 +43,12 @@ from graphiti_core.search.search import search
 from graphiti_core.search.search_config import SearchResults
 from graphiti_core.search.search_config_recipes import NODE_HYBRID_SEARCH_RRF
 from graphiti_core.search.search_filters import SearchFilters
+from graphiti_core.utils.content_chunking import (
+    chunk_json_content,
+    chunk_message_content,
+    chunk_text_content,
+    should_chunk,
+)
 from graphiti_core.utils.datetime_utils import utc_now
 from graphiti_core.utils.maintenance.dedup_helpers import (
     DedupCandidateIndexes,
@@ -91,24 +97,67 @@ async def extract_nodes(
     previous_episodes: list[EpisodicNode],
     entity_types: dict[str, type[BaseModel]] | None = None,
     excluded_entity_types: list[str] | None = None,
+    custom_extraction_instructions: str | None = None,
 ) -> list[EntityNode]:
+    """Extract entity nodes from an episode with adaptive chunking.
+
+    For high-density content (many entities per token), the content is chunked
+    and processed in parallel to avoid LLM timeouts and truncation issues.
+    """
     start = time()
     llm_client = clients.llm_client
-    llm_response = {}
-    custom_prompt = ''
-    entities_missed = True
-    reflexion_iterations = 0
 
+    # Build entity types context
+    entity_types_context = _build_entity_types_context(entity_types)
+
+    # Build base context
+    context = {
+        'episode_content': episode.content,
+        'episode_timestamp': episode.valid_at.isoformat(),
+        'previous_episodes': [ep.content for ep in previous_episodes],
+        'custom_extraction_instructions': custom_extraction_instructions or '',
+        'entity_types': entity_types_context,
+        'source_description': episode.source_description,
+    }
+
+    # Check if chunking is needed (based on entity density)
+    if should_chunk(episode.content, episode.source):
+        extracted_entities = await _extract_nodes_chunked(llm_client, episode, context)
+    else:
+        extracted_entities = await _extract_nodes_single(llm_client, episode, context)
+
+    # Filter empty names
+    filtered_entities = [e for e in extracted_entities if e.name.strip()]
+
+    end = time()
+    logger.debug(f'Extracted {len(filtered_entities)} entities in {(end - start) * 1000:.0f} ms')
+
+    # Convert to EntityNode objects
+    extracted_nodes = _create_entity_nodes(
+        filtered_entities, entity_types_context, excluded_entity_types, episode
+    )
+
+    logger.debug(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
+    return extracted_nodes
+
+
+def _build_entity_types_context(
+    entity_types: dict[str, type[BaseModel]] | None,
+) -> list[dict]:
+    """Build entity types context with ID mappings."""
     entity_types_context = [
         {
             'entity_type_id': 0,
             'entity_type_name': 'Entity',
-            'entity_type_description': 'Default entity classification. Use this entity type if the entity is not one of the other listed types.',
+            'entity_type_description': (
+                'Default entity classification. Use this entity type '
+                'if the entity is not one of the other listed types.'
+            ),
         }
     ]
 
-    entity_types_context += (
-        [
+    if entity_types is not None:
+        entity_types_context += [
             {
                 'entity_type_id': i + 1,
                 'entity_type_name': type_name,
@@ -116,73 +165,124 @@ async def extract_nodes(
             }
             for i, (type_name, type_model) in enumerate(entity_types.items())
         ]
-        if entity_types is not None
-        else []
+
+    return entity_types_context
+
+
+async def _extract_nodes_single(
+    llm_client: LLMClient,
+    episode: EpisodicNode,
+    context: dict,
+) -> list[ExtractedEntity]:
+    """Extract entities using a single LLM call."""
+    llm_response = await _call_extraction_llm(llm_client, episode, context)
+    response_object = ExtractedEntities(**llm_response)
+    return response_object.extracted_entities
+
+
+async def _extract_nodes_chunked(
+    llm_client: LLMClient,
+    episode: EpisodicNode,
+    context: dict,
+) -> list[ExtractedEntity]:
+    """Extract entities from large content using chunking."""
+    # Chunk the content based on episode type
+    if episode.source == EpisodeType.json:
+        chunks = chunk_json_content(episode.content)
+    elif episode.source == EpisodeType.message:
+        chunks = chunk_message_content(episode.content)
+    else:
+        chunks = chunk_text_content(episode.content)
+
+    logger.debug(f'Chunked content into {len(chunks)} chunks for entity extraction')
+
+    # Extract entities from each chunk in parallel
+    chunk_results = await semaphore_gather(
+        *[_extract_from_chunk(llm_client, chunk, context, episode) for chunk in chunks]
     )
 
-    context = {
-        'episode_content': episode.content,
-        'episode_timestamp': episode.valid_at.isoformat(),
-        'previous_episodes': [ep.content for ep in previous_episodes],
-        'custom_prompt': custom_prompt,
-        'entity_types': entity_types_context,
-        'source_description': episode.source_description,
-    }
+    # Merge and deduplicate entities across chunks
+    merged_entities = _merge_extracted_entities(chunk_results)
+    logger.debug(
+        f'Merged {sum(len(r) for r in chunk_results)} entities into {len(merged_entities)} unique'
+    )
 
-    while entities_missed and reflexion_iterations <= MAX_REFLEXION_ITERATIONS:
-        if episode.source == EpisodeType.message:
-            llm_response = await llm_client.generate_response(
-                prompt_library.extract_nodes.extract_message(context),
-                response_model=ExtractedEntities,
-                group_id=episode.group_id,
-                prompt_name='extract_nodes.extract_message',
-            )
-        elif episode.source == EpisodeType.text:
-            llm_response = await llm_client.generate_response(
-                prompt_library.extract_nodes.extract_text(context),
-                response_model=ExtractedEntities,
-                group_id=episode.group_id,
-                prompt_name='extract_nodes.extract_text',
-            )
-        elif episode.source == EpisodeType.json:
-            llm_response = await llm_client.generate_response(
-                prompt_library.extract_nodes.extract_json(context),
-                response_model=ExtractedEntities,
-                group_id=episode.group_id,
-                prompt_name='extract_nodes.extract_json',
-            )
+    return merged_entities
 
-        response_object = ExtractedEntities(**llm_response)
 
-        extracted_entities: list[ExtractedEntity] = response_object.extracted_entities
+async def _extract_from_chunk(
+    llm_client: LLMClient,
+    chunk: str,
+    base_context: dict,
+    episode: EpisodicNode,
+) -> list[ExtractedEntity]:
+    """Extract entities from a single chunk."""
+    chunk_context = {**base_context, 'episode_content': chunk}
+    llm_response = await _call_extraction_llm(llm_client, episode, chunk_context)
+    return ExtractedEntities(**llm_response).extracted_entities
 
-        reflexion_iterations += 1
-        if reflexion_iterations < MAX_REFLEXION_ITERATIONS:
-            missing_entities = await extract_nodes_reflexion(
-                llm_client,
-                episode,
-                previous_episodes,
-                [entity.name for entity in extracted_entities],
-                episode.group_id,
-            )
 
-            entities_missed = len(missing_entities) != 0
+async def _call_extraction_llm(
+    llm_client: LLMClient,
+    episode: EpisodicNode,
+    context: dict,
+) -> dict:
+    """Call the appropriate extraction prompt based on episode type."""
+    if episode.source == EpisodeType.message:
+        prompt = prompt_library.extract_nodes.extract_message(context)
+        prompt_name = 'extract_nodes.extract_message'
+    elif episode.source == EpisodeType.text:
+        prompt = prompt_library.extract_nodes.extract_text(context)
+        prompt_name = 'extract_nodes.extract_text'
+    elif episode.source == EpisodeType.json:
+        prompt = prompt_library.extract_nodes.extract_json(context)
+        prompt_name = 'extract_nodes.extract_json'
+    else:
+        # Fallback to text extraction
+        prompt = prompt_library.extract_nodes.extract_text(context)
+        prompt_name = 'extract_nodes.extract_text'
+
+    return await llm_client.generate_response(
+        prompt,
+        response_model=ExtractedEntities,
+        group_id=episode.group_id,
+        prompt_name=prompt_name,
+    )
 
-            custom_prompt = 'Make sure that the following entities are extracted: '
-            for entity in missing_entities:
-                custom_prompt += f'\n{entity},'
 
-    filtered_extracted_entities = [entity for entity in extracted_entities if entity.name.strip()]
-    end = time()
-    logger.debug(f'Extracted new nodes: {filtered_extracted_entities} in {(end - start) * 1000} ms')
-    # Convert the extracted data into EntityNode objects
+def _merge_extracted_entities(
+    chunk_results: list[list[ExtractedEntity]],
+) -> list[ExtractedEntity]:
+    """Merge entities from multiple chunks, deduplicating by normalized name.
+
+    When duplicates occur, prefer the first occurrence (maintains ordering).
+    """
+    seen_names: set[str] = set()
+    merged: list[ExtractedEntity] = []
+
+    for entities in chunk_results:
+        for entity in entities:
+            normalized = entity.name.strip().lower()
+            if normalized and normalized not in seen_names:
+                seen_names.add(normalized)
+                merged.append(entity)
+
+    return merged
+
+
+def _create_entity_nodes(
+    extracted_entities: list[ExtractedEntity],
+    entity_types_context: list[dict],
+    excluded_entity_types: list[str] | None,
+    episode: EpisodicNode,
+) -> list[EntityNode]:
+    """Convert ExtractedEntity objects to EntityNode objects."""
     extracted_nodes = []
-    for extracted_entity in filtered_extracted_entities:
+
+    for extracted_entity in extracted_entities:
         type_id = extracted_entity.entity_type_id
         if 0 <= type_id < len(entity_types_context):
-            entity_type_name = entity_types_context[extracted_entity.entity_type_id].get(
-                'entity_type_name'
-            )
+            entity_type_name = entity_types_context[type_id].get('entity_type_name')
         else:
             entity_type_name = 'Entity'
 
@@ -203,8 +303,6 @@ async def extract_nodes(
         extracted_nodes.append(new_node)
         logger.debug(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
 
-    logger.debug(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
-
     return extracted_nodes
 
 

{graphiti_core-0.24.3.dist-info → graphiti_core-0.25.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.24.3
+Version: 0.25.3
 Summary: A temporal graph building library
 Project-URL: Homepage, https://help.getzep.com/graphiti/graphiti/overview
 Project-URL: Repository, https://github.com/getzep/graphiti
@@ -132,7 +132,7 @@ while handling changing relationships and maintaining historical context.
 
 ## Graphiti and Zep's Context Engineering Platform.
 
-Graphiti powers the core of [Zep](https://www.getzep.com), a turn-key context engineering platform for AI Agents. Zep
+Graphiti powers the core of [Zep's context engineering platform](https://www.getzep.com) for AI Agents. Zep
 offers agent memory, Graph RAG for dynamic data, and context retrieval and assembly.
 
 Using Graphiti, we've demonstrated Zep is

{graphiti_core-0.24.3.dist-info → graphiti_core-0.25.3.dist-info}/RECORD

@@ -3,9 +3,9 @@ graphiti_core/decorators.py,sha256=tqSICazrXEzQ96MXKbnl_07Y7ah8OuH8rJqRKEOC0q8,4
 graphiti_core/edges.py,sha256=JZZGo6G2HTYv-aaE-s8P7yIXkdHaNqg5UGGPDV4nZOI,20201
 graphiti_core/errors.py,sha256=cH_v9TPgEPeQE6GFOHIg5TvejpUCBddGarMY2Whxbwc,2707
 graphiti_core/graph_queries.py,sha256=ZWMqAo5pwb8PO5ddg4zZ0ArhHWuWV42g3R9ULIxsHOs,8058
-graphiti_core/graphiti.py,sha256=6HsRHx5CFe7D6XhJ_53pVQr5UJlDM-G1QPzUOKklSQE,47700
+graphiti_core/graphiti.py,sha256=KEG-Kdh9OrFAj4f81nTaA25BHBMGfUeqWOBGPyLFIHo,49893
 graphiti_core/graphiti_types.py,sha256=_v-XsMgV-bBbi5P-PoRVyGJEdHEDJR-Khmv4cU0oZ-4,1094
-graphiti_core/helpers.py,sha256=q8kbL9gz8igdlh-oMUS-ylUyeMlXZb-ccf-HQkrES_0,5184
+graphiti_core/helpers.py,sha256=5IsSYXylLjyKVg83DQB7eKBRQ49PbL7AEOQEGZqY3Jg,6258
 graphiti_core/nodes.py,sha256=W_Lx0x3YbJoNRVDGO2Mf9s3MwDFu2NolQl-15jFpr0U,27383
 graphiti_core/py.typed,sha256=vlmmzQOt7bmeQl9L3XJP4W6Ry0iiELepnOrinKz5KQg,79
 graphiti_core/tracer.py,sha256=5L05H8PdJ1eqhmcHuYTtwMThVGVUdUzTdiFd_-07H4E,6149
@@ -18,7 +18,7 @@ graphiti_core/driver/__init__.py,sha256=kCWimqQU19airu5gKwCmZtZuXkDfaQfKSUhMDoL-
 graphiti_core/driver/driver.py,sha256=BmsOrUoUqfdgd3487Vs4WJtl_srSL-szxGRtVBGUeJc,3789
 graphiti_core/driver/falkordb_driver.py,sha256=siztncHLSMqn-GbxkW5y2ybS6kEpjrV_2ZTb9t7FSIg,12877
 graphiti_core/driver/kuzu_driver.py,sha256=SZfbRffC0hz1i5Xnlkx79Z_o4iNKf4barrxdlfrmBgo,5775
-graphiti_core/driver/neo4j_driver.py,sha256=mnsAStRAid9Y47-_vW0ccCDV6q48SvVgVjMFUxNkgRc,3893
+graphiti_core/driver/neo4j_driver.py,sha256=QDuQ8TXgqAvUEaaYRVRc_ftpIlSvJ7RxSB5BX21CRtk,4590
 graphiti_core/driver/neptune_driver.py,sha256=9-MHqgE-Iobzyk1OYO_R1o0AplueSyG25uFYhnCeZi8,11517
 graphiti_core/driver/graph_operations/graph_operations.py,sha256=9Qxs4za1kUNnpGzkO_z2zX4wPvYq6KWan30WlCH-vw8,5284
 graphiti_core/driver/search_interface/search_interface.py,sha256=-lnPsXdv_4feULbOnuWUQN2wmLqcUkGMwmR74jaFyMI,2500
@@ -36,8 +36,8 @@ graphiti_core/llm_client/config.py,sha256=pivp29CDIbDPqgw5NF9Ok2AwcqTV5z5_Q1bgNs
 graphiti_core/llm_client/errors.py,sha256=pn6brRiLW60DAUIXJYKBT6MInrS4ueuH1hNLbn_JbQo,1243
 graphiti_core/llm_client/gemini_client.py,sha256=xRYeFXhNfzwt2o__Qv5-rCxuub-4-hgvQpaawEhsN0c,18746
 graphiti_core/llm_client/groq_client.py,sha256=bYLE_cg1QEhugsJOXh4b1vPbxagKeMWqk48240GCzMs,2922
-graphiti_core/llm_client/openai_base_client.py,sha256=GY4PIOFeLSFEIBowxk0JJ5LwiXdnDYpYxIWPZclOlXY,10064
-graphiti_core/llm_client/openai_client.py,sha256=rNLhYJobsDMa4awO0HgPpePdqKjdDZc-K3WCMlONUtw,4235
+graphiti_core/llm_client/openai_base_client.py,sha256=ZjPiYh9vyrNrkgVHjZoSUH0JgcX7tVzZGf4kK9w6Upk,10068
+graphiti_core/llm_client/openai_client.py,sha256=tijw92l6cgbGv2ES-aVhCH1OB_9h7CZExnQ0799c3uE,4563
 graphiti_core/llm_client/openai_generic_client.py,sha256=9cXfGQxAxD8hQOXoHTKiPbqKgHzzneaJCgE_WAJ4zzM,8606
 graphiti_core/llm_client/utils.py,sha256=zKpxXEbKa369m4W7RDEf-m56kH46V1Mx3RowcWZEWWs,1000
 graphiti_core/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,8 +51,8 @@ graphiti_core/prompts/dedupe_edges.py,sha256=nikgVW2P53MtOlT_ycTUyViu2eHFJm2EmQa
 graphiti_core/prompts/dedupe_nodes.py,sha256=uQrMPAr019KVUzbOslP3VDLaDG4tXp_BqWEtoY0OHbw,8836
 graphiti_core/prompts/eval.py,sha256=GWFkfZoPfY8U7mV8Ngd_5a2S2fHS7KjajChntxv1UEY,5360
 graphiti_core/prompts/extract_edge_dates.py,sha256=3Drs3CmvP0gJN5BidWSxrNvLet3HPoTybU3BUIAoc0Y,4218
-graphiti_core/prompts/extract_edges.py,sha256=8grBkWBKQXFjUZgUiLSu8c0PMs2v7e-WvJmMQcXxFpk,7073
-graphiti_core/prompts/extract_nodes.py,sha256=4424s6Q0617vna1pYfoO4b_nVB4GMZj6LDiqA5cOrq0,10915
+graphiti_core/prompts/extract_edges.py,sha256=BjhnuCrfcCZLQMyPTOmmIfVQwMIDFTe96OaqGYWcR28,7090
+graphiti_core/prompts/extract_nodes.py,sha256=25wStOkbi9kji9j0QSepnqKuyxxcRoqqWrX0KVPSUcc,10966
 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
@@ -63,24 +63,25 @@ graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 graphiti_core/search/search.py,sha256=pSfyLJDRAv6yF9-A5l43bt0GvtHgCeVQbKQ5XBqDAzU,18436
 graphiti_core/search/search_config.py,sha256=Q7vFALFqgU-IsDYbGjzcLlHzVIB0ieunPKQHpsk1IVc,5276
 graphiti_core/search/search_config_recipes.py,sha256=4GquRphHhJlpXQhAZOySYnCzBWYoTwxlJj44eTOavZQ,7443
-graphiti_core/search/search_filters.py,sha256=cBp88VvlEsmfiNnXAZG3GleFt8mglQAbttGWYJQos28,9269
+graphiti_core/search/search_filters.py,sha256=QB6-PrH-4CyvkG2B6FFRtsYNEFvL9NTq5IHtbsAjuKs,9305
 graphiti_core/search/search_helpers.py,sha256=oty-IHVPf_0HxXsSGx21iPML9hMACDcECmdhkGltmVg,2691
 graphiti_core/search/search_utils.py,sha256=vT0G62T6JXE9bqRJFeLg4dKcHVtJpIOGkmufuvBHw28,71754
 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=LijfbnUgNfH8BF6DFnmF1YvmKnOIjkJFbcTXo3udzhM,19816
+graphiti_core/utils/content_chunking.py,sha256=T4397f6e4bumXraD0Zi7vTazbsb1mlw383cu7oVLO9w,22173
 graphiti_core/utils/datetime_utils.py,sha256=J-zYSq7-H-2n9hYOXNIun12kM10vNX9mMATGR_egTmY,1806
 graphiti_core/utils/text_utils.py,sha256=eHGJwW0jX1CHWBrQy86-KQ-KguzRBNdaLa8zmq8a6bo,1687
 graphiti_core/utils/maintenance/__init__.py,sha256=vW4H1KyapTl-OOz578uZABYcpND4wPx3Vt6aAPaXh78,301
 graphiti_core/utils/maintenance/community_operations.py,sha256=OzNo9DW47YWTy67aoq91wRgnKWVelOYduaJpIERdPFY,10803
 graphiti_core/utils/maintenance/dedup_helpers.py,sha256=B7k6KkB6Sii8PZCWNNTvsNiy4BNTNWpoLeGgrPLq6BE,9220
-graphiti_core/utils/maintenance/edge_operations.py,sha256=KuBPlFXHnlWM7smLOfaM-ExhPdlakLdyJV4cxO9U4tI,27187
+graphiti_core/utils/maintenance/edge_operations.py,sha256=YDqmYKSkauQPPW3eXamJMw6G2-bwIavZuBmkqzYmW_M,26907
 graphiti_core/utils/maintenance/graph_data_operations.py,sha256=vZ1kazYBC-ZRysb13CDFfhoiEH_K_DOW_vfEp1JXEnc,3997
-graphiti_core/utils/maintenance/node_operations.py,sha256=70G-Kf1mQJ_9XTi9MJmq5dqC28VJHRxkoAwgMRx4Gvo,20143
+graphiti_core/utils/maintenance/node_operations.py,sha256=ji1uRD8oWAopUnO3OHL0h_iRIF41wwucNBrOH-Bg9q8,23100
 graphiti_core/utils/maintenance/temporal_operations.py,sha256=LWMw8D8-XOZkl412QKa5qOe9vsX_kOhis_dZlwSXY14,3539
 graphiti_core/utils/ontology_utils/entity_types_utils.py,sha256=4eVgxLWY6Q8k9cRJ5pW59IYF--U4nXZsZIGOVb_yHfQ,1285
-graphiti_core-0.24.3.dist-info/METADATA,sha256=9imUX3fGZvz93AlJH_rKUVH7csX5e6SkMiM4hjKFdZc,27853
-graphiti_core-0.24.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-graphiti_core-0.24.3.dist-info/licenses/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.24.3.dist-info/RECORD,,
+graphiti_core-0.25.3.dist-info/METADATA,sha256=3yAWbzq6O3pmaKV9E4vYgt7A6oCuA3TjK9TobD2ylmk,27843
+graphiti_core-0.25.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+graphiti_core-0.25.3.dist-info/licenses/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.25.3.dist-info/RECORD,,