fix(summary): exclude duplicate edges from node summary generation (#1223)

* fix(summary): exclude duplicate edges from node summary generation

When resolving extracted edges, edges that match existing edges in the
graph were still being passed to node summary generation, causing facts
to be duplicated in summaries.

Changes:
- Update resolve_extracted_edges to return new_edges (non-duplicates)
- Update _extract_and_resolve_edges to pass through new_edges
- Pass only new_edges to extract_attributes_from_nodes in add_episode
- An edge is considered "new" if its resolved UUID matches extracted UUID

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

* chore: bump version to 0.27.1

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

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: prasmussen15

graphiti_core/graphiti.py

@@ -440,8 +440,17 @@ async def _extract_and_resolve_edges(
         nodes: list[EntityNode],
         uuid_map: dict[str, str],
         custom_extraction_instructions: str | None = None,
-    ) -> tuple[list[EntityEdge], list[EntityEdge]]:
-        """Extract edges from episode and resolve against existing graph."""
+    ) -> tuple[list[EntityEdge], list[EntityEdge], list[EntityEdge]]:
+        """Extract edges from episode and resolve against existing graph.
+
+        Returns
+        -------
+        tuple[list[EntityEdge], list[EntityEdge], list[EntityEdge]]
+            A tuple of (resolved_edges, invalidated_edges, new_edges) where:
+            - resolved_edges: All edges after resolution
+            - invalidated_edges: Edges invalidated by new information
+            - new_edges: Only edges that are new to the graph (not duplicates)
+        """
         extracted_edges = await extract_edges(
             self.clients,
             episode,
@@ -455,7 +464,7 @@ async def _extract_and_resolve_edges(
 
         edges = resolve_edge_pointers(extracted_edges, uuid_map)
 
-        resolved_edges, invalidated_edges = await resolve_extracted_edges(
+        resolved_edges, invalidated_edges, new_edges = await resolve_extracted_edges(
             self.clients,
             edges,
             episode,
@@ -464,7 +473,7 @@ async def _extract_and_resolve_edges(
             edge_type_map,
         )
 
-        return resolved_edges, invalidated_edges
+        return resolved_edges, invalidated_edges, new_edges
 
     async def _process_episode_data(
         self,
@@ -700,6 +709,8 @@ async def _resolve_nodes_and_edges_bulk(
         for result in edge_results:
             resolved_edges.extend(result[0])
             invalidated_edges.extend(result[1])
+            # result[2] is new_edges - not used in bulk flow since attributes
+            # are extracted before edge resolution
 
         return final_hydrated_nodes, resolved_edges, invalidated_edges, uuid_map
 
@@ -917,7 +928,7 @@ async def add_episode_endpoint(episode_data: EpisodeData):
                 )
 
                 # Extract and resolve edges in parallel with attribute extraction
-                resolved_edges, invalidated_edges = await self._extract_and_resolve_edges(
+                resolved_edges, invalidated_edges, new_edges = await self._extract_and_resolve_edges(
                     episode,
                     extracted_nodes,
                     previous_episodes,
@@ -931,14 +942,15 @@ async def add_episode_endpoint(episode_data: EpisodeData):
 
                 entity_edges = resolved_edges + invalidated_edges
 
-                # Extract node attributes
+                # Extract node attributes - only pass new edges for summary generation
+                # to avoid duplicating facts that already exist in the graph
                 hydrated_nodes = await extract_attributes_from_nodes(
                     self.clients,
                     nodes,
                     episode,
                     previous_episodes,
                     entity_types,
-                    edges=entity_edges,
+                    edges=new_edges,
                 )
 
                 # Process and save episode data (including saga association if provided)

graphiti_core/utils/maintenance/edge_operations.py

@@ -306,7 +306,17 @@ async def resolve_extracted_edges(
     entities: list[EntityNode],
     edge_types: dict[str, type[BaseModel]],
     edge_type_map: dict[tuple[str, str], list[str]],
-) -> tuple[list[EntityEdge], list[EntityEdge]]:
+) -> tuple[list[EntityEdge], list[EntityEdge], list[EntityEdge]]:
+    """Resolve extracted edges against existing graph context.
+
+    Returns
+    -------
+    tuple[list[EntityEdge], list[EntityEdge], list[EntityEdge]]
+        A tuple of (resolved_edges, invalidated_edges, new_edges) where:
+        - resolved_edges: All edges after resolution (may include existing edges if duplicates found)
+        - invalidated_edges: Edges that were invalidated/contradicted by new information
+        - new_edges: Only edges that are new to the graph (not duplicates of existing edges)
+    """
     # Fast path: deduplicate exact matches within the extracted edges before parallel processing
     seen: dict[tuple[str, str, str], EntityEdge] = {}
     deduplicated_edges: list[EntityEdge] = []
@@ -444,21 +454,29 @@ async def resolve_extracted_edges(
 
     resolved_edges: list[EntityEdge] = []
     invalidated_edges: list[EntityEdge] = []
-    for result in results:
+    new_edges: list[EntityEdge] = []
+    for extracted_edge, result in zip(extracted_edges, results, strict=True):
         resolved_edge = result[0]
         invalidated_edge_chunk = result[1]
+        # result[2] is duplicate_edges list
 
         resolved_edges.append(resolved_edge)
         invalidated_edges.extend(invalidated_edge_chunk)
 
+        # Track edges that are new (not duplicates of existing edges)
+        # An edge is new if the resolved edge UUID matches the extracted edge UUID
+        if resolved_edge.uuid == extracted_edge.uuid:
+            new_edges.append(resolved_edge)
+
     logger.debug(f'Resolved edges: {[(e.name, e.uuid) for e in resolved_edges]}')
+    logger.debug(f'New edges (non-duplicates): {[(e.name, e.uuid) for e in new_edges]}')
 
     await semaphore_gather(
         create_entity_edge_embeddings(embedder, resolved_edges),
         create_entity_edge_embeddings(embedder, invalidated_edges),
     )
 
-    return resolved_edges, invalidated_edges
+    return resolved_edges, invalidated_edges, new_edges
 
 
 def resolve_edge_contradictions(

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "graphiti-core"
 description = "A temporal graph building library"
-version = "0.27.0"
+version = "0.27.1"
 authors = [
     { name = "Paul Paliychuk", email = "paul@getzep.com" },
     { name = "Preston Rasmussen", email = "preston@getzep.com" },

tests/utils/maintenance/test_edge_operations.py

@@ -221,7 +221,7 @@ async def immediate_gather(*aws, max_coroutines=None):
     edge_types = {'OCCURRED_AT': OccurredAtEdge}
     edge_type_map = {('Event', 'Entity'): ['OCCURRED_AT']}
 
-    resolved_edges, invalidated_edges = await resolve_extracted_edges(
+    resolved_edges, invalidated_edges, new_edges = await resolve_extracted_edges(
         clients,
         [extracted_edge],
         episode,
@@ -232,6 +232,7 @@ async def immediate_gather(*aws, max_coroutines=None):
 
     assert resolved_edges[0].name == 'INTERACTED_WITH'
     assert invalidated_edges == []
+    assert new_edges == resolved_edges  # No duplicates, so all edges are new
 
 
 @pytest.mark.asyncio
@@ -431,7 +432,7 @@ async def immediate_gather(*aws, max_coroutines=None):
         valid_at=datetime.now(timezone.utc),
     )
 
-    resolved_edges, invalidated_edges = await resolve_extracted_edges(
+    resolved_edges, invalidated_edges, new_edges = await resolve_extracted_edges(
         clients,
         [edge1, edge2, edge3],
         episode,
@@ -445,6 +446,7 @@ async def immediate_gather(*aws, max_coroutines=None):
     assert resolve_call_count == 1
     assert len(resolved_edges) == 1
     assert invalidated_edges == []
+    assert new_edges == resolved_edges  # All edges are new (no graph duplicates)
 
 
 class InterpersonalRelationship(BaseModel):