graphiti-core 0.3.8__py3-none-any.whl → 0.3.11__py3-none-any.whl

graphiti_core/search/search_config.py

@@ -20,6 +20,7 @@ from pydantic import BaseModel, Field
 
 from graphiti_core.edges import EntityEdge
 from graphiti_core.nodes import CommunityNode, EntityNode
+from graphiti_core.search.search_utils import DEFAULT_MIN_SCORE, DEFAULT_MMR_LAMBDA
 
 DEFAULT_SEARCH_LIMIT = 10
 
@@ -43,31 +44,40 @@ class EdgeReranker(Enum):
     rrf = 'reciprocal_rank_fusion'
     node_distance = 'node_distance'
     episode_mentions = 'episode_mentions'
+    mmr = 'mmr'
 
 
 class NodeReranker(Enum):
     rrf = 'reciprocal_rank_fusion'
     node_distance = 'node_distance'
     episode_mentions = 'episode_mentions'
+    mmr = 'mmr'
 
 
 class CommunityReranker(Enum):
     rrf = 'reciprocal_rank_fusion'
+    mmr = 'mmr'
 
 
 class EdgeSearchConfig(BaseModel):
     search_methods: list[EdgeSearchMethod]
-    reranker: EdgeReranker | None
+    reranker: EdgeReranker = Field(default=EdgeReranker.rrf)
+    sim_min_score: float = Field(default=DEFAULT_MIN_SCORE)
+    mmr_lambda: float = Field(default=DEFAULT_MMR_LAMBDA)
 
 
 class NodeSearchConfig(BaseModel):
     search_methods: list[NodeSearchMethod]
-    reranker: NodeReranker | None
+    reranker: NodeReranker = Field(default=NodeReranker.rrf)
+    sim_min_score: float = Field(default=DEFAULT_MIN_SCORE)
+    mmr_lambda: float = Field(default=DEFAULT_MMR_LAMBDA)
 
 
 class CommunitySearchConfig(BaseModel):
     search_methods: list[CommunitySearchMethod]
-    reranker: CommunityReranker | None
+    reranker: CommunityReranker = Field(default=CommunityReranker.rrf)
+    sim_min_score: float = Field(default=DEFAULT_MIN_SCORE)
+    mmr_lambda: float = Field(default=DEFAULT_MMR_LAMBDA)
 
 
 class SearchConfig(BaseModel):

graphiti_core/search/search_config_recipes.py

@@ -43,6 +43,22 @@ COMBINED_HYBRID_SEARCH_RRF = SearchConfig(
     ),
 )
 
+# Performs a hybrid search with mmr reranking over edges, nodes, and communities
+COMBINED_HYBRID_SEARCH_MMR = SearchConfig(
+    edge_config=EdgeSearchConfig(
+        search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
+        reranker=EdgeReranker.mmr,
+    ),
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.mmr,
+    ),
+    community_config=CommunitySearchConfig(
+        search_methods=[CommunitySearchMethod.bm25, CommunitySearchMethod.cosine_similarity],
+        reranker=CommunityReranker.mmr,
+    ),
+)
+
 # performs a hybrid search over edges with rrf reranking
 EDGE_HYBRID_SEARCH_RRF = SearchConfig(
     edge_config=EdgeSearchConfig(
@@ -51,12 +67,21 @@ EDGE_HYBRID_SEARCH_RRF = SearchConfig(
     )
 )
 
+# performs a hybrid search over edges with mmr reranking
+EDGE_HYBRID_SEARCH_MMR = SearchConfig(
+    edge_config=EdgeSearchConfig(
+        search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
+        reranker=EdgeReranker.mmr,
+    )
+)
+
 # performs a hybrid search over edges with node distance reranking
 EDGE_HYBRID_SEARCH_NODE_DISTANCE = SearchConfig(
     edge_config=EdgeSearchConfig(
         search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
         reranker=EdgeReranker.node_distance,
-    )
+    ),
+    limit=30,
 )
 
 # performs a hybrid search over edges with episode mention reranking
@@ -75,6 +100,14 @@ NODE_HYBRID_SEARCH_RRF = SearchConfig(
     )
 )
 
