graphiti-core 0.21.0rc9__tar.gz → 0.21.0rc11__tar.gz

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/.github/workflows/claude-code-review.yml

@@ -29,6 +29,8 @@ jobs:
 
             Please review this pull request.
 
+            IMPORTANT: Your role is to critically review code. You must not provide POSITIVE feedback on code, this only adds noise to the review process.
+
             Note: The PR branch is already checked out in the current working directory.
 
             Focus on:
@@ -48,3 +50,4 @@ jobs:
 
           claude_args: |
             --allowedTools "mcp__github_inline_comment__create_inline_comment,Bash(gh pr comment:*), Bash(gh pr diff:*), Bash(gh pr view:*)"
+            --model claude-sonnet-4-5-20250929

graphiti_core-0.21.0rc11/.github/workflows/daily_issue_maintenance.yml

@@ -0,0 +1,123 @@
+name: Daily Issue Maintenance
+on:
+  schedule:
+    - cron: "0 0 * * *" # Every day at midnight
+  workflow_dispatch: # Manual trigger option
+
+jobs:
+  find-legacy-duplicates:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch'
+    permissions:
+      contents: read
+      issues: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          prompt: |
+            REPO: ${{ github.repository }}
+
+            Find potential duplicate issues in the repository:
+
+            1. Use `gh issue list --state open --limit 1000 --json number,title,body,createdAt` to get all open issues
+            2. For each issue, search for potential duplicates using `gh search issues` with keywords from the title and body
+            3. Compare issues to identify true duplicates using these criteria:
+               - Same bug or error being reported
+               - Same feature request (even if worded differently)
+               - Same question being asked
+               - Issues describing the same root problem
+
+            For each duplicate found:
+            - Add a comment linking to the original issue
+            - Apply the "duplicate" label using `gh issue edit`
+            - Be polite and explain why it's a duplicate
+
+            Focus on finding true duplicates, not just similar issues.
+
+          claude_args: |
+            --allowedTools "Bash(gh issue:*),Bash(gh search:*)"
+            --model claude-sonnet-4-5-20250929
+
+  check-stale-issues:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'schedule'
+    permissions:
+      contents: read
+      issues: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          prompt: |
+            REPO: ${{ github.repository }}
+
+            Review stale issues and request confirmation:
+
+            1. Use `gh issue list --state open --limit 1000 --json number,title,updatedAt,comments` to get all open issues
+            2. Identify issues that are:
+               - Older than 60 days (based on updatedAt)
+               - Have no comments with "stale-check" label
+               - Are not labeled as "enhancement" or "documentation"
+            3. For each stale issue:
+               - Add a polite comment asking the issue originator if this is still relevant
+               - Apply a "stale-check" label to track that we've asked
+               - Use format: "@{author} Is this still an issue? Please confirm within 14 days or this issue will be closed."
+
+            Use:
+            - `gh issue view` to check issue details and labels
+            - `gh issue comment` to add comments
+            - `gh issue edit` to add the "stale-check" label
+
+          claude_args: |
+            --allowedTools "Bash(gh issue:*)"
+            --model claude-sonnet-4-5-20250929
+
+  close-unconfirmed-issues:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'schedule'
+    needs: check-stale-issues
+    permissions:
+      contents: read
+      issues: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          prompt: |
+            REPO: ${{ github.repository }}
+
+            Close unconfirmed stale issues:
+
+            1. Use `gh issue list --state open --label "stale-check" --limit 1000 --json number,title,comments,updatedAt` to get issues with stale-check label
+            2. For each issue, check if:
+               - The "stale-check" comment was added 14+ days ago
+               - There has been no response from the issue author or activity since the comment
+            3. For issues meeting the criteria:
+               - Add a polite closing comment
+               - Close the issue using `gh issue close`
+               - Use format: "Closing due to inactivity. Feel free to reopen if this is still relevant."
+
+            Use:
+            - `gh issue view` to check issue comments and activity
+            - `gh issue comment` to add closing comment
+            - `gh issue close` to close the issue
+
+          claude_args: |
+            --allowedTools "Bash(gh issue:*)"
+            --model claude-sonnet-4-5-20250929

