graphiti-core 0.21.0rc12__py3-none-any.whl → 0.22.0__py3-none-any.whl

graphiti_core/tracer.py

@@ -0,0 +1,193 @@
+"""
+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.
+"""
+
+from abc import ABC, abstractmethod
+from collections.abc import Generator
+from contextlib import AbstractContextManager, contextmanager, suppress
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from opentelemetry.trace import Span, StatusCode
+
+try:
+    from opentelemetry.trace import Span, StatusCode
+
+    OTEL_AVAILABLE = True
+except ImportError:
+    OTEL_AVAILABLE = False
+
+
+class TracerSpan(ABC):
+    """Abstract base class for tracer spans."""
+
+    @abstractmethod
+    def add_attributes(self, attributes: dict[str, Any]) -> None:
+        """Add attributes to the span."""
+        pass
+
+    @abstractmethod
+    def set_status(self, status: str, description: str | None = None) -> None:
+        """Set the status of the span."""
+        pass
+
+    @abstractmethod
+    def record_exception(self, exception: Exception) -> None:
+        """Record an exception in the span."""
+        pass
+
+
+class Tracer(ABC):
+    """Abstract base class for tracers."""
+
+    @abstractmethod
+    def start_span(self, name: str) -> AbstractContextManager[TracerSpan]:
+        """Start a new span with the given name."""
+        pass
+
+
+class NoOpSpan(TracerSpan):
+    """No-op span implementation that does nothing."""
+
+    def add_attributes(self, attributes: dict[str, Any]) -> None:
+        pass
+
+    def set_status(self, status: str, description: str | None = None) -> None:
+        pass
+
+    def record_exception(self, exception: Exception) -> None:
+        pass
+
+
+class NoOpTracer(Tracer):
+    """No-op tracer implementation that does nothing."""
+
+    @contextmanager
+    def start_span(self, name: str) -> Generator[NoOpSpan, None, None]:
+        """Return a no-op span."""
+        yield NoOpSpan()
+
+
+class OpenTelemetrySpan(TracerSpan):
+    """Wrapper for OpenTelemetry span."""
+
+    def __init__(self, span: 'Span'):
+        self._span = span
+
+    def add_attributes(self, attributes: dict[str, Any]) -> None:
+        """Add attributes to the OpenTelemetry span."""
+        try:
+            # Filter out None values and convert all values to appropriate types
+            filtered_attrs = {}
+            for key, value in attributes.items():
+                if value is not None:
+                    # Convert to string if not a primitive type
+                    if isinstance(value, str | int | float | bool):
+                        filtered_attrs[key] = value
+                    else:
+                        filtered_attrs[key] = str(value)
+
+            if filtered_attrs:
+                self._span.set_attributes(filtered_attrs)
+        except Exception:
+            # Silently ignore tracing errors
+            pass
+
+    def set_status(self, status: str, description: str | None = None) -> None:
+        """Set the status of the OpenTelemetry span."""
+        try:
+            if OTEL_AVAILABLE:
+                if status == 'error':
+                    self._span.set_status(StatusCode.ERROR, description)
+                elif status == 'ok':
+                    self._span.set_status(StatusCode.OK, description)
+        except Exception:
+            # Silently ignore tracing errors
+            pass
+
+    def record_exception(self, exception: Exception) -> None:
+        """Record an exception in the OpenTelemetry span."""
+        with suppress(Exception):
+            self._span.record_exception(exception)
+
+
+class OpenTelemetryTracer(Tracer):
+    """Wrapper for OpenTelemetry tracer with configurable span name prefix."""
+
+    def __init__(self, tracer: Any, span_prefix: str = 'graphiti'):
+        """
+        Initialize the OpenTelemetry tracer wrapper.
+
+        Parameters
+        ----------
+        tracer : opentelemetry.trace.Tracer
+            The OpenTelemetry tracer instance.
+        span_prefix : str, optional
+            Prefix to prepend to all span names. Defaults to 'graphiti'.
+        """
+        if not OTEL_AVAILABLE:
+            raise ImportError(
+                'OpenTelemetry is not installed. Install it with: pip install opentelemetry-api'
+            )
+        self._tracer = tracer
+        self._span_prefix = span_prefix.rstrip('.')
+
+    @contextmanager
+    def start_span(self, name: str) -> Generator[OpenTelemetrySpan | NoOpSpan, None, None]:
+        """Start a new OpenTelemetry span with the configured prefix."""
+        try:
+            full_name = f'{self._span_prefix}.{name}'
+            with self._tracer.start_as_current_span(full_name) as span:
+                yield OpenTelemetrySpan(span)
+        except Exception:
+            # If tracing fails, yield a no-op span to prevent breaking the operation
+            yield NoOpSpan()
+
+
+def create_tracer(otel_tracer: Any | None = None, span_prefix: str = 'graphiti') -> Tracer:
+    """
+    Create a tracer instance.
+
+    Parameters
+    ----------
+    otel_tracer : opentelemetry.trace.Tracer | None, optional
+        An OpenTelemetry tracer instance. If None, a no-op tracer is returned.
+    span_prefix : str, optional
+        Prefix to prepend to all span names. Defaults to 'graphiti'.
+
+    Returns
+    -------
+    Tracer
+        A tracer instance (either OpenTelemetryTracer or NoOpTracer).
+
+    Examples
+    --------
+    Using with OpenTelemetry:
+
+    >>> from opentelemetry import trace
+    >>> otel_tracer = trace.get_tracer(__name__)
+    >>> tracer = create_tracer(otel_tracer, span_prefix='myapp.graphiti')
+
+    Using no-op tracer:
+
+    >>> tracer = create_tracer()  # Returns NoOpTracer
+    """
+    if otel_tracer is None:
+        return NoOpTracer()
+
+    if not OTEL_AVAILABLE:
+        return NoOpTracer()
+
+    return OpenTelemetryTracer(otel_tracer, span_prefix)

