graphiti-core 0.3.9__tar.gz → 0.3.12__tar.gz

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.3.9
+Version: 0.3.12
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/edges.py

@@ -51,7 +51,7 @@ class Edge(BaseModel, ABC):
             uuid=self.uuid,
         )
 
-        logger.info(f'Deleted Edge: {self.uuid}')
+        logger.debug(f'Deleted Edge: {self.uuid}')
 
         return result
 
@@ -83,7 +83,7 @@ class EpisodicEdge(Edge):
             created_at=self.created_at,
         )
 
-        logger.info(f'Saved edge to neo4j: {self.uuid}')
+        logger.debug(f'Saved edge to neo4j: {self.uuid}')
 
         return result
 
@@ -178,7 +178,7 @@ class EntityEdge(Edge):
         self.fact_embedding = await embedder.create(input=[text])
 
         end = time()
-        logger.info(f'embedded {text} in {end - start} ms')
+        logger.debug(f'embedded {text} in {end - start} ms')
 
         return self.fact_embedding
 
@@ -206,7 +206,7 @@ class EntityEdge(Edge):
             invalid_at=self.invalid_at,
         )
 
-        logger.info(f'Saved edge to neo4j: {self.uuid}')
+        logger.debug(f'Saved edge to neo4j: {self.uuid}')
 
         return result
 
@@ -313,7 +313,7 @@ class CommunityEdge(Edge):
             created_at=self.created_at,
         )
 
-        logger.info(f'Saved edge to neo4j: {self.uuid}')
+        logger.debug(f'Saved edge to neo4j: {self.uuid}')
 
         return result
 

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/embedder/openai.py

@@ -42,7 +42,7 @@ class OpenAIEmbedder(EmbedderClient):
         self.client = AsyncOpenAI(api_key=config.api_key, base_url=config.base_url)
 
     async def create(
-            self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
+        self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
     ) -> list[float]:
         result = await self.client.embeddings.create(input=input, model=self.config.embedding_model)
         return result.data[0].embedding[: self.config.embedding_dim]

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/embedder/voyage.py

@@ -41,7 +41,7 @@ class VoyageAIEmbedder(EmbedderClient):
         self.client = voyageai.AsyncClient(api_key=config.api_key)
 
     async def create(
-            self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
+        self, input: str | List[str] | Iterable[int] | Iterable[Iterable[int]]
     ) -> list[float]:
         result = await self.client.embed(input, model=self.config.embedding_model)
         return result.embeddings[0][: self.config.embedding_dim]

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/errors.py

@@ -35,6 +35,14 @@ class GroupsEdgesNotFoundError(GraphitiError):
         super().__init__(self.message)
 
 
+class GroupsNodesNotFoundError(GraphitiError):
+    """Raised when no nodes are found for a list of group ids."""
+
+    def __init__(self, group_ids: list[str]):
+        self.message = f'no nodes found for group ids {group_ids}'
+        super().__init__(self.message)
+
+
 class NodeNotFoundError(GraphitiError):
     """Raised when a node is not found."""
 

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/graphiti.py

@@ -319,13 +319,11 @@ class Graphiti:
                 valid_at=reference_time,
             )
             episode.uuid = uuid if uuid is not None else episode.uuid
-            if not self.store_raw_episode_content:
-                episode.content = ''
 
             # Extract entities as nodes
 
             extracted_nodes = await extract_nodes(self.llm_client, episode, previous_episodes)
-            logger.info(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
+            logger.debug(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
 
             # Calculate Embeddings
 
@@ -340,7 +338,7 @@ class Graphiti:
                 )
             )
 
-            logger.info(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
+            logger.debug(f'Extracted nodes: {[(n.name, n.uuid) for n in extracted_nodes]}')
 
             (mentioned_nodes, uuid_map), extracted_edges = await asyncio.gather(
                 resolve_extracted_nodes(self.llm_client, extracted_nodes, existing_nodes_lists),
@@ -348,7 +346,7 @@ class Graphiti:
                     self.llm_client, episode, extracted_nodes, previous_episodes, group_id
                 ),
             )
-            logger.info(f'Adjusted mentioned nodes: {[(n.name, n.uuid) for n in mentioned_nodes]}')
+            logger.debug(f'Adjusted mentioned nodes: {[(n.name, n.uuid) for n in mentioned_nodes]}')
             nodes = mentioned_nodes
 
             extracted_edges_with_resolved_pointers = resolve_edge_pointers(
@@ -378,10 +376,10 @@ class Graphiti:
                     ]
                 )
             )
