graphiti-core 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

graphiti_core/errors.py

@@ -1,3 +1,20 @@
+"""
+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.
+"""
+
+
 class GraphitiError(Exception):
     """Base exception class for Graphiti Core."""
 
@@ -16,3 +33,11 @@ class NodeNotFoundError(GraphitiError):
     def __init__(self, uuid: str):
         self.message = f'node {uuid} not found'
         super().__init__(self.message)
+
+
+class SearchRerankerError(GraphitiError):
+    """Raised when a node is not found."""
+
+    def __init__(self, text: str):
+        self.message = text
+        super().__init__(self.message)

graphiti_core/graphiti.py

@@ -24,14 +24,19 @@ from neo4j import AsyncGraphDatabase
 
 from graphiti_core.edges import EntityEdge, EpisodicEdge
 from graphiti_core.llm_client import LLMClient, OpenAIClient
-from graphiti_core.llm_client.utils import generate_embedding
 from graphiti_core.nodes import EntityNode, EpisodeType, EpisodicNode
-from graphiti_core.search.search import Reranker, SearchConfig, SearchMethod, hybrid_search
+from graphiti_core.search.search import SearchConfig, search
+from graphiti_core.search.search_config import DEFAULT_SEARCH_LIMIT, SearchResults
+from graphiti_core.search.search_config_recipes import (
+    EDGE_HYBRID_SEARCH_NODE_DISTANCE,
+    EDGE_HYBRID_SEARCH_RRF,
+    NODE_HYBRID_SEARCH_NODE_DISTANCE,
+    NODE_HYBRID_SEARCH_RRF,
+)
 from graphiti_core.search.search_utils import (
     RELEVANT_SCHEMA_LIMIT,
     get_relevant_edges,
     get_relevant_nodes,
-    hybrid_node_search,
 )
 from graphiti_core.utils import (
     build_episodic_edges,
@@ -548,7 +553,7 @@ class Graphiti:
         query: str,
         center_node_uuid: str | None = None,
         group_ids: list[str | None] | None = None,
-        num_results=10,
+        num_results=DEFAULT_SEARCH_LIMIT,
     ):
         """
         Perform a hybrid search on the knowledge graph.
@@ -564,7 +569,7 @@ class Graphiti:
             Facts will be reranked based on proximity to this node
         group_ids : list[str | None] | None, optional
             The graph partitions to return data from.
-        num_results : int, optional
+        limit : int, optional
             The maximum number of results to return. Defaults to 10.
 
         Returns
@@ -581,21 +586,17 @@ class Graphiti:
         The search is performed using the current date and time as the reference
         point for temporal relevance.
         """
