graphiti-core 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

graphiti_core/utils/maintenance/edge_operations.py

@@ -24,6 +24,10 @@ from graphiti_core.edges import EntityEdge, EpisodicEdge
 from graphiti_core.llm_client import LLMClient
 from graphiti_core.nodes import EntityNode, EpisodicNode
 from graphiti_core.prompts import prompt_library
+from graphiti_core.utils.maintenance.temporal_operations import (
+    extract_edge_dates,
+    get_edge_contradictions,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -33,15 +37,15 @@ def build_episodic_edges(
     episode: EpisodicNode,
     created_at: datetime,
 ) -> List[EpisodicEdge]:
-    edges: List[EpisodicEdge] = []
-
-    for node in entity_nodes:
-        edge = EpisodicEdge(
+    edges: List[EpisodicEdge] = [
+        EpisodicEdge(
             source_node_uuid=episode.uuid,
             target_node_uuid=node.uuid,
             created_at=created_at,
+            group_id=episode.group_id,
         )
-        edges.append(edge)
+        for node in entity_nodes
+    ]
 
     return edges
 
@@ -51,6 +55,7 @@ async def extract_edges(
     episode: EpisodicNode,
     nodes: list[EntityNode],
     previous_episodes: list[EpisodicNode],
+    group_id: str | None,
 ) -> list[EntityEdge]:
     start = time()
 
@@ -84,6 +89,7 @@ async def extract_edges(
                 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(),
@@ -149,28 +155,110 @@ async def dedupe_extracted_edges(
 async def resolve_extracted_edges(
     llm_client: LLMClient,
     extracted_edges: list[EntityEdge],
+    related_edges_lists: list[list[EntityEdge]],
     existing_edges_lists: list[list[EntityEdge]],
-) -> list[EntityEdge]:
-    resolved_edges: list[EntityEdge] = list(
+    current_episode: EpisodicNode,
+    previous_episodes: list[EpisodicNode],
+) -> tuple[list[EntityEdge], list[EntityEdge]]:
+    # resolve edges with related edges in the graph, extract temporal information, and find invalidation candidates
+    results: list[tuple[EntityEdge, list[EntityEdge]]] = list(
         await asyncio.gather(
             *[
-                resolve_extracted_edge(llm_client, extracted_edge, existing_edges)
-                for extracted_edge, existing_edges in zip(extracted_edges, existing_edges_lists)
+                resolve_extracted_edge(
+                    llm_client,
+                    extracted_edge,
+                    related_edges,
+                    existing_edges,
+                    current_episode,
+                    previous_episodes,
+                )
+                for extracted_edge, related_edges, existing_edges in zip(
+                    extracted_edges, related_edges_lists, existing_edges_lists
+                )
             ]
         )
     )
 
-    return resolved_edges
+    resolved_edges: list[EntityEdge] = []
+    invalidated_edges: list[EntityEdge] = []
+    for result in results:
+        resolved_edge = result[0]
+        invalidated_edge_chunk = result[1]
+
+        resolved_edges.append(resolved_edge)
+        invalidated_edges.extend(invalidated_edge_chunk)
+
+    return resolved_edges, invalidated_edges
 
 
 async def resolve_extracted_edge(
-    llm_client: LLMClient, extracted_edge: EntityEdge, existing_edges: list[EntityEdge]
+    llm_client: LLMClient,
+    extracted_edge: EntityEdge,
+    related_edges: list[EntityEdge],
+    existing_edges: list[EntityEdge],
+    current_episode: EpisodicNode,
+    previous_episodes: list[EpisodicNode],
+) -> tuple[EntityEdge, list[EntityEdge]]:
+    resolved_edge, (valid_at, invalid_at), invalidation_candidates = await asyncio.gather(
+        dedupe_extracted_edge(llm_client, extracted_edge, related_edges),
+        extract_edge_dates(llm_client, extracted_edge, current_episode, previous_episodes),
+        get_edge_contradictions(llm_client, extracted_edge, existing_edges),
+    )
+
+    now = datetime.now()
+
+    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
+    if invalid_at is not None and resolved_edge.expired_at is None:
+        resolved_edge.expired_at = now
+
+    # Determine if the new_edge needs to be expired
+    if resolved_edge.expired_at is None:
+        invalidation_candidates.sort(key=lambda c: (c.valid_at is None, c.valid_at))
+        for candidate in invalidation_candidates:
+            if (
+                candidate.valid_at is not None and resolved_edge.valid_at is not None
+            ) and candidate.valid_at > resolved_edge.valid_at:
+                # Expire new edge since we have information about more recent events
+                resolved_edge.invalid_at = candidate.valid_at
+                resolved_edge.expired_at = now
+                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)
+
+    return resolved_edge, invalidated_edges
+
+
+async def dedupe_extracted_edge(
+    llm_client: LLMClient, extracted_edge: EntityEdge, related_edges: list[EntityEdge]
 ) -> EntityEdge:
     start = time()
 
     # Prepare context for LLM
-    existing_edges_context = [
-        {'uuid': edge.uuid, 'name': edge.name, 'fact': edge.fact} for edge in existing_edges
+    related_edges_context = [
+        {'uuid': edge.uuid, 'name': edge.name, 'fact': edge.fact} for edge in related_edges
     ]
 
     extracted_edge_context = {
@@ -180,7 +268,7 @@ async def resolve_extracted_edge(
     }
 
     context = {
-        'existing_edges': existing_edges_context,
+        'related_edges': related_edges_context,
         'extracted_edges': extracted_edge_context,
     }
 
@@ -191,14 +279,14 @@ async def resolve_extracted_edge(
 
     edge = extracted_edge
     if is_duplicate:
-        for existing_edge in existing_edges:
+        for existing_edge in related_edges:
             if existing_edge.uuid != uuid:
                 continue
             edge = existing_edge
 
     end = time()
     logger.info(
-        f'Resolved node: {extracted_edge.name} is {edge.name}, in {(end - start) * 1000} ms'
+        f'Resolved Edge: {extracted_edge.name} is {edge.name}, in {(end - start) * 1000} ms'
     )
 
     return edge

graphiti_core/utils/maintenance/graph_data_operations.py

@@ -34,6 +34,10 @@ async def build_indices_and_constraints(driver: AsyncDriver):
         'CREATE INDEX episode_uuid IF NOT EXISTS FOR (n:Episodic) ON (n.uuid)',
         'CREATE INDEX relation_uuid IF NOT EXISTS FOR ()-[e:RELATES_TO]-() ON (e.uuid)',
         'CREATE INDEX mention_uuid IF NOT EXISTS FOR ()-[e:MENTIONS]-() ON (e.uuid)',
+        'CREATE INDEX entity_group_id IF NOT EXISTS FOR (n:Entity) ON (n.group_id)',
+        'CREATE INDEX episode_group_id IF NOT EXISTS FOR (n:Episodic) ON (n.group_id)',
+        'CREATE INDEX relation_group_id IF NOT EXISTS FOR ()-[e:RELATES_TO]-() ON (e.group_id)',
+        'CREATE INDEX mention_group_id IF NOT EXISTS FOR ()-[e:MENTIONS]-() ON (e.group_id)',
         'CREATE INDEX name_entity_index IF NOT EXISTS FOR (n:Entity) ON (n.name)',
         'CREATE INDEX created_at_entity_index IF NOT EXISTS FOR (n:Entity) ON (n.created_at)',
         'CREATE INDEX created_at_episodic_index IF NOT EXISTS FOR (n:Episodic) ON (n.created_at)',
@@ -86,6 +90,7 @@ async def retrieve_episodes(
     driver: AsyncDriver,
     reference_time: datetime,
     last_n: int = EPISODE_WINDOW_LEN,
+    group_ids: list[str | None] | None = None,
 ) -> list[EpisodicNode]:
     """
     Retrieve the last n episodic nodes from the graph.
@@ -96,25 +101,28 @@ async def retrieve_episodes(
                                    less than or equal to this reference_time will be retrieved. This allows for
                                    querying the graph's state at a specific point in time.
         last_n (int, optional): The number of most recent episodes to retrieve, relative to the reference_time.
+        group_ids (list[str], optional): The list of group ids to return data from.
 
     Returns:
         list[EpisodicNode]: A list of EpisodicNode objects representing the retrieved episodes.
     """
     result = await driver.execute_query(
         """
-        MATCH (e:Episodic) WHERE e.valid_at <= $reference_time
-        RETURN e.content as content,
-            e.created_at as created_at,
-            e.valid_at as valid_at,
-            e.uuid as uuid,
-            e.name as name,
-            e.source_description as source_description,
-            e.source as source
+        MATCH (e:Episodic) WHERE e.valid_at <= $reference_time AND e.group_id in $group_ids
+        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
         ORDER BY e.created_at DESC
         LIMIT $num_episodes
         """,
         reference_time=reference_time,
         num_episodes=last_n,
+        group_ids=group_ids,
     )
     episodes = [
         EpisodicNode(
@@ -124,6 +132,7 @@ async def retrieve_episodes(
             ),
             valid_at=(record['valid_at'].to_native()),
             uuid=record['uuid'],
+            group_id=record['group_id'],
             source=EpisodeType.from_str(record['source']),
             name=record['name'],
             source_description=record['source_description'],

graphiti_core/utils/maintenance/node_operations.py

@@ -85,6 +85,7 @@ async def extract_nodes(
     for node_data in extracted_node_data:
         new_node = EntityNode(
             name=node_data['name'],
+            group_id=episode.group_id,
             labels=node_data['labels'],
             summary=node_data['summary'],
             created_at=datetime.now(),

graphiti_core/utils/maintenance/temporal_operations.py

@@ -16,6 +16,7 @@ limitations under the License.
 
 import logging
 from datetime import datetime
+from time import time
 from typing import List
 
 from graphiti_core.edges import EntityEdge
@@ -181,3 +182,36 @@ async def extract_edge_dates(
     logger.info(f'Edge date extraction explanation: {explanation}')
 
     return valid_at_datetime, invalid_at_datetime
+
+
+async def get_edge_contradictions(
+    llm_client: LLMClient, new_edge: EntityEdge, existing_edges: list[EntityEdge]
+) -> list[EntityEdge]:
+    start = time()
+    existing_edge_map = {edge.uuid: edge for edge in existing_edges}
+
+    new_edge_context = {'uuid': new_edge.uuid, 'name': new_edge.name, 'fact': new_edge.fact}
+    existing_edge_context = [
+        {'uuid': existing_edge.uuid, 'name': existing_edge.name, 'fact': existing_edge.fact}
+        for existing_edge in existing_edges
+    ]
+
+    context = {'new_edge': new_edge_context, 'existing_edges': existing_edge_context}
+
+    llm_response = await llm_client.generate_response(prompt_library.invalidate_edges.v2(context))
+
+    contradicted_edge_data = llm_response.get('invalidated_edges', [])
+
+    contradicted_edges: list[EntityEdge] = []
+    for edge_data in contradicted_edge_data:
+        if edge_data['uuid'] in existing_edge_map:
+            contradicted_edge = existing_edge_map[edge_data['uuid']]
+            contradicted_edge.fact = edge_data['fact']
+            contradicted_edges.append(contradicted_edge)
+
+    end = time()
+    logger.info(
+        f'Found invalidated edge candidates from {new_edge.fact}, in {(end - start) * 1000} ms'
+    )
+
+    return contradicted_edges

{graphiti_core-0.2.1.dist-info → graphiti_core-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.2.1
+Version: 0.2.3
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -12,11 +12,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: diskcache (>=5.6.3,<6.0.0)
-Requires-Dist: fastapi (>=0.112.0,<0.113.0)
 Requires-Dist: neo4j (>=5.23.0,<6.0.0)
+Requires-Dist: numpy (>=2.1.1,<3.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)
 Description-Content-Type: text/markdown
 
@@ -173,7 +172,7 @@ graphiti.close()
 
 ## Documentation
 
-- [Guides and API documentation](https://help.getzep.com/Graphiti/Graphiti).
+- [Guides and API documentation](https://help.getzep.com/graphiti).
 - [Quick Start](https://help.getzep.com/graphiti/graphiti/quick-start)
 - [Building an agent with LangChain's LangGraph and Graphiti](https://help.getzep.com/graphiti/graphiti/lang-graph-agent)
 

{graphiti_core-0.2.1.dist-info → graphiti_core-0.2.3.dist-info}/RECORD

@@ -1,6 +1,6 @@
 graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
-graphiti_core/edges.py,sha256=Sxsqw7WZAC6YJKftMaF9t69o7HV_GM6m6ULjtLhZg0M,7484
-graphiti_core/graphiti.py,sha256=2skhhx7pgDotUXaXadJ-YGzaZWYmOoSpjOH10PwyBj4,23374
+graphiti_core/edges.py,sha256=oy_tK9YWE7_g4aQMGutymVdreiC-SsWP6ZtayEYGCFQ,7700
+graphiti_core/graphiti.py,sha256=tUEtyBb8hQXTn_eMmVSsFVBV7AKWE22SPQihCMZtcZU,23647
 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
@@ -9,29 +9,28 @@ graphiti_core/llm_client/config.py,sha256=d1oZ9tt7QBQlbph7v-0HjItb6otK9_-IwF8kkR
 graphiti_core/llm_client/groq_client.py,sha256=qscr5-190wBTUCBL31EAjQTLytK9AF75-y9GsVRvGJU,2206
 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/nodes.py,sha256=RZnIKyu9ZzWVlbodae3Rkzlg00fQIqp5o3iGB4Ffm-M,8140
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
-graphiti_core/prompts/dedupe_edges.py,sha256=FuZQVZlXTYjskaRUYblToLw4cFjyDp4ECrSf-Y8Z4sU,6530
+graphiti_core/prompts/dedupe_edges.py,sha256=DUNHdIudj50FAjkla4nc68tSFSD2yjmYHBw-Bb7ph20,6529
 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=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/invalidate_edges.py,sha256=8SHt3iPTdmqk8A52LxgdMtI39w4USKqVDMOS2i6lRQ4,4342
 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=IUqAdWub2mg-j9Mz-NacJVLequsG5fxqx2SySKnQtXA,4438
-graphiti_core/search/search_utils.py,sha256=0tC_TEPCxB6w8uCUXwpqC27nDog-9bjBNrtwXlyFjIk,21138
+graphiti_core/search/search.py,sha256=cr1-syRlRdijnLtbuQYWy_2G1CtAeIaz6BQ2kl_6FrY,4535
+graphiti_core/search/search_utils.py,sha256=YeJ-M67HXPQySruwZmau3jvilFlcwf8OwfuflnSdf1Q,19355
 graphiti_core/utils/__init__.py,sha256=cJAcMnBZdHBQmWrZdU1PQ1YmaL75bhVUkyVpIPuOyns,260
-graphiti_core/utils/bulk_utils.py,sha256=xwKgHDNiGDt3-jG_YfN4vrHfG-SUxfuBnsFnBANal98,11683
+graphiti_core/utils/bulk_utils.py,sha256=JtoYTZPCigPa3n2E43Oe7QhFZRTA_QKNGy1jVgklHag,12614
 graphiti_core/utils/maintenance/__init__.py,sha256=4b9sfxqyFZMLwxxS2lnQ6_wBr3xrJRIqfAWOidK8EK0,388
-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=1Iswwoqy7HDH_CQACQUq3oQKrX7cNZb1kdkSQOawj84,7956
-graphiti_core/utils/maintenance/temporal_operations.py,sha256=XIo3xSYQ_4LFiRDBJ-V03l2-rYeIcq6Id0O1o53yWWY,6865
+graphiti_core/utils/maintenance/edge_operations.py,sha256=Xq60YlOGQKzD5qN6eahUMOiLQJiBaDNOeIiGkS8EdB0,10855
+graphiti_core/utils/maintenance/graph_data_operations.py,sha256=-A4fPYtXIjoBBX6IDPoaU9pDcSjZGeRbRPj23W1C-l4,5951
+graphiti_core/utils/maintenance/node_operations.py,sha256=ecBOp_reQynENFN0M69IzRPgEuBYOuPpDBwFZq5e-I4,7995
+graphiti_core/utils/maintenance/temporal_operations.py,sha256=BzfGDm96w4HcUEsaWTHUBt5S8dNmDQL1eX6AuBL-XFM,8135
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/utils/utils.py,sha256=LguHvEDi9JruXKWXXHaz2f4vpezdfgY-rpxjPq0dao8,1959
-graphiti_core-0.2.1.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.2.1.dist-info/METADATA,sha256=udtA4SQ8-GKtxObQB6dBBrR0t102mla5Dqv3MMUEO5Y,9193
-graphiti_core-0.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.2.1.dist-info/RECORD,,
+graphiti_core-0.2.3.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.2.3.dist-info/METADATA,sha256=o81BUoLGtzm0AhnO9MBW8yeG1_UPFN6m-0PmnFOJKis,9124
+graphiti_core-0.2.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.2.3.dist-info/RECORD,,

graphiti_core/utils/utils.py

@@ -1,60 +0,0 @@
-"""
-Copyright 2024, Zep Software, Inc.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-import logging
-from collections import defaultdict
-
-from graphiti_core.edges import EntityEdge, EpisodicEdge
-from graphiti_core.nodes import EntityNode, EpisodicNode
-
-logger = logging.getLogger(__name__)
-
-
-def build_episodic_edges(
-    entity_nodes: list[EntityNode], episode: EpisodicNode
-) -> list[EpisodicEdge]:
-    edges: list[EpisodicEdge] = []
-
-    for node in entity_nodes:
-        edges.append(
-            EpisodicEdge(
-                source_node_uuid=episode.uuid,
-                target_node_uuid=node.uuid,
-                created_at=episode.created_at,
-            )
-        )
-
-    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