graphiti_core-0.21.0rc11/.github/workflows/issue-triage.yml

@@ -0,0 +1,140 @@
+name: Issue Triage and Deduplication
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      issues: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code for Issue Triage
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          allowed_non_write_users: "*"
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          prompt: |
+            You're an issue triage assistant for GitHub issues. Your task is to analyze the issue and select appropriate labels from the provided list.
+
+            IMPORTANT: Don't post any comments or messages to the issue. Your only action should be to apply labels. DO NOT check for duplicates - that's handled by a separate job.
+
+            Issue Information:
+            - REPO: ${{ github.repository }}
+            - ISSUE_NUMBER: ${{ github.event.issue.number }}
+
+            TASK OVERVIEW:
+
+            1. First, fetch the list of labels available in this repository by running: `gh label list`. Run exactly this command with nothing else.
+
+            2. Next, use gh commands to get context about the issue:
+               - Use `gh issue view ${{ github.event.issue.number }}` to retrieve the current issue's details
+               - Use `gh search issues` to find similar issues that might provide context for proper categorization
+               - You have access to these Bash commands:
+                 - Bash(gh label list:*) - to get available labels
+                 - Bash(gh issue view:*) - to view issue details
+                 - Bash(gh issue edit:*) - to apply labels to the issue
+                 - Bash(gh search:*) - to search for similar issues
+
+            3. Analyze the issue content, considering:
+               - The issue title and description
+               - The type of issue (bug report, feature request, question, etc.)
+               - Technical areas mentioned
+               - Database mentions (neo4j, falkordb, neptune, etc.)
+               - LLM providers mentioned (openai, anthropic, gemini, groq, etc.)
+               - Components affected (embeddings, search, prompts, server, mcp, etc.)
+
+            4. Select appropriate labels from the available labels list:
+               - Choose labels that accurately reflect the issue's nature
+               - Be specific but comprehensive
+               - Add database-specific labels if mentioned: neo4j, falkordb, neptune
+               - Add component labels if applicable
+               - DO NOT add priority labels (P1, P2, P3)
+               - DO NOT add duplicate label - that's handled by the deduplication job
+
+            5. Apply the selected labels:
+               - Use `gh issue edit ${{ github.event.issue.number }} --add-label "label1,label2,label3"` to apply your selected labels
+               - DO NOT post any comments explaining your decision
+               - DO NOT communicate directly with users
+               - If no labels are clearly applicable, do not apply any labels
+
+            IMPORTANT GUIDELINES:
+            - Be thorough in your analysis
+            - Only select labels from the provided list
+            - DO NOT post any comments to the issue
+            - Your ONLY action should be to apply labels using gh issue edit
+            - It's okay to not add any labels if none are clearly applicable
+            - DO NOT check for duplicates
+
+          claude_args: |
+            --allowedTools "Bash(gh label list:*),Bash(gh issue view:*),Bash(gh issue edit:*),Bash(gh search:*)"
+            --model claude-sonnet-4-5-20250929
+
+  deduplicate:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    needs: triage
+    permissions:
+      contents: read
+      issues: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Check for duplicate issues
+        uses: anthropics/claude-code-action@v1
+        with:
+          prompt: |
+            Analyze this new issue and check if it's a duplicate of existing issues in the repository.
+
+            Issue: #${{ github.event.issue.number }}
+            Repository: ${{ github.repository }}
+
+            Your task:
+            1. Use mcp__github__get_issue to get details of the current issue (#${{ github.event.issue.number }})
+            2. Search for similar existing OPEN issues using mcp__github__search_issues with relevant keywords from the issue title and body
+            3. Compare the new issue with existing ones to identify potential duplicates
+
+            Criteria for duplicates:
+            - Same bug or error being reported
+            - Same feature request (even if worded differently)
+            - Same question being asked
+            - Issues describing the same root problem
+
+            If you find duplicates:
+            - Add a comment on the new issue linking to the original issue(s)
+            - Apply the "duplicate" label to the new issue
+            - Be polite and explain why it's a duplicate
+            - Suggest the user follow the original issue for updates
+
+            If it's NOT a duplicate:
+            - Don't add any comments
+            - Don't modify labels
+
+            Use these tools:
+            - mcp__github__get_issue: Get issue details
+            - mcp__github__search_issues: Search for similar issues (use state:open)
+            - mcp__github__list_issues: List recent issues if needed
+            - mcp__github__create_issue_comment: Add a comment if duplicate found
+            - mcp__github__update_issue: Add "duplicate" label
+
+            Be thorough but efficient. Focus on finding true duplicates, not just similar issues.
+
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          claude_args: |
+            --allowedTools "mcp__github__get_issue,mcp__github__search_issues,mcp__github__list_issues,mcp__github__create_issue_comment,mcp__github__update_issue,mcp__github__get_issue_comments"
+            --model claude-sonnet-4-5-20250929

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.21.0rc9
+Version: 0.21.0rc11
 Summary: A temporal graph building library
 Project-URL: Homepage, https://help.getzep.com/graphiti/graphiti/overview
 Project-URL: Repository, https://github.com/getzep/graphiti

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/graphiti_core/edges.py

@@ -644,8 +644,11 @@ def get_community_edge_from_record(record: Any):
 
 
 async def create_entity_edge_embeddings(embedder: EmbedderClient, edges: list[EntityEdge]):
-    if len(edges) == 0:
+    # filter out falsey values from edges
+    filtered_edges = [edge for edge in edges if edge.fact]
+
+    if len(filtered_edges) == 0:
         return
-    fact_embeddings = await embedder.create_batch([edge.fact for edge in edges])
-    for edge, fact_embedding in zip(edges, fact_embeddings, strict=True):
+    fact_embeddings = await embedder.create_batch([edge.fact for edge in filtered_edges])
+    for edge, fact_embedding in zip(filtered_edges, fact_embeddings, strict=True):
         edge.fact_embedding = fact_embedding

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/graphiti_core/nodes.py

@@ -868,9 +868,12 @@ def get_community_node_from_record(record: Any) -> CommunityNode:
 
 
 async def create_entity_node_embeddings(embedder: EmbedderClient, nodes: list[EntityNode]):
-    if not nodes:  # Handle empty list case
+    # filter out falsey values from nodes
+    filtered_nodes = [node for node in nodes if node.name]
+
+    if not filtered_nodes:
         return
 
-    name_embeddings = await embedder.create_batch([node.name for node in nodes])
-    for node, name_embedding in zip(nodes, name_embeddings, strict=True):
+    name_embeddings = await embedder.create_batch([node.name for node in filtered_nodes])
+    for node, name_embedding in zip(filtered_nodes, name_embeddings, strict=True):
         node.name_embedding = name_embedding

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/graphiti_core/prompts/dedupe_nodes.py

@@ -166,7 +166,8 @@ def nodes(context: dict[str, Any]) -> list[Message]:
         - They have similar names or purposes but refer to separate instances or concepts.
 
         Task:
-        Respond with a JSON object that contains an "entity_resolutions" array with one entry for each entity in ENTITIES, ordered by the entity id.
+        ENTITIES contains {len(context['extracted_nodes'])} entities with IDs 0 through {len(context['extracted_nodes']) - 1}.
+        Your response MUST include EXACTLY {len(context['extracted_nodes'])} resolutions with IDs 0 through {len(context['extracted_nodes']) - 1}. Do not skip or add IDs.
 
         For every entity, return an object with the following keys:
         {{

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/graphiti_core/prompts/extract_nodes.py

@@ -151,7 +151,7 @@ For each entity extracted, also determine its entity type based on the provided
 Indicate the classified entity type by providing its entity_type_id.
 
 Guidelines:
-1. Always try to extract an entities that the JSON represents. This will often be something like a "name" or "user field
+1. Extract all entities that the JSON represents. This will often be something like a "name" or "user" field
 2. Extract all entities mentioned in all other properties throughout the JSON structure
 3. Do NOT extract any properties that contain dates
 """

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/graphiti_core/utils/maintenance/node_operations.py

@@ -15,6 +15,7 @@ limitations under the License.
 """
 
 import logging
+from collections.abc import Awaitable, Callable
 from time import time
 from typing import Any
 
@@ -55,6 +56,8 @@ from graphiti_core.utils.maintenance.edge_operations import (
 
 logger = logging.getLogger(__name__)
 
+NodeSummaryFilter = Callable[[EntityNode], Awaitable[bool]]
+
 
 async def extract_nodes_reflexion(
     llm_client: LLMClient,
@@ -266,6 +269,27 @@ async def _resolve_with_llm(
         for i, node in enumerate(llm_extracted_nodes)
     ]
 
+    sent_ids = [ctx['id'] for ctx in extracted_nodes_context]
+    logger.debug(
+        'Sending %d entities to LLM for deduplication with IDs 0-%d (actual IDs sent: %s)',
+        len(llm_extracted_nodes),
+        len(llm_extracted_nodes) - 1,
+        sent_ids if len(sent_ids) < 20 else f'{sent_ids[:10]}...{sent_ids[-10:]}',
+    )
+    if llm_extracted_nodes:
+        sample_size = min(3, len(extracted_nodes_context))
+        logger.debug(
+            'First %d entities: %s',
+            sample_size,
+            [(ctx['id'], ctx['name']) for ctx in extracted_nodes_context[:sample_size]],
+        )
+        if len(extracted_nodes_context) > 3:
+            logger.debug(
+                'Last %d entities: %s',
+                sample_size,
+                [(ctx['id'], ctx['name']) for ctx in extracted_nodes_context[-sample_size:]],
+            )
+
     existing_nodes_context = [
         {
             **{
@@ -298,15 +322,38 @@ async def _resolve_with_llm(
     valid_relative_range = range(len(state.unresolved_indices))
     processed_relative_ids: set[int] = set()
 
+    received_ids = {r.id for r in node_resolutions}
+    expected_ids = set(valid_relative_range)
+    missing_ids = expected_ids - received_ids
+    extra_ids = received_ids - expected_ids
+
+    logger.debug(
+        'Received %d resolutions for %d entities',
+        len(node_resolutions),
+        len(state.unresolved_indices),
+    )
+
+    if missing_ids:
+        logger.warning('LLM did not return resolutions for IDs: %s', sorted(missing_ids))
+
+    if extra_ids:
+        logger.warning(
+            'LLM returned invalid IDs outside valid range 0-%d: %s (all returned IDs: %s)',
+            len(state.unresolved_indices) - 1,
+            sorted(extra_ids),
+            sorted(received_ids),
+        )
+
     for resolution in node_resolutions:
         relative_id: int = resolution.id
         duplicate_idx: int = resolution.duplicate_idx
 
         if relative_id not in valid_relative_range:
             logger.warning(
-                'Skipping invalid LLM dedupe id %s (unresolved indices: %s)',
+                'Skipping invalid LLM dedupe id %d (valid range: 0-%d, received %d resolutions)',
                 relative_id,
-                state.unresolved_indices,
+                len(state.unresolved_indices) - 1,
+                len(node_resolutions),
             )
             continue
 
@@ -402,6 +449,7 @@ async def extract_attributes_from_nodes(
     episode: EpisodicNode | None = None,
     previous_episodes: list[EpisodicNode] | None = None,
     entity_types: dict[str, type[BaseModel]] | None = None,
+    should_summarize_node: NodeSummaryFilter | None = None,
 ) -> list[EntityNode]:
     llm_client = clients.llm_client
     embedder = clients.embedder
@@ -418,6 +466,7 @@ async def extract_attributes_from_nodes(
                     else None
                 ),
                 clients.ensure_ascii,
+                should_summarize_node,
             )
             for node in nodes
         ]
@@ -435,6 +484,7 @@ async def extract_attributes_from_node(
     previous_episodes: list[EpisodicNode] | None = None,
     entity_type: type[BaseModel] | None = None,
     ensure_ascii: bool = False,
+    should_summarize_node: NodeSummaryFilter | None = None,
 ) -> EntityNode:
     node_context: dict[str, Any] = {
         'name': node.name,
@@ -477,16 +527,22 @@ async def extract_attributes_from_node(
         else {}
     )
 
-    summary_response = await llm_client.generate_response(
-        prompt_library.extract_nodes.extract_summary(summary_context),
-        response_model=EntitySummary,
-        model_size=ModelSize.small,
-    )
+    # Determine if summary should be generated
+    generate_summary = True
+    if should_summarize_node is not None:
+        generate_summary = await should_summarize_node(node)
+
+    # Conditionally generate summary
+    if generate_summary:
+        summary_response = await llm_client.generate_response(
+            prompt_library.extract_nodes.extract_summary(summary_context),
+            response_model=EntitySummary,
+            model_size=ModelSize.small,
+        )
+        node.summary = summary_response.get('summary', '')
 
     if has_entity_attributes and entity_type is not None:
         entity_type(**llm_response)
-
-    node.summary = summary_response.get('summary', '')
     node_attributes = {key: value for key, value in llm_response.items()}
 
     node.attributes.update(node_attributes)

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/pyproject.toml

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

{graphiti_core-0.21.0rc9 → graphiti_core-0.21.0rc11}/tests/utils/maintenance/test_node_operations.py

@@ -27,6 +27,8 @@ from graphiti_core.utils.maintenance.dedup_helpers import (
 from graphiti_core.utils.maintenance.node_operations import (
     _collect_candidate_nodes,
     _resolve_with_llm,
+    extract_attributes_from_node,
+    extract_attributes_from_nodes,
     resolve_extracted_nodes,
 )
 
@@ -477,3 +479,183 @@ async def test_resolve_with_llm_invalid_duplicate_idx_defaults_to_extracted(monk
     assert state.resolved_nodes[0] == extracted
     assert state.uuid_map[extracted.uuid] == extracted.uuid
     assert state.duplicate_pairs == []
+
+
+@pytest.mark.asyncio
+async def test_extract_attributes_without_callback_generates_summary():
+    """Test that summary is generated when no callback is provided (default behavior)."""
+    llm_client = MagicMock()
+    llm_client.generate_response = AsyncMock(
+        return_value={'summary': 'Generated summary', 'attributes': {}}
+    )
+
+    node = EntityNode(name='Test Node', group_id='group', labels=['Entity'], summary='Old summary')
+    episode = _make_episode()
+
+    result = await extract_attributes_from_node(
+        llm_client,
+        node,
+        episode=episode,
+        previous_episodes=[],
+        entity_type=None,
+        ensure_ascii=False,
+        should_summarize_node=None,  # No callback provided
+    )
+
+    # Summary should be generated
+    assert result.summary == 'Generated summary'
+    # LLM should have been called for summary
+    assert llm_client.generate_response.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_extract_attributes_with_callback_skip_summary():
+    """Test that summary is NOT regenerated when callback returns False."""
+    llm_client = MagicMock()
+    llm_client.generate_response = AsyncMock(
+        return_value={'summary': 'This should not be used', 'attributes': {}}
+    )
+
+    node = EntityNode(name='Test Node', group_id='group', labels=['Entity'], summary='Old summary')
+    episode = _make_episode()
+
+    # Callback that always returns False (skip summary generation)
+    async def skip_summary_filter(node: EntityNode) -> bool:
+        return False
+
+    result = await extract_attributes_from_node(
+        llm_client,
+        node,
+        episode=episode,
+        previous_episodes=[],
+        entity_type=None,
+        ensure_ascii=False,
+        should_summarize_node=skip_summary_filter,
+    )
+
+    # Summary should remain unchanged
+    assert result.summary == 'Old summary'
+    # LLM should NOT have been called for summary
+    assert llm_client.generate_response.call_count == 0
+
+
+@pytest.mark.asyncio
+async def test_extract_attributes_with_callback_generate_summary():
+    """Test that summary is regenerated when callback returns True."""
+    llm_client = MagicMock()
+    llm_client.generate_response = AsyncMock(
+        return_value={'summary': 'New generated summary', 'attributes': {}}
+    )
+
+    node = EntityNode(name='Test Node', group_id='group', labels=['Entity'], summary='Old summary')
+    episode = _make_episode()
+
+    # Callback that always returns True (generate summary)
+    async def generate_summary_filter(node: EntityNode) -> bool:
+        return True
+
+    result = await extract_attributes_from_node(
+        llm_client,
+        node,
+        episode=episode,
+        previous_episodes=[],
+        entity_type=None,
+        ensure_ascii=False,
+        should_summarize_node=generate_summary_filter,
+    )
+
+    # Summary should be updated
+    assert result.summary == 'New generated summary'
+    # LLM should have been called for summary
+    assert llm_client.generate_response.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_extract_attributes_with_selective_callback():
+    """Test callback that selectively skips summaries based on node properties."""
+    llm_client = MagicMock()
+    llm_client.generate_response = AsyncMock(
+        return_value={'summary': 'Generated summary', 'attributes': {}}
+    )
+
+    user_node = EntityNode(name='User', group_id='group', labels=['Entity', 'User'], summary='Old')
+    topic_node = EntityNode(
+        name='Topic', group_id='group', labels=['Entity', 'Topic'], summary='Old'
+    )
+
+    episode = _make_episode()
+
+    # Callback that skips User nodes but generates for others
+    async def selective_filter(node: EntityNode) -> bool:
+        return 'User' not in node.labels
+
+    result_user = await extract_attributes_from_node(
+        llm_client,
+        user_node,
+        episode=episode,
+        previous_episodes=[],
+        entity_type=None,
+        ensure_ascii=False,
+        should_summarize_node=selective_filter,
+    )
+
+    result_topic = await extract_attributes_from_node(
+        llm_client,
+        topic_node,
+        episode=episode,
+        previous_episodes=[],
+        entity_type=None,
+        ensure_ascii=False,
+        should_summarize_node=selective_filter,
+    )
+
+    # User summary should remain unchanged
+    assert result_user.summary == 'Old'
+    # Topic summary should be generated
+    assert result_topic.summary == 'Generated summary'
+    # LLM should have been called only once (for topic)
+    assert llm_client.generate_response.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_extract_attributes_from_nodes_with_callback():
+    """Test that callback is properly passed through extract_attributes_from_nodes."""
+    clients, _ = _make_clients()
+    clients.llm_client.generate_response = AsyncMock(
+        return_value={'summary': 'New summary', 'attributes': {}}
+    )
+    clients.embedder.create = AsyncMock(return_value=[0.1, 0.2, 0.3])
+    clients.embedder.create_batch = AsyncMock(return_value=[[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]])
+
+    node1 = EntityNode(name='Node1', group_id='group', labels=['Entity', 'User'], summary='Old1')
+    node2 = EntityNode(name='Node2', group_id='group', labels=['Entity', 'Topic'], summary='Old2')
+
+    episode = _make_episode()
+
+    call_tracker = []
+
+    # Callback that tracks which nodes it's called with
+    async def tracking_filter(node: EntityNode) -> bool:
+        call_tracker.append(node.name)
+        return 'User' not in node.labels
+
+    results = await extract_attributes_from_nodes(
+        clients,
+        [node1, node2],
+        episode=episode,
+        previous_episodes=[],
+        entity_types=None,
+        should_summarize_node=tracking_filter,
+    )
+
+    # Callback should have been called for both nodes
+    assert len(call_tracker) == 2
+    assert 'Node1' in call_tracker
+    assert 'Node2' in call_tracker
+
+    # Node1 (User) should keep old summary, Node2 (Topic) should get new summary
+    node1_result = next(n for n in results if n.name == 'Node1')
+    node2_result = next(n for n in results if n.name == 'Node2')
+
+    assert node1_result.summary == 'Old1'
+    assert node2_result.summary == 'New summary'