+# performs a hybrid search over nodes with mmr reranking
+NODE_HYBRID_SEARCH_MMR = SearchConfig(
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.mmr,
+    )
+)
+
 # performs a hybrid search over nodes with node distance reranking
 NODE_HYBRID_SEARCH_NODE_DISTANCE = SearchConfig(
     node_config=NodeSearchConfig(
@@ -98,3 +131,11 @@ COMMUNITY_HYBRID_SEARCH_RRF = SearchConfig(
         reranker=CommunityReranker.rrf,
     )
 )
+
+# performs a hybrid search over communities with mmr reranking
+COMMUNITY_HYBRID_SEARCH_MMR = SearchConfig(
+    community_config=CommunitySearchConfig(
+        search_methods=[CommunitySearchMethod.bm25, CommunitySearchMethod.cosine_similarity],
+        reranker=CommunityReranker.mmr,
+    )
+)

graphiti_core/search/search_utils.py

@@ -19,10 +19,11 @@ import logging
 from collections import defaultdict
 from time import time
 
+import numpy as np
 from neo4j import AsyncDriver, Query
 
 from graphiti_core.edges import EntityEdge, get_entity_edge_from_record
-from graphiti_core.helpers import lucene_sanitize
+from graphiti_core.helpers import lucene_sanitize, normalize_l2
 from graphiti_core.nodes import (
     CommunityNode,
     EntityNode,
@@ -34,6 +35,8 @@ from graphiti_core.nodes import (
 logger = logging.getLogger(__name__)
 
 RELEVANT_SCHEMA_LIMIT = 3
+DEFAULT_MIN_SCORE = 0.6
+DEFAULT_MMR_LAMBDA = 0.5
 
 
 def fulltext_query(query: str, group_ids: list[str] | None = None):
@@ -52,6 +55,21 @@ def fulltext_query(query: str, group_ids: list[str] | None = None):
     return full_query
 
 
+async def get_episodes_by_mentions(
+    driver: AsyncDriver,
+    nodes: list[EntityNode],
+    edges: list[EntityEdge],
+    limit: int = RELEVANT_SCHEMA_LIMIT,
+) -> list[EpisodicNode]:
+    episode_uuids: list[str] = []
+    for edge in edges:
+        episode_uuids.extend(edge.episodes)
+
+    episodes = await EpisodicNode.get_by_uuids(driver, episode_uuids[:limit])
+
+    return episodes
+
+
 async def get_mentioned_nodes(
     driver: AsyncDriver, episodes: list[EpisodicNode]
 ) -> list[EntityNode]:
@@ -113,9 +131,6 @@ async def edge_fulltext_search(
               CALL db.index.fulltext.queryRelationships("edge_name_and_fact", $query) 
               YIELD relationship AS rel, score
               MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
-              WHERE ($source_uuid IS NULL OR n.uuid = $source_uuid)
-              AND ($target_uuid IS NULL OR m.uuid = $target_uuid)
-              AND ($group_ids IS NULL OR n.group_id IN $group_ids)
               RETURN 
                     r.uuid AS uuid,
                     r.group_id AS group_id,
@@ -153,15 +168,18 @@ async def edge_similarity_search(
     target_node_uuid: str | None,
     group_ids: list[str] | None = None,
     limit: int = RELEVANT_SCHEMA_LIMIT,
+    min_score: float = DEFAULT_MIN_SCORE,
 ) -> list[EntityEdge]:
     # vector similarity search over embedded facts
     query = Query("""
+                CYPHER runtime = parallel parallelRuntimeSupport=all
                 MATCH (n:Entity)-[r:RELATES_TO]-(m:Entity)
                 WHERE ($group_ids IS NULL OR r.group_id IN $group_ids)
                 AND ($source_uuid IS NULL OR n.uuid = $source_uuid)
                 AND ($target_uuid IS NULL OR m.uuid = $target_uuid)
+                WITH n, r, m, vector.similarity.cosine(r.fact_embedding, $search_vector) AS score
+                WHERE score > $min_score
                 RETURN
-                    vector.similarity.cosine(r.fact_embedding, $search_vector) AS score,
                     r.uuid AS uuid,
                     r.group_id AS group_id,
                     n.uuid AS source_node_uuid,
@@ -185,6 +203,7 @@ async def edge_similarity_search(
         target_uuid=target_node_uuid,
         group_ids=group_ids,
         limit=limit,
+        min_score=min_score,
     )
 
     edges = [get_entity_edge_from_record(record) for record in records]
@@ -205,7 +224,6 @@ async def node_fulltext_search(
         """
     CALL db.index.fulltext.queryNodes("node_name_and_summary", $query) 
     YIELD node AS n, score
-    WHERE $group_ids IS NULL OR n.group_id IN $group_ids
     RETURN
         n.uuid AS uuid,
         n.group_id AS group_id, 
@@ -230,14 +248,17 @@ async def node_similarity_search(
     search_vector: list[float],
     group_ids: list[str] | None = None,
     limit=RELEVANT_SCHEMA_LIMIT,
+    min_score: float = DEFAULT_MIN_SCORE,
 ) -> list[EntityNode]:
     # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
         """
+                CYPHER runtime = parallel parallelRuntimeSupport=all
                 MATCH (n:Entity)
                 WHERE $group_ids IS NULL OR n.group_id IN $group_ids
+                WITH n, vector.similarity.cosine(n.name_embedding, $search_vector) AS score
+                WHERE score > $min_score
                 RETURN
-                    vector.similarity.cosine(n.name_embedding, $search_vector) AS score,
                     n.uuid As uuid,
                     n.group_id AS group_id,
                     n.name AS name, 
@@ -250,6 +271,7 @@ async def node_similarity_search(
         search_vector=search_vector,
         group_ids=group_ids,
         limit=limit,
+        min_score=min_score,
     )
     nodes = [get_entity_node_from_record(record) for record in records]
 
@@ -269,8 +291,6 @@ async def community_fulltext_search(
         """
     CALL db.index.fulltext.queryNodes("community_name", $query) 
     YIELD node AS comm, score
-    MATCH (comm:Community)
-    WHERE $group_ids IS NULL OR comm.group_id in $group_ids
     RETURN
         comm.uuid AS uuid,
         comm.group_id AS group_id, 
@@ -295,14 +315,17 @@ async def community_similarity_search(
     search_vector: list[float],
     group_ids: list[str] | None = None,
     limit=RELEVANT_SCHEMA_LIMIT,
+    min_score=DEFAULT_MIN_SCORE,
 ) -> list[CommunityNode]:
     # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
         """
+                CYPHER runtime = parallel parallelRuntimeSupport=all
                 MATCH (comm:Community)
                 WHERE ($group_ids IS NULL OR comm.group_id IN $group_ids)
+                WITH comm, vector.similarity.cosine(comm.name_embedding, $search_vector) AS score
+                WHERE score > $min_score
                 RETURN
-                    vector.similarity.cosine(comm.name_embedding, $search_vector) AS score,
                     comm.uuid As uuid,
                     comm.group_id AS group_id,
                     comm.name AS name, 
@@ -315,6 +338,7 @@ async def community_similarity_search(
         search_vector=search_vector,
         group_ids=group_ids,
         limit=limit,
+        min_score=min_score,
     )
     communities = [get_community_node_from_record(record) for record in records]
 
@@ -384,7 +408,7 @@ async def hybrid_node_search(
     relevant_nodes: list[EntityNode] = [node_uuid_map[uuid] for uuid in ranked_uuids]
 
     end = time()
-    logger.info(f'Found relevant nodes: {ranked_uuids} in {(end - start) * 1000} ms')
+    logger.debug(f'Found relevant nodes: {ranked_uuids} in {(end - start) * 1000} ms')
     return relevant_nodes
 
 
@@ -467,7 +491,7 @@ async def get_relevant_edges(
             relevant_edges.append(edge)
 
     end = time()
-    logger.info(f'Found relevant edges: {relevant_edge_uuids} in {(end - start) * 1000} ms')
+    logger.debug(f'Found relevant edges: {relevant_edge_uuids} in {(end - start) * 1000} ms')
 
     return relevant_edges
 
@@ -520,7 +544,7 @@ async def node_distance_reranker(
     # rerank on shortest distance
     filtered_uuids.sort(key=lambda cur_uuid: scores[cur_uuid])
 
-    # add back in filtered center uuids
+    # add back in filtered center uuid
     filtered_uuids = [center_node_uuid] + filtered_uuids
 
     return filtered_uuids
@@ -555,3 +579,19 @@ async def episode_mentions_reranker(driver: AsyncDriver, node_uuids: list[list[s
     sorted_uuids.sort(key=lambda cur_uuid: scores[cur_uuid])
 
     return sorted_uuids
+
+
+def maximal_marginal_relevance(
+    query_vector: list[float],
+    candidates: list[tuple[str, list[float]]],
+    mmr_lambda: float = DEFAULT_MMR_LAMBDA,
+):
+    candidates_with_mmr: list[tuple[str, float]] = []
+    for candidate in candidates:
+        max_sim = max([np.dot(normalize_l2(candidate[1]), normalize_l2(c[1])) for c in candidates])
+        mmr = mmr_lambda * np.dot(candidate[1], query_vector) - (1 - mmr_lambda) * max_sim
+        candidates_with_mmr.append((candidate[0], mmr))
+
+    candidates_with_mmr.sort(reverse=True, key=lambda c: c[1])
+
+    return [candidate[0] for candidate in candidates_with_mmr]

graphiti_core/utils/maintenance/__init__.py

@@ -4,7 +4,6 @@ from .graph_data_operations import (
     retrieve_episodes,
 )
 from .node_operations import extract_nodes
-from .temporal_operations import invalidate_edges
 
 __all__ = [
     'extract_edges',
@@ -12,5 +11,4 @@ __all__ = [
     'extract_nodes',
     'clear_data',
     'retrieve_episodes',
-    'invalidate_edges',
 ]

graphiti_core/utils/maintenance/community_operations.py

@@ -15,7 +15,6 @@ from graphiti_core.utils.maintenance.edge_operations import build_community_edge
 
 MAX_COMMUNITY_BUILD_CONCURRENCY = 10
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -24,31 +23,20 @@ class Neighbor(BaseModel):
     edge_count: int
 
 
-async def build_community_projection(driver: AsyncDriver) -> str:
-    records, _, _ = await driver.execute_query("""
-    CALL gds.graph.project("communities", "Entity",             
-        {RELATES_TO: {
-            type: "RELATES_TO",
-            orientation: "UNDIRECTED",
-            properties: {weight: {property: "*", aggregation: "COUNT"}}
-        }}
-    )
-    YIELD graphName AS graph, nodeProjection AS nodes, relationshipProjection AS edges
-    """)
-
-    return records[0]['graph']
-
-
-async def get_community_clusters(driver: AsyncDriver) -> list[list[EntityNode]]:
+async def get_community_clusters(
+    driver: AsyncDriver, group_ids: list[str] | None
+) -> list[list[EntityNode]]:
     community_clusters: list[list[EntityNode]] = []
 
-    group_id_values, _, _ = await driver.execute_query("""
-    MATCH (n:Entity WHERE n.group_id IS NOT NULL)
-    RETURN 
-        collect(DISTINCT n.group_id) AS group_ids
-    """)
+    if group_ids is None:
+        group_id_values, _, _ = await driver.execute_query("""
+        MATCH (n:Entity WHERE n.group_id IS NOT NULL)
+        RETURN 
+            collect(DISTINCT n.group_id) AS group_ids
+        """)
+
+        group_ids = group_id_values[0]['group_ids']
 
-    group_ids = group_id_values[0]['group_ids']
     for group_id in group_ids:
         projection: dict[str, list[Neighbor]] = {}
         nodes = await EntityNode.get_by_group_ids(driver, [group_id])
@@ -191,15 +179,15 @@ async def build_community(
     )
     community_edges = build_community_edges(community_cluster, community_node, now)
 
-    logger.info((community_node, community_edges))
+    logger.debug((community_node, community_edges))
 
     return community_node, community_edges
 
 
 async def build_communities(
-    driver: AsyncDriver, llm_client: LLMClient
+    driver: AsyncDriver, llm_client: LLMClient, group_ids: list[str] | None
 ) -> tuple[list[CommunityNode], list[CommunityEdge]]:
-    community_clusters = await get_community_clusters(driver)
+    community_clusters = await get_community_clusters(driver, group_ids)
 
     semaphore = asyncio.Semaphore(MAX_COMMUNITY_BUILD_CONCURRENCY)
 

graphiti_core/utils/maintenance/edge_operations.py

@@ -97,7 +97,7 @@ async def extract_edges(
     edges_data = llm_response.get('edges', [])
 
     end = time()
-    logger.info(f'Extracted new edges: {edges_data} in {(end - start) * 1000} ms')
+    logger.debug(f'Extracted new edges: {edges_data} in {(end - start) * 1000} ms')
 
     # Convert the extracted data into EntityEdge objects
     edges = []
@@ -115,19 +115,13 @@ async def extract_edges(
                 invalid_at=None,
             )
             edges.append(edge)
-            logger.info(
+            logger.debug(
                 f'Created new edge: {edge.name} from (UUID: {edge.source_node_uuid}) to (UUID: {edge.target_node_uuid})'
             )
 
     return edges
 
 
-def create_edge_identifier(
-    source_node: EntityNode, edge: EntityEdge, target_node: EntityNode
-) -> str:
-    return f'{source_node.name}-{edge.name}-{target_node.name}'
-
-
 async def dedupe_extracted_edges(
     llm_client: LLMClient,
     extracted_edges: list[EntityEdge],
@@ -150,7 +144,7 @@ async def dedupe_extracted_edges(
 
     llm_response = await llm_client.generate_response(prompt_library.dedupe_edges.v1(context))
     duplicate_data = llm_response.get('duplicates', [])
-    logger.info(f'Extracted unique edges: {duplicate_data}')
+    logger.debug(f'Extracted unique edges: {duplicate_data}')
 
     duplicate_uuid_map: dict[str, str] = {}
     for duplicate in duplicate_data:
@@ -251,11 +245,11 @@ async def resolve_extracted_edge(
         if (
             edge.invalid_at is not None
             and resolved_edge.valid_at is not None
-            and edge.invalid_at < resolved_edge.valid_at
+            and edge.invalid_at <= resolved_edge.valid_at
         ) or (
             edge.valid_at is not None
             and resolved_edge.invalid_at is not None
-            and resolved_edge.invalid_at < edge.valid_at
+            and resolved_edge.invalid_at <= edge.valid_at
         ):
             continue
         # New edge invalidates edge
@@ -305,7 +299,7 @@ async def dedupe_extracted_edge(
             edge = existing_edge
 
     end = time()
-    logger.info(
+    logger.debug(
         f'Resolved Edge: {extracted_edge.name} is {edge.name}, in {(end - start) * 1000} ms'
     )
 
@@ -332,7 +326,7 @@ async def dedupe_edge_list(
     unique_edges_data = llm_response.get('unique_facts', [])
 
     end = time()
-    logger.info(f'Extracted edge duplicates: {unique_edges_data} in {(end - start) * 1000} ms ')
+    logger.debug(f'Extracted edge duplicates: {unique_edges_data} in {(end - start) * 1000} ms ')
 
     # Get full edge data
     unique_edges = []

graphiti_core/utils/maintenance/node_operations.py

@@ -104,7 +104,7 @@ async def extract_nodes(
         extracted_node_data = await extract_json_nodes(llm_client, episode)
 
     end = time()
-    logger.info(f'Extracted new nodes: {extracted_node_data} in {(end - start) * 1000} ms')
+    logger.debug(f'Extracted new nodes: {extracted_node_data} in {(end - start) * 1000} ms')
     # Convert the extracted data into EntityNode objects
     new_nodes = []
     for node_data in extracted_node_data:
@@ -116,7 +116,7 @@ async def extract_nodes(
             created_at=datetime.now(),
         )
         new_nodes.append(new_node)
-        logger.info(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
+        logger.debug(f'Created new node: {new_node.name} (UUID: {new_node.uuid})')
 
     return new_nodes
 
@@ -152,7 +152,7 @@ async def dedupe_extracted_nodes(
     duplicate_data = llm_response.get('duplicates', [])
 
     end = time()
-    logger.info(f'Deduplicated nodes: {duplicate_data} in {(end - start) * 1000} ms')
+    logger.debug(f'Deduplicated nodes: {duplicate_data} in {(end - start) * 1000} ms')
 
     uuid_map: dict[str, str] = {}
     for duplicate in duplicate_data:
@@ -232,7 +232,7 @@ async def resolve_extracted_node(
             uuid_map[extracted_node.uuid] = existing_node.uuid
 
     end = time()
-    logger.info(
+    logger.debug(
         f'Resolved node: {extracted_node.name} is {node.name}, in {(end - start) * 1000} ms'
     )
 
@@ -266,7 +266,7 @@ async def dedupe_node_list(
     nodes_data = llm_response.get('nodes', [])
 
     end = time()
-    logger.info(f'Deduplicated nodes: {nodes_data} in {(end - start) * 1000} ms')
+    logger.debug(f'Deduplicated nodes: {nodes_data} in {(end - start) * 1000} ms')
 
     # Get full node data
     unique_nodes = []

graphiti_core/utils/maintenance/temporal_operations.py

@@ -21,129 +21,11 @@ from typing import List
 
 from graphiti_core.edges import EntityEdge
 from graphiti_core.llm_client import LLMClient
-from graphiti_core.nodes import EntityNode, EpisodicNode
+from graphiti_core.nodes import EpisodicNode
 from graphiti_core.prompts import prompt_library
 
 logger = logging.getLogger(__name__)
 
-NodeEdgeNodeTriplet = tuple[EntityNode, EntityEdge, EntityNode]
-
-
-def extract_node_and_edge_triplets(
-    edges: list[EntityEdge], nodes: list[EntityNode]
-) -> list[NodeEdgeNodeTriplet]:
-    return [extract_node_edge_node_triplet(edge, nodes) for edge in edges]
-
-
-def extract_node_edge_node_triplet(
-    edge: EntityEdge, nodes: list[EntityNode]
-) -> NodeEdgeNodeTriplet:
-    source_node = next((node for node in nodes if node.uuid == edge.source_node_uuid), None)
-    target_node = next((node for node in nodes if node.uuid == edge.target_node_uuid), None)
-    if not source_node or not target_node:
-        raise ValueError(f'Source or target node not found for edge {edge.uuid}')
-    return (source_node, edge, target_node)
-
-
-def prepare_edges_for_invalidation(
-    existing_edges: list[EntityEdge],
-    new_edges: list[EntityEdge],
-    nodes: list[EntityNode],
-) -> tuple[list[NodeEdgeNodeTriplet], list[NodeEdgeNodeTriplet]]:
-    existing_edges_pending_invalidation: list[NodeEdgeNodeTriplet] = []
-    new_edges_with_nodes: list[NodeEdgeNodeTriplet] = []
-
-    for edge_list, result_list in [
-        (existing_edges, existing_edges_pending_invalidation),
-        (new_edges, new_edges_with_nodes),
-    ]:
-        for edge in edge_list:
-            source_node = next((node for node in nodes if node.uuid == edge.source_node_uuid), None)
-            target_node = next((node for node in nodes if node.uuid == edge.target_node_uuid), None)
-
-            if source_node and target_node:
-                result_list.append((source_node, edge, target_node))
-
-    return existing_edges_pending_invalidation, new_edges_with_nodes
-
-
-async def invalidate_edges(
-    llm_client: LLMClient,
-    existing_edges_pending_invalidation: list[NodeEdgeNodeTriplet],
-    new_edges: list[NodeEdgeNodeTriplet],
-    current_episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
-) -> list[EntityEdge]:
-    invalidated_edges = []  # TODO: this is not yet used?
-
-    context = prepare_invalidation_context(
-        existing_edges_pending_invalidation,
-        new_edges,
-        current_episode,
-        previous_episodes,
-    )
-    llm_response = await llm_client.generate_response(prompt_library.invalidate_edges.v1(context))
-
-    edges_to_invalidate = llm_response.get('invalidated_edges', [])
-    invalidated_edges = process_edge_invalidation_llm_response(
-        edges_to_invalidate, existing_edges_pending_invalidation
-    )
-
-    return invalidated_edges
-
-
-def extract_date_strings_from_edge(edge: EntityEdge) -> str:
-    start = edge.valid_at
-    end = edge.invalid_at
-    date_string = f'Start Date: {start.isoformat()}' if start else ''
-    if end:
-        date_string += f' (End Date: {end.isoformat()})'
-    return date_string
-
-
-def prepare_invalidation_context(
-    existing_edges: list[NodeEdgeNodeTriplet],
-    new_edges: list[NodeEdgeNodeTriplet],
-    current_episode: EpisodicNode,
-    previous_episodes: list[EpisodicNode],
-) -> dict:
-    return {
-        'existing_edges': [
-            f'{edge.uuid} | {source_node.name} - {edge.name} - {target_node.name} (Fact: {edge.fact}) {extract_date_strings_from_edge(edge)}'
-            for source_node, edge, target_node in sorted(
-                existing_edges, key=lambda x: (x[1].created_at), reverse=True
-            )
-        ],
-        'new_edges': [
-            f'{edge.uuid} | {source_node.name} - {edge.name} - {target_node.name} (Fact: {edge.fact}) {extract_date_strings_from_edge(edge)}'
-            for source_node, edge, target_node in sorted(
-                new_edges, key=lambda x: (x[1].created_at), reverse=True
-            )
-        ],
-        'current_episode': current_episode.content,
-        'previous_episodes': [episode.content for episode in previous_episodes],
-    }
-
-
-def process_edge_invalidation_llm_response(
-    edges_to_invalidate: List[dict], existing_edges: List[NodeEdgeNodeTriplet]
-) -> List[EntityEdge]:
-    invalidated_edges = []
-    for edge_to_invalidate in edges_to_invalidate:
-        edge_uuid = edge_to_invalidate['edge_uuid']
-        edge_to_update = next(
-            (edge for _, edge, _ in existing_edges if edge.uuid == edge_uuid),
-            None,
-        )
-        if edge_to_update:
-            edge_to_update.expired_at = datetime.now()
-            edge_to_update.fact = edge_to_invalidate['fact']
-            invalidated_edges.append(edge_to_update)
-            logger.info(
-                f"Invalidated edge: {edge_to_update.name} (UUID: {edge_to_update.uuid}). Updated Fact: {edge_to_invalidate['fact']}"
-            )
-    return invalidated_edges
-
 
 async def extract_edge_dates(
     llm_client: LLMClient,
@@ -152,7 +34,6 @@ async def extract_edge_dates(
     previous_episodes: List[EpisodicNode],
 ) -> tuple[datetime | None, datetime | None]:
     context = {
-        'edge_name': edge.name,
         'edge_fact': edge.fact,
         'current_episode': current_episode.content,
         'previous_episodes': [ep.content for ep in previous_episodes],
@@ -162,25 +43,22 @@ async def extract_edge_dates(
 
     valid_at = llm_response.get('valid_at')
     invalid_at = llm_response.get('invalid_at')
-    explanation = llm_response.get('explanation', '')
 
     valid_at_datetime = None
     invalid_at_datetime = None
 
-    if valid_at and valid_at != '':
+    if valid_at:
         try:
             valid_at_datetime = datetime.fromisoformat(valid_at.replace('Z', '+00:00'))
         except ValueError as e:
             logger.error(f'Error parsing valid_at date: {e}. Input: {valid_at}')
 
-    if invalid_at and invalid_at != '':
+    if invalid_at:
         try:
             invalid_at_datetime = datetime.fromisoformat(invalid_at.replace('Z', '+00:00'))
         except ValueError as e:
             logger.error(f'Error parsing invalid_at date: {e}. Input: {invalid_at}')
 
-    logger.info(f'Edge date extraction explanation: {explanation}')
-
     return valid_at_datetime, invalid_at_datetime
 
 
@@ -210,7 +88,7 @@ async def get_edge_contradictions(
             contradicted_edges.append(contradicted_edge)
 
     end = time()
-    logger.info(
+    logger.debug(
         f'Found invalidated edge candidates from {new_edge.fact}, in {(end - start) * 1000} ms'
     )