edge types no regressions

Author: prasmussen15

graphiti_core/search/search_utils.py

@@ -340,10 +340,10 @@ async def node_fulltext_search(
 
     query = (
         """
-                                                                                    CALL db.index.fulltext.queryNodes("node_name_and_summary", $query, {limit: $limit}) 
-                                                                                    YIELD node AS n, score
-                                                                                    WHERE n:Entity
-                                                                                    """
+                                                                                        CALL db.index.fulltext.queryNodes("node_name_and_summary", $query, {limit: $limit}) 
+                                                                                        YIELD node AS n, score
+                                                                                        WHERE n:Entity
+                                                                                        """
         + filter_query
         + ENTITY_NODE_RETURN
         + """
@@ -775,7 +775,7 @@ async def get_relevant_edges(
                     expired_at: e.expired_at,
                     valid_at: e.valid_at,
                     invalid_at: e.invalid_at,
-                    attributes: properties(e),
+                    attributes: properties(e)
                 })[..$limit] AS matches
         """
     )
@@ -842,7 +842,7 @@ async def get_edge_invalidation_candidates(
                     expired_at: e.expired_at,
                     valid_at: e.valid_at,
                     invalid_at: e.invalid_at,
-                    attributes: properties(e),
+                    attributes: properties(e)
                 })[..$limit] AS matches
         """
     )

graphiti_core/utils/bulk_utils.py

@@ -137,16 +137,34 @@ async def add_nodes_and_edges_bulk_tx(
         entity_data['labels'] = list(set(node.labels + ['Entity']))
         nodes.append(entity_data)
 
+    edges: list[dict[str, Any]] = []
     for edge in entity_edges:
         if edge.fact_embedding is None:
             await edge.generate_embedding(embedder)
+        edge_data: dict[str, Any] = {
+            'uuid': edge.uuid,
+            'source_node_uuid': edge.source_node_uuid,
+            'target_node_uuid': edge.target_node_uuid,
+            'name': edge.name,
+            'fact': edge.fact,
+            'fact_embedding': edge.fact_embedding,
+            'group_id': edge.group_id,
+            'episodes': edge.episodes,
+            'created_at': edge.created_at,
+            'expired_at': edge.expired_at,
+            'valid_at': edge.valid_at,
+            'invalid_at': edge.invalid_at,
+        }
+
+        edge_data.update(edge.attributes or {})
+        edges.append(edge_data)
 
     await tx.run(EPISODIC_NODE_SAVE_BULK, episodes=episodes)
     await tx.run(ENTITY_NODE_SAVE_BULK, nodes=nodes)
     await tx.run(
         EPISODIC_EDGE_SAVE_BULK, episodic_edges=[edge.model_dump() for edge in episodic_edges]
     )
-    await tx.run(ENTITY_EDGE_SAVE_BULK, entity_edges=[edge.model_dump() for edge in entity_edges])
+    await tx.run(ENTITY_EDGE_SAVE_BULK, entity_edges=edges)
 
 
 async def extract_nodes_and_edges_bulk(

graphiti_core/utils/maintenance/edge_operations.py

@@ -284,16 +284,17 @@ async def resolve_extracted_edges(
             for target_label in target_node_labels
         ]
 
-        extracted_edge_types = []
+        extracted_edge_types = {}
         for label_tuple in label_tuples:
-            extracted_edge_types.extend(edge_type_map.get(label_tuple, []))
+            type_names = edge_type_map.get(label_tuple, [])
+            for type_name in type_names:
+                type_model = edge_types.get(type_name)
+                if type_model is None:
+                    continue
 
-        for type_name in extracted_edge_types:
-            type_model = edge_types.get(type_name)
-            if type_model is None:
-                continue
+                extracted_edge_types[type_name] = type_model
 
-            edge_types_lst.append({type_name: type_model})
+        edge_types_lst.append(extracted_edge_types)
 
     # resolve edges with related edges in the graph and find invalidation candidates
     results: list[tuple[EntityEdge, list[EntityEdge]]] = list(