-            logger.info(
+            logger.debug(
                 f'Related edges lists: {[(e.name, e.uuid) for edges_lst in related_edges_list for e in edges_lst]}'
             )
-            logger.info(
+            logger.debug(
                 f'Extracted edges: {[(e.name, e.uuid) for e in extracted_edges_with_resolved_pointers]}'
             )
 
@@ -433,15 +431,18 @@ class Graphiti:
 
             entity_edges.extend(resolved_edges + invalidated_edges)
 
-            logger.info(f'Resolved edges: {[(e.name, e.uuid) for e in resolved_edges]}')
+            logger.debug(f'Resolved edges: {[(e.name, e.uuid) for e in resolved_edges]}')
 
             episodic_edges: list[EpisodicEdge] = build_episodic_edges(mentioned_nodes, episode, now)
 
-            logger.info(f'Built episodic edges: {episodic_edges}')
+            logger.debug(f'Built episodic edges: {episodic_edges}')
 
             episode.entity_edges = [edge.uuid for edge in entity_edges]
 
             # Future optimization would be using batch operations to save nodes and edges
+            if not self.store_raw_episode_content:
+                episode.content = ''
+
             await episode.save(self.driver)
             await asyncio.gather(*[node.save(self.driver) for node in nodes])
             await asyncio.gather(*[edge.save(self.driver) for edge in episodic_edges])
@@ -563,7 +564,7 @@ class Graphiti:
             edges = await dedupe_edges_bulk(
                 self.driver, self.llm_client, extracted_edges_with_resolved_pointers
             )
-            logger.info(f'extracted edge length: {len(edges)}')
+            logger.debug(f'extracted edge length: {len(edges)}')
 
             # invalidate edges
 

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/nodes.py

@@ -86,7 +86,7 @@ class Node(BaseModel, ABC):
             uuid=self.uuid,
         )
 
-        logger.info(f'Deleted Node: {self.uuid}')
+        logger.debug(f'Deleted Node: {self.uuid}')
 
         return result
 
@@ -135,7 +135,7 @@ class EpisodicNode(Node):
             source=self.source.value,
         )
 
-        logger.info(f'Saved Node to neo4j: {self.uuid}')
+        logger.debug(f'Saved Node to neo4j: {self.uuid}')
 
         return result
 
@@ -217,7 +217,7 @@ class EntityNode(Node):
         text = self.name.replace('\n', ' ')
         self.name_embedding = await embedder.create(input=[text])
         end = time()
-        logger.info(f'embedded {text} in {end - start} ms')
+        logger.debug(f'embedded {text} in {end - start} ms')
 
         return self.name_embedding
 
@@ -236,7 +236,7 @@ class EntityNode(Node):
             created_at=self.created_at,
         )
 
-        logger.info(f'Saved Node to neo4j: {self.uuid}')
+        logger.debug(f'Saved Node to neo4j: {self.uuid}')
 
         return result
 
@@ -258,6 +258,9 @@ class EntityNode(Node):
 
         nodes = [get_entity_node_from_record(record) for record in records]
 
+        if len(nodes) == 0:
+            raise NodeNotFoundError(uuid)
+
         return nodes[0]
 
     @classmethod
@@ -320,7 +323,7 @@ class CommunityNode(Node):
             created_at=self.created_at,
         )
 
-        logger.info(f'Saved Node to neo4j: {self.uuid}')
+        logger.debug(f'Saved Node to neo4j: {self.uuid}')
 
         return result
 
@@ -329,7 +332,7 @@ class CommunityNode(Node):
         text = self.name.replace('\n', ' ')
         self.name_embedding = await embedder.create(input=[text])
         end = time()
-        logger.info(f'embedded {text} in {end - start} ms')
+        logger.debug(f'embedded {text} in {end - start} ms')
 
         return self.name_embedding
 
@@ -351,6 +354,9 @@ class CommunityNode(Node):
 
         nodes = [get_community_node_from_record(record) for record in records]
 
+        if len(nodes) == 0:
+            raise NodeNotFoundError(uuid)
+
         return nodes[0]
 
     @classmethod

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/search/search.py

