refactor: add get_between_nodes_bidirectional to avoid doubling queries

Adds a new EntityEdge.get_between_nodes_bidirectional method that uses
undirected Cypher matching (-) instead of directed (->), finding edges
in both directions with a single query. This preserves the existing
directional semantics of get_between_nodes for other callers.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: prasmussen15

graphiti_core/edges.py

@@ -435,6 +435,35 @@ async def get_between_nodes(
 
         return edges
 
+    @classmethod
+    async def get_between_nodes_bidirectional(
+        cls, driver: GraphDriver, node_uuid_a: str, node_uuid_b: str
+    ):
+        match_query = """
+            MATCH (n:Entity {uuid: $node_uuid_a})-[e:RELATES_TO]-(m:Entity {uuid: $node_uuid_b})
+        """
+        if driver.provider == GraphProvider.KUZU:
+            match_query = """
+                MATCH (n:Entity {uuid: $node_uuid_a})
+                      -[:RELATES_TO]-(e:RelatesToNode_)
+                      -[:RELATES_TO]-(m:Entity {uuid: $node_uuid_b})
+            """
+
+        records, _, _ = await driver.execute_query(
+            match_query
+            + """
+            RETURN
+            """
+            + get_entity_edge_return_query(driver.provider),
+            node_uuid_a=node_uuid_a,
+            node_uuid_b=node_uuid_b,
+            routing_='r',
+        )
+
+        edges = [get_entity_edge_from_record(record, driver.provider) for record in records]
+
+        return edges
+
     @classmethod
     async def get_by_uuids(cls, driver: GraphDriver, uuids: list[str]):
         if driver.graph_operations_interface:

graphiti_core/utils/maintenance/edge_operations.py

@@ -273,27 +273,14 @@ async def resolve_extracted_edges(
     embedder = clients.embedder
     await create_entity_edge_embeddings(embedder, extracted_edges)
 
-    all_edge_queries = [
-        EntityEdge.get_between_nodes(driver, edge.source_node_uuid, edge.target_node_uuid)
-        for edge in extracted_edges
-    ] + [
-        EntityEdge.get_between_nodes(driver, edge.target_node_uuid, edge.source_node_uuid)
-        for edge in extracted_edges
-    ]
-    all_results: list[list[EntityEdge]] = await semaphore_gather(*all_edge_queries)
-    n = len(extracted_edges)
-    forward_edges_list = all_results[:n]
-    inverse_edges_list = all_results[n:]
-
-    valid_edges_list: list[list[EntityEdge]] = []
-    for forward_edges, inverse_edges in zip(forward_edges_list, inverse_edges_list, strict=True):
-        seen_uuids: set[str] = set()
-        combined: list[EntityEdge] = []
-        for edge in [*forward_edges, *inverse_edges]:
-            if edge.uuid not in seen_uuids:
-                seen_uuids.add(edge.uuid)
-                combined.append(edge)
-        valid_edges_list.append(combined)
+    valid_edges_list: list[list[EntityEdge]] = await semaphore_gather(
+        *[
+            EntityEdge.get_between_nodes_bidirectional(
+                driver, edge.source_node_uuid, edge.target_node_uuid
+            )
+            for edge in extracted_edges
+        ]
+    )
 
     related_edges_results: list[SearchResults] = await semaphore_gather(
         *[