graphiti_core/utils/bulk_utils.py

@@ -24,9 +24,6 @@ from pydantic import BaseModel, Field
 from typing_extensions import Any
 
 from graphiti_core.driver.driver import (
-    ENTITY_EDGE_INDEX_NAME,
-    ENTITY_INDEX_NAME,
-    EPISODE_INDEX_NAME,
     GraphDriver,
     GraphDriverSession,
     GraphProvider,
@@ -177,12 +174,10 @@ async def add_nodes_and_edges_bulk_tx(
             'group_id': node.group_id,
             'summary': node.summary,
             'created_at': node.created_at,
+            'name_embedding': node.name_embedding,
+            'labels': list(set(node.labels + ['Entity'])),
         }
 
-        if not bool(driver.aoss_client):
-            entity_data['name_embedding'] = node.name_embedding
-
-        entity_data['labels'] = list(set(node.labels + ['Entity']))
         if driver.provider == GraphProvider.KUZU:
             attributes = convert_datetimes_to_strings(node.attributes) if node.attributes else {}
             entity_data['attributes'] = json.dumps(attributes)
@@ -207,11 +202,9 @@ async def add_nodes_and_edges_bulk_tx(
             'expired_at': edge.expired_at,
             'valid_at': edge.valid_at,
             'invalid_at': edge.invalid_at,
+            'fact_embedding': edge.fact_embedding,
         }
 
-        if not bool(driver.aoss_client):
-            edge_data['fact_embedding'] = edge.fact_embedding
-
         if driver.provider == GraphProvider.KUZU:
             attributes = convert_datetimes_to_strings(edge.attributes) if edge.attributes else {}
             edge_data['attributes'] = json.dumps(attributes)
@@ -220,7 +213,17 @@ async def add_nodes_and_edges_bulk_tx(
 
         edges.append(edge_data)
 
-    if driver.provider == GraphProvider.KUZU:
+    if driver.graph_operations_interface:
+        await driver.graph_operations_interface.episodic_node_save_bulk(
+            None, driver, tx, episodic_nodes
+        )
+        await driver.graph_operations_interface.node_save_bulk(None, driver, tx, nodes)
+        await driver.graph_operations_interface.episodic_edge_save_bulk(
+            None, driver, tx, episodic_edges
+        )
+        await driver.graph_operations_interface.edge_save_bulk(None, driver, tx, edges)
+
+    elif driver.provider == GraphProvider.KUZU:
         # FIXME: Kuzu's UNWIND does not currently support STRUCT[] type properly, so we insert the data one by one instead for now.
         episode_query = get_episode_node_save_bulk_query(driver.provider)
         for episode in episodes:
@@ -237,9 +240,7 @@ async def add_nodes_and_edges_bulk_tx(
     else:
         await tx.run(get_episode_node_save_bulk_query(driver.provider), episodes=episodes)
         await tx.run(
-            get_entity_node_save_bulk_query(
-                driver.provider, nodes, has_aoss=bool(driver.aoss_client)
-            ),
+            get_entity_node_save_bulk_query(driver.provider, nodes),
             nodes=nodes,
         )
         await tx.run(
@@ -247,23 +248,10 @@ async def add_nodes_and_edges_bulk_tx(
             episodic_edges=[edge.model_dump() for edge in episodic_edges],
         )
         await tx.run(
-            get_entity_edge_save_bulk_query(driver.provider, has_aoss=bool(driver.aoss_client)),
+            get_entity_edge_save_bulk_query(driver.provider),
             entity_edges=edges,
         )
 
-        if bool(driver.aoss_client):
-            for node_data, entity_node in zip(nodes, entity_nodes, strict=True):
-                if node_data.get('uuid') == entity_node.uuid:
-                    node_data['name_embedding'] = entity_node.name_embedding
-
-            for edge_data, entity_edge in zip(edges, entity_edges, strict=True):
-                if edge_data.get('uuid') == entity_edge.uuid:
-                    edge_data['fact_embedding'] = entity_edge.fact_embedding
-
-            await driver.save_to_aoss(EPISODE_INDEX_NAME, episodes)
-            await driver.save_to_aoss(ENTITY_INDEX_NAME, nodes)
-            await driver.save_to_aoss(ENTITY_EDGE_INDEX_NAME, edges)
-
 
 async def extract_nodes_and_edges_bulk(
     clients: GraphitiClients,

graphiti_core/utils/maintenance/community_operations.py

@@ -138,7 +138,9 @@ async def summarize_pair(llm_client: LLMClient, summary_pair: tuple[str, str]) -
     }
 
     llm_response = await llm_client.generate_response(
-        prompt_library.summarize_nodes.summarize_pair(context), response_model=Summary
+        prompt_library.summarize_nodes.summarize_pair(context),
+        response_model=Summary,
+        prompt_name='summarize_nodes.summarize_pair',
     )
 
     pair_summary = llm_response.get('summary', '')
@@ -154,6 +156,7 @@ async def generate_summary_description(llm_client: LLMClient, summary: str) -> s
     llm_response = await llm_client.generate_response(
         prompt_library.summarize_nodes.summary_description(context),
         response_model=SummaryDescription,
+        prompt_name='summarize_nodes.summary_description',
     )
 
     description = llm_response.get('description', '')

graphiti_core/utils/maintenance/edge_operations.py

@@ -139,6 +139,8 @@ async def extract_edges(
             prompt_library.extract_edges.edge(context),
             response_model=ExtractedEdges,
             max_tokens=extract_edges_max_tokens,
+            group_id=group_id,
+            prompt_name='extract_edges.edge',
         )
         edges_data = ExtractedEdges(**llm_response).edges
 
@@ -150,6 +152,8 @@ async def extract_edges(
                 prompt_library.extract_edges.reflexion(context),
                 response_model=MissingFacts,
                 max_tokens=extract_edges_max_tokens,
+                group_id=group_id,
+                prompt_name='extract_edges.reflexion',
             )
 
             missing_facts = reflexion_response.get('missing_facts', [])
@@ -177,6 +181,10 @@ async def extract_edges(
         valid_at_datetime = None
         invalid_at_datetime = None
 
+        # Filter out empty edges
+        if not edge_data.fact.strip():
+            continue
+
         source_node_idx = edge_data.source_entity_id
         target_node_idx = edge_data.target_entity_id
 
@@ -405,21 +413,26 @@ def resolve_edge_contradictions(
     invalidated_edges: list[EntityEdge] = []
     for edge in invalidation_candidates:
         # (Edge invalid before new edge becomes valid) or (new edge invalid before edge becomes valid)
+        edge_invalid_at_utc = ensure_utc(edge.invalid_at)
+        resolved_edge_valid_at_utc = ensure_utc(resolved_edge.valid_at)
+        edge_valid_at_utc = ensure_utc(edge.valid_at)
+        resolved_edge_invalid_at_utc = ensure_utc(resolved_edge.invalid_at)
+
         if (
-            edge.invalid_at is not None
-            and resolved_edge.valid_at is not None
-            and edge.invalid_at <= resolved_edge.valid_at
+            edge_invalid_at_utc is not None
+            and resolved_edge_valid_at_utc is not None
+            and edge_invalid_at_utc <= resolved_edge_valid_at_utc
         ) or (
-            edge.valid_at is not None
-            and resolved_edge.invalid_at is not None
-            and resolved_edge.invalid_at <= edge.valid_at
+            edge_valid_at_utc is not None
+            and resolved_edge_invalid_at_utc is not None
+            and resolved_edge_invalid_at_utc <= edge_valid_at_utc
         ):
             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_valid_at_utc is not None
+            and resolved_edge_valid_at_utc is not None
+            and edge_valid_at_utc < resolved_edge_valid_at_utc
         ):
             edge.invalid_at = resolved_edge.valid_at
             edge.expired_at = edge.expired_at if edge.expired_at is not None else utc_now()
@@ -520,6 +533,7 @@ async def resolve_extracted_edge(
         prompt_library.dedupe_edges.resolve_edge(context),
         response_model=EdgeDuplicate,
         model_size=ModelSize.small,
+        prompt_name='dedupe_edges.resolve_edge',
     )
     response_object = EdgeDuplicate(**llm_response)
     duplicate_facts = response_object.duplicate_facts
@@ -583,6 +597,7 @@ async def resolve_extracted_edge(
                 prompt_library.extract_edges.extract_attributes(edge_attributes_context),
                 response_model=edge_model,  # type: ignore
                 model_size=ModelSize.small,
+                prompt_name='extract_edges.extract_attributes',
             )
 
             resolved_edge.attributes = edge_attributes_response
@@ -609,14 +624,14 @@ async def resolve_extracted_edge(
 
     # 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))
+        invalidation_candidates.sort(key=lambda c: (c.valid_at is None, ensure_utc(c.valid_at)))
         for candidate in invalidation_candidates:
+            candidate_valid_at_utc = ensure_utc(candidate.valid_at)
+            resolved_edge_valid_at_utc = ensure_utc(resolved_edge.valid_at)
             if (
-                candidate.valid_at
-                and resolved_edge.valid_at
-                and candidate.valid_at.tzinfo
-                and resolved_edge.valid_at.tzinfo
-                and candidate.valid_at > resolved_edge.valid_at
+                candidate_valid_at_utc is not None
+                and resolved_edge_valid_at_utc is not None
+                and candidate_valid_at_utc > resolved_edge_valid_at_utc
             ):
                 # Expire new edge since we have information about more recent events
                 resolved_edge.invalid_at = candidate.valid_at

graphiti_core/utils/maintenance/graph_data_operations.py

@@ -34,30 +34,13 @@ logger = logging.getLogger(__name__)
 
 
 async def build_indices_and_constraints(driver: GraphDriver, delete_existing: bool = False):
-    if driver.aoss_client:
-        await driver.create_aoss_indices()  # pyright: ignore[reportAttributeAccessIssue]
-        return
     if delete_existing:
-        records, _, _ = await driver.execute_query(
-            """
-            SHOW INDEXES YIELD name
-            """,
-        )
-        index_names = [record['name'] for record in records]
-        await semaphore_gather(
-            *[
-                driver.execute_query(
-                    """DROP INDEX $name""",
-                    name=name,
-                )
-                for name in index_names
-            ]
-        )
+        await driver.delete_all_indexes()
 
     range_indices: list[LiteralString] = get_range_indices(driver.provider)
 
-    # Don't create fulltext indices if OpenSearch is being used
-    if not driver.aoss_client:
+    # Don't create fulltext indices if search_interface is being used
+    if not driver.search_interface:
         fulltext_indices: list[LiteralString] = get_fulltext_indices(driver.provider)
 
     if driver.provider == GraphProvider.KUZU:
@@ -95,8 +78,6 @@ async def clear_data(driver: GraphDriver, group_ids: list[str] | None = None):
 
         async def delete_all(tx):
             await tx.run('MATCH (n) DETACH DELETE n')
-            if driver.aoss_client:
-                await driver.clear_aoss_indices()
 
         async def delete_group_ids(tx):
             labels = ['Entity', 'Episodic', 'Community']
@@ -153,9 +134,9 @@ async def retrieve_episodes(
 
     query: LiteralString = (
         """
-                        MATCH (e:Episodic)
-                        WHERE e.valid_at <= $reference_time
-                        """
+                                    MATCH (e:Episodic)
+                                    WHERE e.valid_at <= $reference_time
+                                    """
         + query_filter
         + """
         RETURN

graphiti_core/utils/maintenance/node_operations.py

@@ -53,6 +53,7 @@ from graphiti_core.utils.maintenance.dedup_helpers import (
 from graphiti_core.utils.maintenance.edge_operations import (
     filter_existing_duplicate_of_edges,
 )
+from graphiti_core.utils.text_utils import MAX_SUMMARY_CHARS, truncate_at_sentence
 
 logger = logging.getLogger(__name__)
 
@@ -64,6 +65,7 @@ async def extract_nodes_reflexion(
     episode: EpisodicNode,
     previous_episodes: list[EpisodicNode],
     node_names: list[str],
+    group_id: str | None = None,
 ) -> list[str]:
     # Prepare context for LLM
     context = {
@@ -73,7 +75,10 @@ async def extract_nodes_reflexion(
     }
 
     llm_response = await llm_client.generate_response(
-        prompt_library.extract_nodes.reflexion(context), MissedEntities
+        prompt_library.extract_nodes.reflexion(context),
+        MissedEntities,
+        group_id=group_id,
+        prompt_name='extract_nodes.reflexion',
     )
     missed_entities = llm_response.get('missed_entities', [])
 
@@ -129,16 +134,22 @@ async def extract_nodes(
             llm_response = await llm_client.generate_response(
                 prompt_library.extract_nodes.extract_message(context),
                 response_model=ExtractedEntities,
+                group_id=episode.group_id,
+                prompt_name='extract_nodes.extract_message',
             )
         elif episode.source == EpisodeType.text:
             llm_response = await llm_client.generate_response(
                 prompt_library.extract_nodes.extract_text(context),
                 response_model=ExtractedEntities,
+                group_id=episode.group_id,
+                prompt_name='extract_nodes.extract_text',
             )
         elif episode.source == EpisodeType.json:
             llm_response = await llm_client.generate_response(
                 prompt_library.extract_nodes.extract_json(context),
                 response_model=ExtractedEntities,
+                group_id=episode.group_id,
+                prompt_name='extract_nodes.extract_json',
             )
 
         response_object = ExtractedEntities(**llm_response)
@@ -152,6 +163,7 @@ async def extract_nodes(
                 episode,
                 previous_episodes,
                 [entity.name for entity in extracted_entities],
+                episode.group_id,
             )
 
             entities_missed = len(missing_entities) != 0
@@ -192,6 +204,7 @@ async def extract_nodes(
         logger.debug(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
 
     logger.debug(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
+
     return extracted_nodes
 
 
@@ -309,6 +322,7 @@ async def _resolve_with_llm(
     llm_response = await llm_client.generate_response(
         prompt_library.dedupe_nodes.nodes(context),
         response_model=NodeResolutions,
+        prompt_name='dedupe_nodes.nodes',
     )
 
     node_resolutions: list[NodeDuplicate] = NodeResolutions(**llm_response).entity_resolutions
@@ -477,63 +491,97 @@ async def extract_attributes_from_node(
     entity_type: type[BaseModel] | None = None,
     should_summarize_node: NodeSummaryFilter | None = None,
 ) -> EntityNode:
-    node_context: dict[str, Any] = {
-        'name': node.name,
-        'summary': node.summary,
-        'entity_types': node.labels,
-        'attributes': node.attributes,
-    }
+    # Extract attributes if entity type is defined and has attributes
+    llm_response = await _extract_entity_attributes(
+        llm_client, node, episode, previous_episodes, entity_type
+    )
 
-    attributes_context: dict[str, Any] = {
-        'node': node_context,
-        'episode_content': episode.content if episode is not None else '',
-        'previous_episodes': (
-            [ep.content for ep in previous_episodes] if previous_episodes is not None else []
-        ),
-    }
+    # Extract summary if needed
+    await _extract_entity_summary(
+        llm_client, node, episode, previous_episodes, should_summarize_node
+    )
+
+    node.attributes.update(llm_response)
+
+    return node
 
-    summary_context: dict[str, Any] = {
-        'node': node_context,
-        'episode_content': episode.content if episode is not None else '',
-        'previous_episodes': (
-            [ep.content for ep in previous_episodes] if previous_episodes is not None else []
-        ),
-    }
 
-    has_entity_attributes: bool = bool(
-        entity_type is not None and len(entity_type.model_fields) != 0
+async def _extract_entity_attributes(
+    llm_client: LLMClient,
+    node: EntityNode,
+    episode: EpisodicNode | None,
+    previous_episodes: list[EpisodicNode] | None,
+    entity_type: type[BaseModel] | None,
+) -> dict[str, Any]:
+    if entity_type is None or len(entity_type.model_fields) == 0:
+        return {}
+
+    attributes_context = _build_episode_context(
+        # should not include summary
+        node_data={
+            'name': node.name,
+            'entity_types': node.labels,
+            'attributes': node.attributes,
+        },
+        episode=episode,
+        previous_episodes=previous_episodes,
     )
 
-    llm_response = (
-        (
-            await llm_client.generate_response(
-                prompt_library.extract_nodes.extract_attributes(attributes_context),
-                response_model=entity_type,
-                model_size=ModelSize.small,
-            )
-        )
-        if has_entity_attributes
-        else {}
+    llm_response = await llm_client.generate_response(
+        prompt_library.extract_nodes.extract_attributes(attributes_context),
+        response_model=entity_type,
+        model_size=ModelSize.small,
+        group_id=node.group_id,
+        prompt_name='extract_nodes.extract_attributes',
     )
 
-    # 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', '')
+    # validate response
+    entity_type(**llm_response)
 
-    if has_entity_attributes and entity_type is not None:
-        entity_type(**llm_response)
-    node_attributes = {key: value for key, value in llm_response.items()}
+    return llm_response
 
-    node.attributes.update(node_attributes)
 
-    return node
+async def _extract_entity_summary(
+    llm_client: LLMClient,
+    node: EntityNode,
+    episode: EpisodicNode | None,
+    previous_episodes: list[EpisodicNode] | None,
+    should_summarize_node: NodeSummaryFilter | None,
+) -> None:
+    if should_summarize_node is not None and not await should_summarize_node(node):
+        return
+
+    summary_context = _build_episode_context(
+        node_data={
+            'name': node.name,
+            'summary': truncate_at_sentence(node.summary, MAX_SUMMARY_CHARS),
+            'entity_types': node.labels,
+            'attributes': node.attributes,
+        },
+        episode=episode,
+        previous_episodes=previous_episodes,
+    )
+
+    summary_response = await llm_client.generate_response(
+        prompt_library.extract_nodes.extract_summary(summary_context),
+        response_model=EntitySummary,
+        model_size=ModelSize.small,
+        group_id=node.group_id,
+        prompt_name='extract_nodes.extract_summary',
+    )
+
+    node.summary = truncate_at_sentence(summary_response.get('summary', ''), MAX_SUMMARY_CHARS)
+
+
+def _build_episode_context(
+    node_data: dict[str, Any],
+    episode: EpisodicNode | None,
+    previous_episodes: list[EpisodicNode] | None,
+) -> dict[str, Any]:
+    return {
+        'node': node_data,
+        'episode_content': episode.content if episode is not None else '',
+        'previous_episodes': (
+            [ep.content for ep in previous_episodes] if previous_episodes is not None else []
+        ),
+    }