@@ -160,7 +160,7 @@ async def edge_search(
         for edge in sorted_results:
             source_to_edge_uuid_map[edge.source_node_uuid].append(edge.uuid)
 
-        source_uuids = [edge.source_node_uuid for edge in sorted_results]
+        source_uuids = [source_node_uuid for source_node_uuid in source_to_edge_uuid_map]
 
         reranked_node_uuids = await node_distance_reranker(driver, source_uuids, center_node_uuid)
 

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/search/search_config_recipes.py

@@ -68,7 +68,7 @@ EDGE_HYBRID_SEARCH_RRF = SearchConfig(
 )
 
 # performs a hybrid search over edges with mmr reranking
-EDGE_HYBRID_SEARCH_mmr = SearchConfig(
+EDGE_HYBRID_SEARCH_MMR = SearchConfig(
     edge_config=EdgeSearchConfig(
         search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
         reranker=EdgeReranker.mmr,
@@ -80,7 +80,8 @@ 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

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/search/search_utils.py

@@ -49,17 +49,17 @@ def fulltext_query(query: str, group_ids: list[str] | None = None):
 
     group_ids_filter += ' AND ' if group_ids_filter else ''
 
-    fuzzy_query = lucene_sanitize(query) + '~'
-    full_query = group_ids_filter + fuzzy_query
+    lucene_query = lucene_sanitize(query)
+    full_query = group_ids_filter + lucene_query
 
     return full_query
 
 
 async def get_episodes_by_mentions(
-        driver: AsyncDriver,
-        nodes: list[EntityNode],
-        edges: list[EntityEdge],
-        limit: int = RELEVANT_SCHEMA_LIMIT,
+    driver: AsyncDriver,
+    nodes: list[EntityNode],
+    edges: list[EntityEdge],
+    limit: int = RELEVANT_SCHEMA_LIMIT,
 ) -> list[EpisodicNode]:
     episode_uuids: list[str] = []
     for edge in edges:
@@ -71,7 +71,7 @@ async def get_episodes_by_mentions(
 
 
 async def get_mentioned_nodes(
-        driver: AsyncDriver, episodes: list[EpisodicNode]
+    driver: AsyncDriver, episodes: list[EpisodicNode]
 ) -> list[EntityNode]:
     episode_uuids = [episode.uuid for episode in episodes]
     records, _, _ = await driver.execute_query(
@@ -94,7 +94,7 @@ async def get_mentioned_nodes(
 
 
 async def get_communities_by_nodes(
-        driver: AsyncDriver, nodes: list[EntityNode]
+    driver: AsyncDriver, nodes: list[EntityNode]
 ) -> list[CommunityNode]:
     node_uuids = [node.uuid for node in nodes]
     records, _, _ = await driver.execute_query(
@@ -117,12 +117,12 @@ async def get_communities_by_nodes(
 
 
 async def edge_fulltext_search(
-        driver: AsyncDriver,
-        query: str,
-        source_node_uuid: str | None,
-        target_node_uuid: str | None,
-        group_ids: list[str] | None = None,
-        limit=RELEVANT_SCHEMA_LIMIT,
+    driver: AsyncDriver,
+    query: str,
+    source_node_uuid: str | None,
+    target_node_uuid: str | None,
+    group_ids: list[str] | None = None,
+    limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
     # fulltext search over facts
     fuzzy_query = fulltext_query(query, group_ids)
@@ -162,13 +162,13 @@ async def edge_fulltext_search(
 
 
 async def edge_similarity_search(
-        driver: AsyncDriver,
-        search_vector: list[float],
-        source_node_uuid: str | None,
-        target_node_uuid: str | None,
-        group_ids: list[str] | None = None,
-        limit: int = RELEVANT_SCHEMA_LIMIT,
-        min_score: float = DEFAULT_MIN_SCORE,
+    driver: AsyncDriver,
+    search_vector: list[float],
+    source_node_uuid: str | None,
+    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("""
@@ -212,10 +212,10 @@ async def edge_similarity_search(
 
 
 async def node_fulltext_search(
-        driver: AsyncDriver,
-        query: str,
-        group_ids: list[str] | None = None,
-        limit=RELEVANT_SCHEMA_LIMIT,
+    driver: AsyncDriver,
+    query: str,
+    group_ids: list[str] | None = None,
+    limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityNode]:
     # BM25 search to get top nodes
     fuzzy_query = fulltext_query(query, group_ids)
@@ -244,11 +244,11 @@ async def node_fulltext_search(
 
 
 async def node_similarity_search(
-        driver: AsyncDriver,
-        search_vector: list[float],
-        group_ids: list[str] | None = None,
-        limit=RELEVANT_SCHEMA_LIMIT,
-        min_score: float = DEFAULT_MIN_SCORE,
+    driver: AsyncDriver,
+    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(
@@ -279,10 +279,10 @@ async def node_similarity_search(
 
 
 async def community_fulltext_search(
-        driver: AsyncDriver,
-        query: str,
-        group_ids: list[str] | None = None,
-        limit=RELEVANT_SCHEMA_LIMIT,
+    driver: AsyncDriver,
+    query: str,
+    group_ids: list[str] | None = None,
+    limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[CommunityNode]:
     # BM25 search to get top communities
     fuzzy_query = fulltext_query(query, group_ids)
@@ -311,11 +311,11 @@ async def community_fulltext_search(
 
 
 async def community_similarity_search(
-        driver: AsyncDriver,
-        search_vector: list[float],
-        group_ids: list[str] | None = None,
-        limit=RELEVANT_SCHEMA_LIMIT,
-        min_score=DEFAULT_MIN_SCORE,
+    driver: AsyncDriver,
+    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(
@@ -346,11 +346,11 @@ async def community_similarity_search(
 
 
 async def hybrid_node_search(
-        queries: list[str],
-        embeddings: list[list[float]],
-        driver: AsyncDriver,
-        group_ids: list[str] | None = None,
-        limit: int = RELEVANT_SCHEMA_LIMIT,
+    queries: list[str],
+    embeddings: list[list[float]],
+    driver: AsyncDriver,
+    group_ids: list[str] | None = None,
+    limit: int = RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityNode]:
     """
     Perform a hybrid search for nodes using both text queries and embeddings.
@@ -408,13 +408,13 @@ 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
 
 
 async def get_relevant_nodes(
-        nodes: list[EntityNode],
-        driver: AsyncDriver,
+    nodes: list[EntityNode],
+    driver: AsyncDriver,
 ) -> list[EntityNode]:
     """
     Retrieve relevant nodes based on the provided list of EntityNodes.
@@ -451,11 +451,11 @@ async def get_relevant_nodes(
 
 
 async def get_relevant_edges(
-        driver: AsyncDriver,
-        edges: list[EntityEdge],
-        source_node_uuid: str | None,
-        target_node_uuid: str | None,
-        limit: int = RELEVANT_SCHEMA_LIMIT,
+    driver: AsyncDriver,
+    edges: list[EntityEdge],
+    source_node_uuid: str | None,
+    target_node_uuid: str | None,
+    limit: int = RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
     start = time()
     relevant_edges: list[EntityEdge] = []
@@ -491,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
 
@@ -512,7 +512,7 @@ def rrf(results: list[list[str]], rank_const=1) -> list[str]:
 
 
 async def node_distance_reranker(
-        driver: AsyncDriver, node_uuids: list[str], center_node_uuid: str
+    driver: AsyncDriver, node_uuids: list[str], center_node_uuid: str
 ) -> list[str]:
     # filter out node_uuid center node node uuid
     filtered_uuids = list(filter(lambda uuid: uuid != center_node_uuid, node_uuids))
@@ -544,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
@@ -582,19 +582,14 @@ async def episode_mentions_reranker(driver: AsyncDriver, node_uuids: list[list[s
 
 
 def maximal_marginal_relevance(
-        query_vector: list[float],
-        candidates: list[tuple[str, list[float]]],
-        mmr_lambda: float = DEFAULT_MMR_LAMBDA,
+    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
+        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])

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/graphiti_core/utils/maintenance/community_operations.py

@@ -179,7 +179,7 @@ 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
 

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/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,7 +115,7 @@ 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})'
             )
 
@@ -144,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:
@@ -299,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'
     )
 
@@ -326,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-0.3.9 → graphiti_core-0.3.12}/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-0.3.9 → graphiti_core-0.3.12}/graphiti_core/utils/maintenance/temporal_operations.py

@@ -88,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'
     )
 

{graphiti_core-0.3.9 → graphiti_core-0.3.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "graphiti-core"
-version = "0.3.9"
+version = "0.3.12"
 description = "A temporal graph building library"
 authors = [
     "Paul Paliychuk <paul@getzep.com>",