-        reranker = Reranker.rrf if center_node_uuid is None else Reranker.node_distance
-        search_config = SearchConfig(
-            num_episodes=0,
-            num_edges=num_results,
-            num_nodes=0,
-            group_ids=group_ids,
-            search_methods=[SearchMethod.bm25, SearchMethod.cosine_similarity],
-            reranker=reranker,
+        search_config = (
+            EDGE_HYBRID_SEARCH_RRF if center_node_uuid is None else EDGE_HYBRID_SEARCH_NODE_DISTANCE
         )
+        search_config.limit = num_results
+
         edges = (
-            await hybrid_search(
+            await search(
                 self.driver,
                 self.llm_client.get_embedder(),
                 query,
-                datetime.now(),
+                group_ids,
                 search_config,
                 center_node_uuid,
             )
@@ -606,19 +607,20 @@ class Graphiti:
     async def _search(
         self,
         query: str,
-        timestamp: datetime,
         config: SearchConfig,
+        group_ids: list[str | None] | None = None,
         center_node_uuid: str | None = None,
-    ):
-        return await hybrid_search(
-            self.driver, self.llm_client.get_embedder(), query, timestamp, config, center_node_uuid
+    ) -> SearchResults:
+        return await search(
+            self.driver, self.llm_client.get_embedder(), query, group_ids, config, center_node_uuid
         )
 
     async def get_nodes_by_query(
         self,
         query: str,
+        center_node_uuid: str | None = None,
         group_ids: list[str | None] | None = None,
-        limit: int = RELEVANT_SCHEMA_LIMIT,
+        limit: int = DEFAULT_SEARCH_LIMIT,
     ) -> list[EntityNode]:
         """
         Retrieve nodes from the graph database based on a text query.
@@ -629,7 +631,9 @@ class Graphiti:
         Parameters
         ----------
         query : str
-            The text query to search for in the graph.
+            The text query to search for in the graph
+        center_node_uuid: str, optional
+            Facts will be reranked based on proximity to this node.
         group_ids : list[str | None] | None, optional
             The graph partitions to return data from.
         limit : int | None, optional
@@ -655,8 +659,12 @@ class Graphiti:
         If not specified, a default limit (defined in the search functions) will be used.
         """
         embedder = self.llm_client.get_embedder()
-        query_embedding = await generate_embedding(embedder, query)
-        relevant_nodes = await hybrid_node_search(
-            [query], [query_embedding], self.driver, group_ids, limit
+        search_config = (
+            NODE_HYBRID_SEARCH_RRF if center_node_uuid is None else NODE_HYBRID_SEARCH_NODE_DISTANCE
         )
-        return relevant_nodes
+        search_config.limit = limit
+
+        nodes = (
+            await search(self.driver, embedder, query, group_ids, search_config, center_node_uuid)
+        ).nodes
+        return nodes

graphiti_core/helpers.py

@@ -1,3 +1,19 @@
+"""
+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 datetime import datetime
 
 from neo4j import time as neo4j_time

graphiti_core/llm_client/errors.py

@@ -1,3 +1,20 @@
+"""
+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.
+"""
+
+
 class RateLimitError(Exception):
     """Exception raised when the rate limit is exceeded."""
 

graphiti_core/llm_client/utils.py

@@ -1,3 +1,19 @@
+"""
+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.
+"""
+
 import logging
 import typing
 from time import time
@@ -17,6 +33,6 @@ async def generate_embedding(
     embedding = embedding[:EMBEDDING_DIM]
 
     end = time()
-    logger.debug(f'embedded text of length {len(text)} in {end-start} ms')
+    logger.debug(f'embedded text of length {len(text)} in {end - start} ms')
 
     return embedding

graphiti_core/nodes.py

@@ -175,7 +175,7 @@ class EpisodicNode(Node):
             e.valid_at AS valid_at,
             e.uuid AS uuid,
             e.name AS name,
-            e.group_id AS group_id
+            e.group_id AS group_id,
             e.source_description AS source_description,
             e.source AS source
         """,
@@ -230,7 +230,7 @@ class EntityNode(Node):
             n.uuid As uuid, 
             n.name AS name,
             n.name_embedding AS name_embedding,
-            n.group_id AS group_id
+            n.group_id AS group_id,
             n.created_at AS created_at, 
             n.summary AS summary
         """,
@@ -307,7 +307,7 @@ class CommunityNode(Node):
             n.uuid As uuid, 
             n.name AS name,
             n.name_embedding AS name_embedding,
-            n.group_id AS group_id
+            n.group_id AS group_id,
             n.created_at AS created_at, 
             n.summary AS summary
         """,
@@ -329,7 +329,7 @@ class CommunityNode(Node):
             n.uuid As uuid, 
             n.name AS name,
             n.name_embedding AS name_embedding,
-            n.group_id AS group_id
+            n.group_id AS group_id,
             n.created_at AS created_at, 
             n.summary AS summary
         """,

graphiti_core/prompts/extract_edge_dates.py

@@ -1,3 +1,19 @@
+"""
+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 typing import Any, Protocol, TypedDict
 
 from .models import Message, PromptFunction, PromptVersion

graphiti_core/search/search.py

@@ -15,131 +15,228 @@ limitations under the License.
 """
 
 import logging
-from datetime import datetime
-from enum import Enum
 from time import time
 
 from neo4j import AsyncDriver
-from pydantic import BaseModel, Field
 
 from graphiti_core.edges import EntityEdge
+from graphiti_core.errors import SearchRerankerError
 from graphiti_core.llm_client.config import EMBEDDING_DIM
-from graphiti_core.nodes import EntityNode, EpisodicNode
+from graphiti_core.nodes import CommunityNode, EntityNode
+from graphiti_core.search.search_config import (
+    DEFAULT_SEARCH_LIMIT,
+    CommunityReranker,
+    CommunitySearchConfig,
+    CommunitySearchMethod,
+    EdgeReranker,
+    EdgeSearchConfig,
+    EdgeSearchMethod,
+    NodeReranker,
+    NodeSearchConfig,
+    NodeSearchMethod,
+    SearchConfig,
+    SearchResults,
+)
 from graphiti_core.search.search_utils import (
+    community_fulltext_search,
+    community_similarity_search,
     edge_fulltext_search,
     edge_similarity_search,
-    get_mentioned_nodes,
     node_distance_reranker,
+    node_fulltext_search,
+    node_similarity_search,
     rrf,
 )
-from graphiti_core.utils import retrieve_episodes
-from graphiti_core.utils.maintenance.graph_data_operations import EPISODE_WINDOW_LEN
 
 logger = logging.getLogger(__name__)
 
 
-class SearchMethod(Enum):
-    cosine_similarity = 'cosine_similarity'
-    bm25 = 'bm25'
-
-
-class Reranker(Enum):
-    rrf = 'reciprocal_rank_fusion'
-    node_distance = 'node_distance'
+async def search(
+    driver: AsyncDriver,
+    embedder,
+    query: str,
+    group_ids: list[str | None] | None,
+    config: SearchConfig,
+    center_node_uuid: str | None = None,
+) -> SearchResults:
+    start = time()
+    query = query.replace('\n', ' ')
+    # if group_ids is empty, set it to None
+    group_ids = group_ids if group_ids else None
+    edges = (
+        await edge_search(
+            driver, embedder, query, group_ids, config.edge_config, center_node_uuid, config.limit
+        )
+        if config.edge_config is not None
+        else []
+    )
+    nodes = (
+        await node_search(
+            driver, embedder, query, group_ids, config.node_config, center_node_uuid, config.limit
+        )
+        if config.node_config is not None
+        else []
+    )
+    communities = (
+        await community_search(
+            driver, embedder, query, group_ids, config.community_config, config.limit
+        )
+        if config.community_config is not None
+        else []
+    )
 
+    results = SearchResults(
+        edges=edges[: config.limit],
+        nodes=nodes[: config.limit],
+        communities=communities[: config.limit],
+    )
 
-class SearchConfig(BaseModel):
-    num_edges: int = Field(default=10)
-    num_nodes: int = Field(default=10)
-    num_episodes: int = EPISODE_WINDOW_LEN
-    group_ids: list[str | None] | None
-    search_methods: list[SearchMethod]
-    reranker: Reranker | None
+    end = time()
 
+    logger.info(f'search returned context for query {query} in {(end - start) * 1000} ms')
 
-class SearchResults(BaseModel):
-    episodes: list[EpisodicNode]
-    nodes: list[EntityNode]
-    edges: list[EntityEdge]
+    return results
 
 
-async def hybrid_search(
+async def edge_search(
     driver: AsyncDriver,
     embedder,
     query: str,
-    timestamp: datetime,
-    config: SearchConfig,
+    group_ids: list[str | None] | None,
+    config: EdgeSearchConfig,
     center_node_uuid: str | None = None,
-) -> SearchResults:
-    start = time()
-
-    episodes = []
-    nodes = []
-    edges = []
+    limit=DEFAULT_SEARCH_LIMIT,
+) -> list[EntityEdge]:
+    search_results: list[list[EntityEdge]] = []
 
-    search_results = []
+    if EdgeSearchMethod.bm25 in config.search_methods:
+        text_search = await edge_fulltext_search(driver, query, None, None, group_ids, 2 * limit)
+        search_results.append(text_search)
 
-    if config.num_episodes > 0:
-        episodes.extend(await retrieve_episodes(driver, timestamp, config.num_episodes))
-        nodes.extend(await get_mentioned_nodes(driver, episodes))
+    if EdgeSearchMethod.cosine_similarity in config.search_methods:
+        search_vector = (
+            (await embedder.create(input=[query], model='text-embedding-3-small'))
+            .data[0]
+            .embedding[:EMBEDDING_DIM]
+        )
 
-    if SearchMethod.bm25 in config.search_methods:
-        text_search = await edge_fulltext_search(
-            driver, query, None, None, config.group_ids, 2 * config.num_edges
+        similarity_search = await edge_similarity_search(
+            driver, search_vector, None, None, group_ids, 2 * limit
         )
+        search_results.append(similarity_search)
+
+    if len(search_results) > 1 and config.reranker is None:
+        raise SearchRerankerError('Multiple edge searches enabled without a reranker')
+
+    edge_uuid_map = {edge.uuid: edge for result in search_results for edge in result}
+
+    reranked_uuids: list[str] = []
+    if config.reranker == EdgeReranker.rrf:
+        search_result_uuids = [[edge.uuid for edge in result] for result in search_results]
+
+        reranked_uuids = rrf(search_result_uuids)
+    elif config.reranker == EdgeReranker.node_distance:
+        if center_node_uuid is None:
+            raise SearchRerankerError('No center node provided for Node Distance reranker')
+
+        source_to_edge_uuid_map = {
+            edge.source_node_uuid: edge.uuid for result in search_results for edge in result
+        }
+        source_uuids = [[edge.source_node_uuid for edge in result] for result in search_results]
+
+        reranked_node_uuids = await node_distance_reranker(driver, source_uuids, center_node_uuid)
+
+        reranked_uuids = [source_to_edge_uuid_map[node_uuid] for node_uuid in reranked_node_uuids]
+
+    reranked_edges = [edge_uuid_map[uuid] for uuid in reranked_uuids]
+
+    return reranked_edges
+
+
+async def node_search(
+    driver: AsyncDriver,
+    embedder,
+    query: str,
+    group_ids: list[str | None] | None,
+    config: NodeSearchConfig,
+    center_node_uuid: str | None = None,
+    limit=DEFAULT_SEARCH_LIMIT,
+) -> list[EntityNode]:
+    search_results: list[list[EntityNode]] = []
+
+    if NodeSearchMethod.bm25 in config.search_methods:
+        text_search = await node_fulltext_search(driver, query, group_ids, 2 * limit)
         search_results.append(text_search)
 
-    if SearchMethod.cosine_similarity in config.search_methods:
-        query_text = query.replace('\n', ' ')
+    if NodeSearchMethod.cosine_similarity in config.search_methods:
         search_vector = (
-            (await embedder.create(input=[query_text], model='text-embedding-3-small'))
+            (await embedder.create(input=[query], model='text-embedding-3-small'))
             .data[0]
             .embedding[:EMBEDDING_DIM]
         )
 
-        similarity_search = await edge_similarity_search(
-            driver, search_vector, None, None, config.group_ids, 2 * config.num_edges
+        similarity_search = await node_similarity_search(
+            driver, search_vector, group_ids, 2 * limit
         )
         search_results.append(similarity_search)
 
     if len(search_results) > 1 and config.reranker is None:
-        logger.exception('Multiple searches enabled without a reranker')
-        raise Exception('Multiple searches enabled without a reranker')
+        raise SearchRerankerError('Multiple node searches enabled without a reranker')
 
-    else:
-        edge_uuid_map = {}
-        search_result_uuids = []
+    search_result_uuids = [[node.uuid for node in result] for result in search_results]
+    node_uuid_map = {node.uuid: node for result in search_results for node in result}
 
-        for result in search_results:
-            result_uuids = []
-            for edge in result:
-                result_uuids.append(edge.uuid)
-                edge_uuid_map[edge.uuid] = edge
+    reranked_uuids: list[str] = []
+    if config.reranker == NodeReranker.rrf:
+        reranked_uuids = rrf(search_result_uuids)
+    elif config.reranker == NodeReranker.node_distance:
+        if center_node_uuid is None:
+            raise SearchRerankerError('No center node provided for Node Distance reranker')
+        reranked_uuids = await node_distance_reranker(driver, search_result_uuids, center_node_uuid)
 
-            search_result_uuids.append(result_uuids)
+    reranked_nodes = [node_uuid_map[uuid] for uuid in reranked_uuids]
 
-        search_result_uuids = [[edge.uuid for edge in result] for result in search_results]
+    return reranked_nodes
 
-        reranked_uuids: list[str] = []
-        if config.reranker == Reranker.rrf:
-            reranked_uuids = rrf(search_result_uuids)
-        elif config.reranker == Reranker.node_distance:
-            if center_node_uuid is None:
-                logger.exception('No center node provided for Node Distance reranker')
-                raise Exception('No center node provided for Node Distance reranker')
-            reranked_uuids = await node_distance_reranker(
-                driver, search_result_uuids, center_node_uuid
-            )
-
-        reranked_edges = [edge_uuid_map[uuid] for uuid in reranked_uuids]
-        edges.extend(reranked_edges)
-
-    context = SearchResults(
-        episodes=episodes, nodes=nodes[: config.num_nodes], edges=edges[: config.num_edges]
-    )
 
-    end = time()
+async def community_search(
+    driver: AsyncDriver,
+    embedder,
+    query: str,
+    group_ids: list[str | None] | None,
+    config: CommunitySearchConfig,
+    limit=DEFAULT_SEARCH_LIMIT,
+) -> list[CommunityNode]:
+    search_results: list[list[CommunityNode]] = []
+
+    if CommunitySearchMethod.bm25 in config.search_methods:
+        text_search = await community_fulltext_search(driver, query, group_ids, 2 * limit)
+        search_results.append(text_search)
 
-    logger.info(f'search returned context for query {query} in {(end - start) * 1000} ms')
+    if CommunitySearchMethod.cosine_similarity in config.search_methods:
+        search_vector = (
+            (await embedder.create(input=[query], model='text-embedding-3-small'))
+            .data[0]
+            .embedding[:EMBEDDING_DIM]
+        )
+
+        similarity_search = await community_similarity_search(
+            driver, search_vector, group_ids, 2 * limit
+        )
+        search_results.append(similarity_search)
+
+    if len(search_results) > 1 and config.reranker is None:
+        raise SearchRerankerError('Multiple node searches enabled without a reranker')
+
+    search_result_uuids = [[community.uuid for community in result] for result in search_results]
+    community_uuid_map = {
+        community.uuid: community for result in search_results for community in result
+    }
+
+    reranked_uuids: list[str] = []
+    if config.reranker == CommunityReranker.rrf:
+        reranked_uuids = rrf(search_result_uuids)
+
+    reranked_communities = [community_uuid_map[uuid] for uuid in reranked_uuids]
 
-    return context
+    return reranked_communities

graphiti_core/search/search_config.py

@@ -0,0 +1,81 @@
+"""
+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 enum import Enum
+
+from pydantic import BaseModel, Field
+
+from graphiti_core.edges import EntityEdge
+from graphiti_core.nodes import CommunityNode, EntityNode
+
+DEFAULT_SEARCH_LIMIT = 10
+
+
+class EdgeSearchMethod(Enum):
+    cosine_similarity = 'cosine_similarity'
+    bm25 = 'bm25'
+
+
+class NodeSearchMethod(Enum):
+    cosine_similarity = 'cosine_similarity'
+    bm25 = 'bm25'
+
+
+class CommunitySearchMethod(Enum):
+    cosine_similarity = 'cosine_similarity'
+    bm25 = 'bm25'
+
+
+class EdgeReranker(Enum):
+    rrf = 'reciprocal_rank_fusion'
+    node_distance = 'node_distance'
+
+
+class NodeReranker(Enum):
+    rrf = 'reciprocal_rank_fusion'
+    node_distance = 'node_distance'
+
+
+class CommunityReranker(Enum):
+    rrf = 'reciprocal_rank_fusion'
+
+
+class EdgeSearchConfig(BaseModel):
+    search_methods: list[EdgeSearchMethod]
+    reranker: EdgeReranker | None
+
+
+class NodeSearchConfig(BaseModel):
+    search_methods: list[NodeSearchMethod]
+    reranker: NodeReranker | None
+
+
+class CommunitySearchConfig(BaseModel):
+    search_methods: list[CommunitySearchMethod]
+    reranker: CommunityReranker | None
+
+
+class SearchConfig(BaseModel):
+    edge_config: EdgeSearchConfig | None = Field(default=None)
+    node_config: NodeSearchConfig | None = Field(default=None)
+    community_config: CommunitySearchConfig | None = Field(default=None)
+    limit: int = Field(default=DEFAULT_SEARCH_LIMIT)
+
+
+class SearchResults(BaseModel):
+    edges: list[EntityEdge]
+    nodes: list[EntityNode]
+    communities: list[CommunityNode]

graphiti_core/search/search_config_recipes.py

@@ -0,0 +1,84 @@
+"""
+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 graphiti_core.search.search_config import (
+    CommunityReranker,
+    CommunitySearchConfig,
+    CommunitySearchMethod,
+    EdgeReranker,
+    EdgeSearchConfig,
+    EdgeSearchMethod,
+    NodeReranker,
+    NodeSearchConfig,
+    NodeSearchMethod,
+    SearchConfig,
+)
+
+# Performs a hybrid search with rrf reranking over edges, nodes, and communities
+COMBINED_HYBRID_SEARCH_RRF = SearchConfig(
+    edge_config=EdgeSearchConfig(
+        search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
+        reranker=EdgeReranker.rrf,
+    ),
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.rrf,
+    ),
+    community_config=CommunitySearchConfig(
+        search_methods=[CommunitySearchMethod.bm25, CommunitySearchMethod.cosine_similarity],
+        reranker=CommunityReranker.rrf,
+    ),
+)
+
+# performs a hybrid search over edges with rrf reranking
+EDGE_HYBRID_SEARCH_RRF = SearchConfig(
+    edge_config=EdgeSearchConfig(
+        search_methods=[EdgeSearchMethod.bm25, EdgeSearchMethod.cosine_similarity],
+        reranker=EdgeReranker.rrf,
+    )
+)
+
+# 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,
+    )
+)
+
+# performs a hybrid search over nodes with rrf reranking
+NODE_HYBRID_SEARCH_RRF = SearchConfig(
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.rrf,
+    )
+)
+
+# performs a hybrid search over nodes with node distance reranking
+NODE_HYBRID_SEARCH_NODE_DISTANCE = SearchConfig(
+    node_config=NodeSearchConfig(
+        search_methods=[NodeSearchMethod.bm25, NodeSearchMethod.cosine_similarity],
+        reranker=NodeReranker.node_distance,
+    )
+)
+
+# performs a hybrid search over communities with rrf reranking
+COMMUNITY_HYBRID_SEARCH_RRF = SearchConfig(
+    community_config=CommunitySearchConfig(
+        search_methods=[CommunitySearchMethod.bm25, CommunitySearchMethod.cosine_similarity],
+        reranker=CommunityReranker.rrf,
+    )
+)

graphiti_core/search/search_utils.py

@@ -1,3 +1,19 @@
+"""
+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.
+"""
+
 import asyncio
 import logging
 import re
@@ -7,7 +23,13 @@ from time import time
 from neo4j import AsyncDriver, Query
 
 from graphiti_core.edges import EntityEdge, get_entity_edge_from_record
-from graphiti_core.nodes import EntityNode, EpisodicNode, get_entity_node_from_record
+from graphiti_core.nodes import (
+    CommunityNode,
+    EntityNode,
+    EpisodicNode,
+    get_community_node_from_record,
+    get_entity_node_from_record,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +57,128 @@ async def get_mentioned_nodes(driver: AsyncDriver, episodes: list[EpisodicNode])
     return 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 = None,
+    limit=RELEVANT_SCHEMA_LIMIT,
+) -> list[EntityEdge]:
+    # fulltext search over facts
+    cypher_query = Query("""
+              CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
+              YIELD relationship AS rel, score
+              MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
+              WHERE CASE
+                WHEN $group_ids IS NULL THEN n.group_id IS NULL
+                ELSE n.group_id IN $group_ids
+              END
+              RETURN 
+                    r.uuid AS uuid,
+                    r.group_id AS group_id,
+                    n.uuid AS source_node_uuid,
+                    m.uuid AS target_node_uuid,
+                    r.created_at AS created_at,
+                    r.name AS name,
+                    r.fact AS fact,
+                    r.fact_embedding AS fact_embedding,
+                    r.episodes AS episodes,
+                    r.expired_at AS expired_at,
+                    r.valid_at AS valid_at,
+                    r.invalid_at AS invalid_at
+                ORDER BY score DESC LIMIT $limit
+                """)
+
+    if source_node_uuid is None and target_node_uuid is None:
+        cypher_query = Query("""
+                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
+                  YIELD relationship AS rel, score
+                  MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
+                  WHERE CASE
+                    WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                    ELSE r.group_id IN $group_ids
+                  END
+                  RETURN 
+                        r.uuid AS uuid,
+                        r.group_id AS group_id,
+                        n.uuid AS source_node_uuid,
+                        m.uuid AS target_node_uuid,
+                        r.created_at AS created_at,
+                        r.name AS name,
+                        r.fact AS fact,
+                        r.fact_embedding AS fact_embedding,
+                        r.episodes AS episodes,
+                        r.expired_at AS expired_at,
+                        r.valid_at AS valid_at,
+                        r.invalid_at AS invalid_at
+                    ORDER BY score DESC LIMIT $limit
+                    """)
+    elif source_node_uuid is None:
+        cypher_query = Query("""
+                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
+                  YIELD relationship AS rel, score
+                  MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})              
+                  WHERE CASE
+                    WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                    ELSE r.group_id IN $group_ids
+                  END
+                  RETURN 
+                        r.uuid AS uuid,
+                        r.group_id AS group_id,
+                        n.uuid AS source_node_uuid,
+                        m.uuid AS target_node_uuid,
+                        r.created_at AS created_at,
+                        r.name AS name,
+                        r.fact AS fact,
+                        r.fact_embedding AS fact_embedding,
+                        r.episodes AS episodes,
+                        r.expired_at AS expired_at,
+                        r.valid_at AS valid_at,
+                        r.invalid_at AS invalid_at
+                    ORDER BY score DESC LIMIT $limit
+                    """)
+    elif target_node_uuid is None:
+        cypher_query = Query("""
+                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
+                  YIELD relationship AS rel, score
+                  MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity)              
+                  WHERE CASE
+                    WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                    ELSE r.group_id IN $group_ids
+                  END
+                  RETURN 
+                        r.uuid AS uuid,
+                        r.group_id AS group_id,
+                        n.uuid AS source_node_uuid,
+                        m.uuid AS target_node_uuid,
+                        r.created_at AS created_at,
+                        r.name AS name,
+                        r.fact AS fact,
+                        r.fact_embedding AS fact_embedding,
+                        r.episodes AS episodes,
+                        r.expired_at AS expired_at,
+                        r.valid_at AS valid_at,
+                        r.invalid_at AS invalid_at
+                    ORDER BY score DESC LIMIT $limit
+                    """)
+
+    fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
+
+    records, _, _ = await driver.execute_query(
+        cypher_query,
+        query=fuzzy_query,
+        source_uuid=source_node_uuid,
+        target_uuid=target_node_uuid,
+        group_ids=group_ids,
+        limit=limit,
+    )
+
+    edges = [get_entity_edge_from_record(record) for record in records]
+
+    return edges
+
+
 async def edge_similarity_search(
     driver: AsyncDriver,
     search_vector: list[float],
@@ -43,13 +187,15 @@ async def edge_similarity_search(
     group_ids: list[str | None] | None = None,
     limit: int = RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
-    group_ids = group_ids if group_ids is not None else [None]
     # vector similarity search over embedded facts
     query = Query("""
                 CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
                 YIELD relationship AS rel, score
                 MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
-                WHERE r.group_id IN $group_ids
+                WHERE CASE
+                    WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                    ELSE r.group_id IN $group_ids
+                END
                 RETURN
                     r.uuid AS uuid,
                     r.group_id AS group_id,
@@ -71,7 +217,10 @@ async def edge_similarity_search(
                     CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
                     YIELD relationship AS rel, score
                     MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
-                    WHERE r.group_id IN $group_ids
+                    WHERE CASE
+                        WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                        ELSE r.group_id IN $group_ids
+                    END
                     RETURN
                         r.uuid AS uuid,
                         r.group_id AS group_id,
@@ -92,7 +241,10 @@ async def edge_similarity_search(
                     CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
                     YIELD relationship AS rel, score
                     MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
-                    WHERE r.group_id IN $group_ids
+                    WHERE CASE
+                        WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                        ELSE r.group_id IN $group_ids
+                    END
                     RETURN
                         r.uuid AS uuid,
                         r.group_id AS group_id,
@@ -113,7 +265,10 @@ async def edge_similarity_search(
                     CALL db.index.vector.queryRelationships("fact_embedding", $limit, $search_vector)
                     YIELD relationship AS rel, score
                     MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity)
-                    WHERE r.group_id IN $group_ids
+                    WHERE CASE
+                        WHEN $group_ids IS NULL THEN r.group_id IS NULL
+                        ELSE r.group_id IN $group_ids
+                    END
                     RETURN
                         r.uuid AS uuid,
                         r.group_id AS group_id,
@@ -144,9 +299,44 @@ async def edge_similarity_search(
     return edges
 
 
-async def entity_similarity_search(
-    search_vector: list[float],
+async def node_fulltext_search(
+    driver: AsyncDriver,
+    query: str,
+    group_ids: list[str | None] | None = None,
+    limit=RELEVANT_SCHEMA_LIMIT,
+) -> list[EntityNode]:
+    # BM25 search to get top nodes
+    fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
+    records, _, _ = await driver.execute_query(
+        """
+    CALL db.index.fulltext.queryNodes("name_and_summary", $query) 
+    YIELD node AS n, score
+    WHERE CASE
+        WHEN $group_ids IS NULL THEN n.group_id IS NULL
+        ELSE n.group_id IN $group_ids
+    END
+    RETURN
+        n.uuid AS uuid,
+        n.group_id AS group_id, 
+        n.name AS name, 
+        n.name_embedding AS name_embedding,
+        n.created_at AS created_at, 
+        n.summary AS summary
+    ORDER BY score DESC
+    LIMIT $limit
+    """,
+        query=fuzzy_query,
+        group_ids=group_ids,
+        limit=limit,
+    )
+    nodes = [get_entity_node_from_record(record) for record in records]
+
+    return nodes
+
+
+async def node_similarity_search(
     driver: AsyncDriver,
+    search_vector: list[float],
     group_ids: list[str | None] | None = None,
     limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityNode]:
@@ -176,28 +366,28 @@ async def entity_similarity_search(
     return nodes
 
 
-async def entity_fulltext_search(
-    query: str,
+async def community_fulltext_search(
     driver: AsyncDriver,
+    query: str,
     group_ids: list[str | None] | None = None,
     limit=RELEVANT_SCHEMA_LIMIT,
-) -> list[EntityNode]:
+) -> list[CommunityNode]:
     group_ids = group_ids if group_ids is not None else [None]
 
-    # BM25 search to get top nodes
+    # BM25 search to get top communities
     fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
     records, _, _ = await driver.execute_query(
         """
-    CALL db.index.fulltext.queryNodes("name_and_summary", $query) 
-    YIELD node AS n, score
-    MATCH (n WHERE n.group_id in $group_ids)
+    CALL db.index.fulltext.queryNodes("community_name", $query) 
+    YIELD node AS comm, score
+    MATCH (comm WHERE comm.group_id in $group_ids)
     RETURN
-        n.uuid AS uuid,
-        n.group_id AS group_id, 
-        n.name AS name, 
-        n.name_embedding AS name_embedding,
-        n.created_at AS created_at, 
-        n.summary AS summary
+        comm.uuid AS uuid,
+        comm.group_id AS group_id, 
+        comm.name AS name, 
+        comm.name_embedding AS name_embedding,
+        comm.created_at AS created_at, 
+        comm.summary AS summary
     ORDER BY score DESC
     LIMIT $limit
     """,
@@ -205,121 +395,41 @@ async def entity_fulltext_search(
         group_ids=group_ids,
         limit=limit,
     )
-    nodes = [get_entity_node_from_record(record) for record in records]
+    communities = [get_community_node_from_record(record) for record in records]
 
-    return nodes
+    return communities
 
 
-async def edge_fulltext_search(
+async def community_similarity_search(
     driver: AsyncDriver,
-    query: str,
-    source_node_uuid: str | None,
-    target_node_uuid: str | None,
+    search_vector: list[float],
     group_ids: list[str | None] | None = None,
     limit=RELEVANT_SCHEMA_LIMIT,
-) -> list[EntityEdge]:
+) -> list[CommunityNode]:
     group_ids = group_ids if group_ids is not None else [None]
 
-    # fulltext search over facts
-    cypher_query = Query("""
-              CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-              YIELD relationship AS rel, score
-              MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})
-              WHERE r.group_id IN $group_ids
-              RETURN 
-                    r.uuid AS uuid,
-                    r.group_id AS group_id,
-                    n.uuid AS source_node_uuid,
-                    m.uuid AS target_node_uuid,
-                    r.created_at AS created_at,
-                    r.name AS name,
-                    r.fact AS fact,
-                    r.fact_embedding AS fact_embedding,
-                    r.episodes AS episodes,
-                    r.expired_at AS expired_at,
-                    r.valid_at AS valid_at,
-                    r.invalid_at AS invalid_at
-                ORDER BY score DESC LIMIT $limit
-                """)
-
-    if source_node_uuid is None and target_node_uuid is None:
-        cypher_query = Query("""
-                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-                  YIELD relationship AS rel, score
-                  MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity)
-                  WHERE r.group_id IN $group_ids
-                  RETURN 
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC LIMIT $limit
-                    """)
-    elif source_node_uuid is None:
-        cypher_query = Query("""
-                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-                  YIELD relationship AS rel, score
-                  MATCH (n:Entity)-[r {uuid: rel.uuid}]-(m:Entity {uuid: $target_uuid})              
-                  WHERE r.group_id IN $group_ids
-                  RETURN 
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC LIMIT $limit
-                    """)
-    elif target_node_uuid is None:
-        cypher_query = Query("""
-                  CALL db.index.fulltext.queryRelationships("name_and_fact", $query) 
-                  YIELD relationship AS rel, score
-                  MATCH (n:Entity {uuid: $source_uuid})-[r {uuid: rel.uuid}]-(m:Entity)              
-                  WHERE r.group_id IN $group_ids
-                  RETURN 
-                        r.uuid AS uuid,
-                        r.group_id AS group_id,
-                        n.uuid AS source_node_uuid,
-                        m.uuid AS target_node_uuid,
-                        r.created_at AS created_at,
-                        r.name AS name,
-                        r.fact AS fact,
-                        r.fact_embedding AS fact_embedding,
-                        r.episodes AS episodes,
-                        r.expired_at AS expired_at,
-                        r.valid_at AS valid_at,
-                        r.invalid_at AS invalid_at
-                    ORDER BY score DESC LIMIT $limit
-                    """)
-
-    fuzzy_query = re.sub(r'[^\w\s]', '', query) + '~'
-
+    # vector similarity search over entity names
     records, _, _ = await driver.execute_query(
-        cypher_query,
-        query=fuzzy_query,
-        source_uuid=source_node_uuid,
-        target_uuid=target_node_uuid,
+        """
+                CALL db.index.vector.queryNodes("community_name_embedding", $limit, $search_vector)
+                YIELD node AS comm, score
+                MATCH (comm WHERE comm.group_id IN $group_ids)
+                RETURN
+                    comm.uuid As uuid,
+                    comm.group_id AS group_id,
+                    comm.name AS name, 
+                    comm.name_embedding AS name_embedding,
+                    comm.created_at AS created_at, 
+                    comm.summary AS summary
+                ORDER BY score DESC
+                """,
+        search_vector=search_vector,
         group_ids=group_ids,
         limit=limit,
     )
+    communities = [get_community_node_from_record(record) for record in records]
 
-    edges = [get_entity_edge_from_record(record) for record in records]
-
-    return edges
+    return communities
 
 
 async def hybrid_node_search(
@@ -371,8 +481,8 @@ async def hybrid_node_search(
 
     results: list[list[EntityNode]] = list(
         await asyncio.gather(
-            *[entity_fulltext_search(q, driver, group_ids, 2 * limit) for q in queries],
-            *[entity_similarity_search(e, driver, group_ids, 2 * limit) for e in embeddings],
+            *[node_fulltext_search(driver, q, group_ids, 2 * limit) for q in queries],
+            *[node_similarity_search(driver, e, group_ids, 2 * limit) for e in embeddings],
         )
     )
 
@@ -490,24 +600,23 @@ def rrf(results: list[list[str]], rank_const=1) -> list[str]:
 
 
 async def node_distance_reranker(
-    driver: AsyncDriver, results: list[list[str]], center_node_uuid: str
+    driver: AsyncDriver, node_uuids: list[list[str]], center_node_uuid: str
 ) -> list[str]:
     # use rrf as a preliminary ranker
-    sorted_uuids = rrf(results)
+    sorted_uuids = rrf(node_uuids)
     scores: dict[str, float] = {}
 
     # Find the shortest path to center node
     query = Query("""  
-        MATCH (source:Entity)-[r:RELATES_TO {uuid: $edge_uuid}]->(target:Entity)
-        MATCH p = SHORTEST 1 (center:Entity {uuid: $center_uuid})-[:RELATES_TO]-+(n:Entity {uuid: source.uuid})
-        RETURN length(p) AS score, source.uuid AS source_uuid, target.uuid AS target_uuid
+        MATCH p = SHORTEST 1 (center:Entity {uuid: $center_uuid})-[:RELATES_TO]-+(n:Entity {uuid: $node_uuid})
+        RETURN length(p) AS score
         """)
 
     path_results = await asyncio.gather(
         *[
             driver.execute_query(
                 query,
-                edge_uuid=uuid,
+                node_uuid=uuid,
                 center_uuid=center_node_uuid,
             )
             for uuid in sorted_uuids
@@ -518,15 +627,8 @@ async def node_distance_reranker(
         records = result[0]
         record = records[0] if len(records) > 0 else None
         distance: float = record['score'] if record is not None else float('inf')
-        if record is not None and (
-            record['source_uuid'] == center_node_uuid or record['target_uuid'] == center_node_uuid
-        ):
-            distance = 0
-
-        if uuid in scores:
-            scores[uuid] = min(distance, scores[uuid])
-        else:
-            scores[uuid] = distance
+        distance = 0 if uuid == center_node_uuid else distance
+        scores[uuid] = distance
 
     # rerank on shortest distance
     sorted_uuids.sort(key=lambda cur_uuid: scores[cur_uuid])

{graphiti_core-0.3.0.dist-info → graphiti_core-0.3.2.dist-info}/METADATA

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

{graphiti_core-0.3.0.dist-info → graphiti_core-0.3.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
 graphiti_core/__init__.py,sha256=e5SWFkRiaUwfprYIeIgVIh7JDedNiloZvd3roU-0aDY,55
 graphiti_core/edges.py,sha256=bKzlrIrzofggRckgL3RA3MKLTgCKwkPVMB-tVA6Vd_A,9130
-graphiti_core/errors.py,sha256=VnirEGvivs0DGdBapy8nGmwLwOeO8CdkFLi4s0dM4W0,499
-graphiti_core/graphiti.py,sha256=8Cs--MmvSYTziI73c5NjvX4KuB4p8PbzdeaQouj8L-A,24312
-graphiti_core/helpers.py,sha256=EAeC3RrcecjiTGN2vxergN5RHTy2_jhFXA5PQVT3toU,200
+graphiti_core/errors.py,sha256=BOwL0VVnoUuMjK3EUYKvqefsbsYhRhcKcVWXaX9hanw,1259
+graphiti_core/graphiti.py,sha256=ViKKrF84VENTIR6WFtGpZ3FCZqC9B9__lKVsiXPCjV8,24563
+graphiti_core/helpers.py,sha256=qQqZJBkc_z5f3x5axPfCKK_QHLRybvWNFb57WXNENfQ,769
 graphiti_core/llm_client/__init__.py,sha256=PA80TSMeX-sUXITXEAxMDEt3gtfZgcJrGJUcyds1mSo,207
 graphiti_core/llm_client/anthropic_client.py,sha256=3zsOkewLFxBhKe90OkmpfkvrcwykgGwRoqII05Jno_Q,2410
 graphiti_core/llm_client/client.py,sha256=7-gEhOKxjdkllV_xS2Ikn-a4QzK9NE63CANnZgdn3VY,3438
 graphiti_core/llm_client/config.py,sha256=d1oZ9tt7QBQlbph7v-0HjItb6otK9_-IwF8kkRYL2rc,2359
-graphiti_core/llm_client/errors.py,sha256=wYz7pJDC7ppwYpoHpIJPcu--If7NObDy6vJSu__jtDc,244
+graphiti_core/llm_client/errors.py,sha256=-qlWwv1X-UjfsFIiNl-7yJIYvPwi7z8srVRfX4-s6uk,814
 graphiti_core/llm_client/groq_client.py,sha256=clQvQ9-zCRoqK9NGMx9Icyl4lUXmM70lZgVquXikxBo,2334
 graphiti_core/llm_client/openai_client.py,sha256=VqzWdSrHuNfF2l1aRDua00NHhtP9UR7VNtLcu8h9vLc,2343
-graphiti_core/llm_client/utils.py,sha256=H8-Kwa5SyvIYDNIas8O4bHJ6jsOL49li44VoDEMyauY,555
-graphiti_core/nodes.py,sha256=b3R06tFdmKriTwe7evXa7K8uwjuW33mOApXiW404aKU,12150
+graphiti_core/llm_client/utils.py,sha256=0KT4XxTVw3c0__HLDj3F8kNR4K_qY0hT0TH-pQZ_IZw,1126
+graphiti_core/nodes.py,sha256=w2cbyA7g_0eSm7axFWraG4opYxQz7-mPCxkcNHdefJY,12154
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
 graphiti_core/prompts/dedupe_edges.py,sha256=DUNHdIudj50FAjkla4nc68tSFSD2yjmYHBw-Bb7ph20,6529
 graphiti_core/prompts/dedupe_nodes.py,sha256=BZ9S-PB9SSGjc5Oo8ivdgA6rZx3OGOFhKtwrBlQ0bm0,7269
-graphiti_core/prompts/extract_edge_dates.py,sha256=G-Gnsyt8pYx9lFJEwlIsTdADF3ESDe26WSsrAGmvlYk,3086
+graphiti_core/prompts/extract_edge_dates.py,sha256=oOCR8mC_3gI1bumrmIjUbkNO-WTuLTXXAalPDYnDXeM,3655
 graphiti_core/prompts/extract_edges.py,sha256=AQ8xYbAv_RKXAT6WMwXs1_GvUdLtM_lhLNbt3SkOAmk,5348
 graphiti_core/prompts/extract_nodes.py,sha256=VIr0Nh0mSiodI3iGOQFszh7DOni4mufOKJDuGkMysl8,6889
 graphiti_core/prompts/invalidate_edges.py,sha256=8SHt3iPTdmqk8A52LxgdMtI39w4USKqVDMOS2i6lRQ4,4342
@@ -24,8 +24,10 @@ graphiti_core/prompts/models.py,sha256=cvx_Bv5RMFUD_5IUawYrbpOKLPHogai7_bm7YXrSz
 graphiti_core/prompts/summarize_nodes.py,sha256=FLuZpGTABgcxuIDkx_IKH115nHEw0rIaFhcGlWveAMc,2357
 graphiti_core/py.typed,sha256=vlmmzQOt7bmeQl9L3XJP4W6Ry0iiELepnOrinKz5KQg,79
 graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/search/search.py,sha256=cr1-syRlRdijnLtbuQYWy_2G1CtAeIaz6BQ2kl_6FrY,4535
-graphiti_core/search/search_utils.py,sha256=jwFoN1z6XKpHw5xdReJpblA4eBDiLIlY4lR8rCgDP5o,19502
+graphiti_core/search/search.py,sha256=BtyZBhwAt_IbU8dqm-DeRAIovkFDTdFly5IBGxs4yy8,8101
+graphiti_core/search/search_config.py,sha256=nOLU_k2p_sM0-JBYci8rWhc-mERv8uWkDn0GOYqZjL8,2081
+graphiti_core/search/search_config_recipes.py,sha256=CJIhYjXPgSm20cY9IkXQxArCgwLvjz-4xB7mr4NylWg,2857
+graphiti_core/search/search_utils.py,sha256=vFxLMt0CB_1Avn32d1PFsJPtJ26MCEdoq-BSBx2uCGQ,22802
 graphiti_core/utils/__init__.py,sha256=cJAcMnBZdHBQmWrZdU1PQ1YmaL75bhVUkyVpIPuOyns,260
 graphiti_core/utils/bulk_utils.py,sha256=JtoYTZPCigPa3n2E43Oe7QhFZRTA_QKNGy1jVgklHag,12614
 graphiti_core/utils/maintenance/__init__.py,sha256=4b9sfxqyFZMLwxxS2lnQ6_wBr3xrJRIqfAWOidK8EK0,388
@@ -35,7 +37,7 @@ graphiti_core/utils/maintenance/graph_data_operations.py,sha256=d27efEVLvQTmoKE7
 graphiti_core/utils/maintenance/node_operations.py,sha256=WXJFU1AprYjmHSq6rZhTIX4JFHtF5W9LbzA2Tfksp5Q,8838
 graphiti_core/utils/maintenance/temporal_operations.py,sha256=BzfGDm96w4HcUEsaWTHUBt5S8dNmDQL1eX6AuBL-XFM,8135
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core-0.3.0.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.3.0.dist-info/METADATA,sha256=L96LEC27fgAsQ_uTtol9fagh5fykQfJxRd0fIiWcrus,9323
-graphiti_core-0.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.3.0.dist-info/RECORD,,
+graphiti_core-0.3.2.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.3.2.dist-info/METADATA,sha256=zmcAQu2r7J1odYWWcYQ91fpahTbTu4YZnxEXN-1Qge0,9323
+graphiti_core-0.3.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.3.2.dist-info/RECORD,,