graphiti-core 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

graphiti_core/graphiti.py

@@ -21,6 +21,7 @@ from time import time
 from dotenv import load_dotenv
 from neo4j import AsyncGraphDatabase
 from pydantic import BaseModel
+from typing_extensions import LiteralString
 
 from graphiti_core.cross_encoder.client import CrossEncoderClient
 from graphiti_core.cross_encoder.openai_reranker_client import OpenAIRerankerClient
@@ -35,6 +36,7 @@ from graphiti_core.search.search_config_recipes import (
     EDGE_HYBRID_SEARCH_NODE_DISTANCE,
     EDGE_HYBRID_SEARCH_RRF,
 )
+from graphiti_core.search.search_filters import SearchFilters
 from graphiti_core.search.search_utils import (
     RELEVANT_SCHEMA_LIMIT,
     get_communities_by_nodes,
@@ -481,6 +483,7 @@ class Graphiti:
         except Exception as e:
             raise e
 
+    #### WIP: USE AT YOUR OWN RISK ####
     async def add_episode_bulk(self, bulk_episodes: list[RawEpisode], group_id: str = ''):
         """
         Process multiple episodes in bulk and update the graph.
@@ -624,6 +627,7 @@ class Graphiti:
         center_node_uuid: str | None = None,
         group_ids: list[str] | None = None,
         num_results=DEFAULT_SEARCH_LIMIT,
+        search_filter: SearchFilters | None = None,
     ) -> list[EntityEdge]:
         """
         Perform a hybrid search on the knowledge graph.
@@ -669,6 +673,7 @@ class Graphiti:
                 query,
                 group_ids,
                 search_config,
+                search_filter if search_filter is not None else SearchFilters(),
                 center_node_uuid,
             )
         ).edges
@@ -682,6 +687,7 @@ class Graphiti:
         group_ids: list[str] | None = None,
         center_node_uuid: str | None = None,
         bfs_origin_node_uuids: list[str] | None = None,
+        search_filter: SearchFilters | None = None,
     ) -> SearchResults:
         return await search(
             self.driver,
@@ -690,6 +696,7 @@ class Graphiti:
             query,
             group_ids,
             config,
+            search_filter if search_filter is not None else SearchFilters(),
             center_node_uuid,
             bfs_origin_node_uuids,
         )
@@ -741,3 +748,34 @@ class Graphiti:
         await add_nodes_and_edges_bulk(
             self.driver, [], [], resolved_nodes, [resolved_edge] + invalidated_edges
         )
+
+    async def remove_episode(self, episode_uuid: str):
+        # Find the episode to be deleted
+        episode = await EpisodicNode.get_by_uuid(self.driver, episode_uuid)
+
+        # Find edges mentioned by the episode
+        edges = await EntityEdge.get_by_uuids(self.driver, episode.entity_edges)
+
+        # We should only delete edges created by the episode
+        edges_to_delete: list[EntityEdge] = []
+        for edge in edges:
+            if edge.episodes[0] == episode.uuid:
+                edges_to_delete.append(edge)
+
+        # Find nodes mentioned by the episode
+        nodes = await get_mentioned_nodes(self.driver, [episode])
+        # We should delete all nodes that are only mentioned in the deleted episode
+        nodes_to_delete: list[EntityNode] = []
+        for node in nodes:
+            query: LiteralString = 'MATCH (e:Episodic)-[:MENTIONS]->(n:Entity {uuid: $uuid}) RETURN count(*) AS episode_count'
+            records, _, _ = await self.driver.execute_query(
+                query, uuid=node.uuid, database_=DEFAULT_DATABASE, routing_='r'
+            )
+
+            for record in records:
+                if record['episode_count'] == 1:
+                    nodes_to_delete.append(node)
+
+        await semaphore_gather(*[node.delete(self.driver) for node in nodes_to_delete])
+        await semaphore_gather(*[edge.delete(self.driver) for edge in edges_to_delete])
+        await episode.delete(self.driver)

graphiti_core/llm_client/config.py

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-DEFAULT_MAX_TOKENS = 1024
+DEFAULT_MAX_TOKENS = 2048
 DEFAULT_TEMPERATURE = 0
 
 

graphiti_core/nodes.py

@@ -170,7 +170,8 @@ class EpisodicNode(Node):
             e.name AS name,
             e.group_id AS group_id,
             e.source_description AS source_description,
-            e.source AS source
+            e.source AS source,
+            e.entity_edges AS entity_edges
         """,
             uuid=uuid,
             database_=DEFAULT_DATABASE,
@@ -197,7 +198,8 @@ class EpisodicNode(Node):
             e.name AS name,
             e.group_id AS group_id,
             e.source_description AS source_description,
-            e.source AS source
+            e.source AS source,
+            e.entity_edges AS entity_edges
         """,
             uuids=uuids,
             database_=DEFAULT_DATABASE,
@@ -233,7 +235,8 @@ class EpisodicNode(Node):
             e.name AS name,
             e.group_id AS group_id,
             e.source_description AS source_description,
-            e.source AS source
+            e.source AS source,
+            e.entity_edges AS entity_edges
         ORDER BY e.uuid DESC
         """
             + limit_query,
@@ -490,6 +493,7 @@ def get_episodic_node_from_record(record: Any) -> EpisodicNode:
         source=EpisodeType.from_str(record['source']),
         name=record['name'],
         source_description=record['source_description'],
+        entity_edges=record['entity_edges'],
     )
 
 

graphiti_core/search/search.py

@@ -39,6 +39,7 @@ from graphiti_core.search.search_config import (
     SearchConfig,
     SearchResults,
 )
+from graphiti_core.search.search_filters import SearchFilters
 from graphiti_core.search.search_utils import (
     community_fulltext_search,
     community_similarity_search,
@@ -64,6 +65,7 @@ async def search(
     query: str,
     group_ids: list[str] | None,
     config: SearchConfig,
+    search_filter: SearchFilters,
     center_node_uuid: str | None = None,
     bfs_origin_node_uuids: list[str] | None = None,
 ) -> SearchResults:
@@ -86,6 +88,7 @@ async def search(
             query_vector,
             group_ids,
             config.edge_config,
+            search_filter,
             center_node_uuid,
             bfs_origin_node_uuids,
             config.limit,
@@ -133,6 +136,7 @@ async def edge_search(
     query_vector: list[float],
     group_ids: list[str] | None,
     config: EdgeSearchConfig | None,
+    search_filter: SearchFilters,
     center_node_uuid: str | None = None,
     bfs_origin_node_uuids: list[str] | None = None,
     limit=DEFAULT_SEARCH_LIMIT,
@@ -143,11 +147,20 @@ async def edge_search(
     search_results: list[list[EntityEdge]] = list(
         await semaphore_gather(
             *[
-                edge_fulltext_search(driver, query, group_ids, 2 * limit),
+                edge_fulltext_search(driver, query, search_filter, group_ids, 2 * limit),
                 edge_similarity_search(
-                    driver, query_vector, None, None, group_ids, 2 * limit, config.sim_min_score
+                    driver,
+                    query_vector,
+                    None,
+                    None,
+                    search_filter,
+                    group_ids,
+                    2 * limit,
+                    config.sim_min_score,
+                ),
+                edge_bfs_search(
+                    driver, bfs_origin_node_uuids, config.bfs_max_depth, search_filter, 2 * limit
                 ),
-                edge_bfs_search(driver, bfs_origin_node_uuids, config.bfs_max_depth, 2 * limit),
             ]
         )
     )
@@ -155,7 +168,9 @@ async def edge_search(
     if EdgeSearchMethod.bfs in config.search_methods and bfs_origin_node_uuids is None:
         source_node_uuids = [edge.source_node_uuid for result in search_results for edge in result]
         search_results.append(
-            await edge_bfs_search(driver, source_node_uuids, config.bfs_max_depth, 2 * limit)
+            await edge_bfs_search(
+                driver, source_node_uuids, config.bfs_max_depth, search_filter, 2 * limit
+            )
         )
 
     edge_uuid_map = {edge.uuid: edge for result in search_results for edge in result}

graphiti_core/search/search_filters.py

@@ -0,0 +1,152 @@
+"""
+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 enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+from typing_extensions import LiteralString
+
+
+class ComparisonOperator(Enum):
+    equals = '='
+    not_equals = '<>'
+    greater_than = '>'
+    less_than = '<'
+    greater_than_equal = '>='
+    less_than_equal = '<='
+
+
+class DateFilter(BaseModel):
+    date: datetime = Field(description='A datetime to filter on')
+    comparison_operator: ComparisonOperator = Field(
+        description='Comparison operator for date filter'
+    )
+
+
+class SearchFilters(BaseModel):
+    valid_at: list[list[DateFilter]] | None = Field(default=None)
+    invalid_at: list[list[DateFilter]] | None = Field(default=None)
+    created_at: list[list[DateFilter]] | None = Field(default=None)
+    expired_at: list[list[DateFilter]] | None = Field(default=None)
+
+
+def search_filter_query_constructor(filters: SearchFilters) -> tuple[LiteralString, dict[str, Any]]:
+    filter_query: LiteralString = ''
+    filter_params: dict[str, Any] = {}
+
+    if filters.valid_at is not None:
+        valid_at_filter = 'AND ('
+        for i, or_list in enumerate(filters.valid_at):
+            for j, date_filter in enumerate(or_list):
+                filter_params['valid_at_' + str(j)] = date_filter.date
+
+            and_filters = [
+                '(r.valid_at ' + date_filter.comparison_operator.value + f' $valid_at_{j})'
+                for j, date_filter in enumerate(or_list)
+            ]
+            and_filter_query = ''
+            for j, and_filter in enumerate(and_filters):
+                and_filter_query += and_filter
+                if j != len(and_filter_query) - 1:
+                    and_filter_query += ' AND '
+
+            valid_at_filter += and_filter_query
+
+            if i == len(or_list) - 1:
+                valid_at_filter += ')'
+            else:
+                valid_at_filter += ' OR '
+
+        filter_query += valid_at_filter
+
+    if filters.invalid_at is not None:
+        invalid_at_filter = 'AND ('
+        for i, or_list in enumerate(filters.invalid_at):
+            for j, date_filter in enumerate(or_list):
+                filter_params['invalid_at_' + str(j)] = date_filter.date
+
+            and_filters = [
+                '(r.invalid_at ' + date_filter.comparison_operator.value + f' $invalid_at_{j})'
+                for j, date_filter in enumerate(or_list)
+            ]
+            and_filter_query = ''
+            for j, and_filter in enumerate(and_filters):
+                and_filter_query += and_filter
+                if j != len(and_filter_query) - 1:
+                    and_filter_query += ' AND '
+
+            invalid_at_filter += and_filter_query
+
+            if i == len(or_list) - 1:
+                invalid_at_filter += ')'
+            else:
+                invalid_at_filter += ' OR '
+
+        filter_query += invalid_at_filter
+
+    if filters.created_at is not None:
+        created_at_filter = 'AND ('
+        for i, or_list in enumerate(filters.created_at):
+            for j, date_filter in enumerate(or_list):
+                filter_params['created_at_' + str(j)] = date_filter.date
+
+            and_filters = [
+                '(r.created_at ' + date_filter.comparison_operator.value + f' $created_at_{j})'
+                for j, date_filter in enumerate(or_list)
+            ]
+            and_filter_query = ''
+            for j, and_filter in enumerate(and_filters):
+                and_filter_query += and_filter
+                if j != len(and_filter_query) - 1:
+                    and_filter_query += ' AND '
+
+            created_at_filter += and_filter_query
+
+            if i == len(or_list) - 1:
+                created_at_filter += ')'
+            else:
+                created_at_filter += ' OR '
+
+        filter_query += created_at_filter
+
+    if filters.expired_at is not None:
+        expired_at_filter = 'AND ('
+        for i, or_list in enumerate(filters.expired_at):
+            for j, date_filter in enumerate(or_list):
+                filter_params['expired_at_' + str(j)] = date_filter.date
+
+            and_filters = [
+                '(r.expired_at ' + date_filter.comparison_operator.value + f' $expired_at_{j})'
+                for j, date_filter in enumerate(or_list)
+            ]
+            and_filter_query = ''
+            for j, and_filter in enumerate(and_filters):
+                and_filter_query += and_filter
+                if j != len(and_filter_query) - 1:
+                    and_filter_query += ' AND '
+
+            expired_at_filter += and_filter_query
+
+            if i == len(or_list) - 1:
+                expired_at_filter += ')'
+            else:
+                expired_at_filter += ' OR '
+
+        filter_query += expired_at_filter
+
+    return filter_query, filter_params

graphiti_core/search/search_utils.py

@@ -38,6 +38,7 @@ from graphiti_core.nodes import (
     get_community_node_from_record,
     get_entity_node_from_record,
 )
+from graphiti_core.search.search_filters import SearchFilters, search_filter_query_constructor
 
 logger = logging.getLogger(__name__)
 
@@ -136,6 +137,7 @@ async def get_communities_by_nodes(
 async def edge_fulltext_search(
     driver: AsyncDriver,
     query: str,
+    search_filter: SearchFilters,
     group_ids: list[str] | None = None,
     limit=RELEVANT_SCHEMA_LIMIT,
 ) -> list[EntityEdge]:
@@ -144,28 +146,36 @@ async def edge_fulltext_search(
     if fuzzy_query == '':
         return []
 
-    cypher_query = Query("""
+    filter_query, filter_params = search_filter_query_constructor(search_filter)
+
+    cypher_query = Query(
+        """
               CALL db.index.fulltext.queryRelationships("edge_name_and_fact", $query, {limit: $limit}) 
-              YIELD relationship AS r, score
-              WITH r, score, startNode(r) AS n, endNode(r) AS m
-              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
-                """)
+              YIELD relationship AS rel, score
+              MATCH (:ENTITY)-[r:RELATES_TO]->(:ENTITY)
+              WHERE r.group_id IN $group_ids"""
+        + filter_query
+        + """\nWITH r, score, startNode(r) AS n, endNode(r) AS m
+               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
+                 """
+    )
 
     records, _, _ = await driver.execute_query(
         cypher_query,
+        filter_params,
         query=fuzzy_query,
         group_ids=group_ids,
         limit=limit,
@@ -183,6 +193,7 @@ async def edge_similarity_search(
     search_vector: list[float],
     source_node_uuid: str | None,
     target_node_uuid: str | None,
+    search_filter: SearchFilters,
     group_ids: list[str] | None = None,
     limit: int = RELEVANT_SCHEMA_LIMIT,
     min_score: float = DEFAULT_MIN_SCORE,
@@ -194,6 +205,9 @@ async def edge_similarity_search(
 
     query_params: dict[str, Any] = {}
 
+    filter_query, filter_params = search_filter_query_constructor(search_filter)
+    query_params.update(filter_params)
+
     group_filter_query: LiteralString = ''
     if group_ids is not None:
         group_filter_query += 'WHERE r.group_id IN $group_ids'
@@ -209,9 +223,10 @@ async def edge_similarity_search(
 
     query: LiteralString = (
         """
-                        MATCH (n:Entity)-[r:RELATES_TO]->(m:Entity)
-                        """
+                                    MATCH (n:Entity)-[r:RELATES_TO]->(m:Entity)
+                                    """
         + group_filter_query
+        + filter_query
         + """\nWITH DISTINCT r, vector.similarity.cosine(r.fact_embedding, $search_vector) AS score
                 WHERE score > $min_score
                 RETURN
@@ -254,17 +269,25 @@ async def edge_bfs_search(
     driver: AsyncDriver,
     bfs_origin_node_uuids: list[str] | None,
     bfs_max_depth: int,
+    search_filter: SearchFilters,
     limit: int,
 ) -> list[EntityEdge]:
     # vector similarity search over embedded facts
     if bfs_origin_node_uuids is None:
         return []
 
-    query = Query("""
+    filter_query, filter_params = search_filter_query_constructor(search_filter)
+
+    query = Query(
+        """
                 UNWIND $bfs_origin_node_uuids AS origin_uuid
                 MATCH path = (origin:Entity|Episodic {uuid: origin_uuid})-[:RELATES_TO|MENTIONS]->{1,3}(n:Entity)
                 UNWIND relationships(path) AS rel
-                MATCH ()-[r:RELATES_TO {uuid: rel.uuid}]-()
+                MATCH ()-[r:RELATES_TO]-()
+                WHERE r.uuid = rel.uuid
+                """
+        + filter_query
+        + """  
                 RETURN DISTINCT
                     r.uuid AS uuid,
                     r.group_id AS group_id,
@@ -279,10 +302,12 @@ async def edge_bfs_search(
                     r.valid_at AS valid_at,
                     r.invalid_at AS invalid_at
                 LIMIT $limit
-        """)
+        """
+    )
 
     records, _, _ = await driver.execute_query(
         query,
+        filter_params,
         bfs_origin_node_uuids=bfs_origin_node_uuids,
         depth=bfs_max_depth,
         limit=limit,
@@ -626,6 +651,7 @@ async def get_relevant_edges(
                 edge.fact_embedding,
                 source_node_uuid,
                 target_node_uuid,
+                SearchFilters(),
                 [edge.group_id],
                 limit,
             )

{graphiti_core-0.5.2.dist-info → graphiti_core-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: graphiti-core
-Version: 0.5.2
+Version: 0.6.0
 Summary: A temporal graph building library
 License: Apache-2.0
 Author: Paul Paliychuk
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-<img width="350" alt="Graphiti-ts-small" src="https://github.com/user-attachments/assets/bbd02947-e435-4a05-b25a-bbbac36d52c8">
+# Graphiti
 
 ## Temporal Knowledge Graphs for Agentic Applications
 
@@ -45,7 +45,7 @@ a fusion of time, full-text, semantic, and graph algorithm approaches.
 <br />
 
 <p align="center">
-    <img src="/images/graphiti-graph-intro.gif" alt="Graphiti temporal walkthrough" width="700px">   
+    <img src="images/graphiti-graph-intro.gif" alt="Graphiti temporal walkthrough" width="700px">   
 </p>
 
 <br />
@@ -65,6 +65,20 @@ With Graphiti, you can build LLM applications such as:
 Graphiti supports a wide range of applications in sales, customer service, health, finance, and more, enabling long-term
 recall and state-based reasoning for both assistants and agents.
 
+## Graphiti and Zep Memory
+
+Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for LLM-powered Assistants and Agents.
+
+Using Graphiti, we've demonstrated Zep is the [State of the Art in Agent Memory](https://blog.getzep.com/state-of-the-art-agent-memory/).
+
+Read our paper: [Zep: A Temporal Knowledge Graph Architecture for Agent Memory](https://arxiv.org/abs/2501.13956).
+
+We're excited to open-source Graphiti, believing its potential reaches far beyond memory applications.
+
+<p align="center">
+    <a href="https://arxiv.org/abs/2501.13956"><img src="images/arxiv-screenshot.png" alt="Zep: A Temporal Knowledge Graph Architecture for Agent Memory" width="700px"></a>
+</p>
+
 ## Why Graphiti?
 
 We were intrigued by Microsoft’s GraphRAG, which expanded on RAG text chunking by using a graph to better model a
@@ -89,12 +103,6 @@ scale:
     <img src="/images/graphiti-intro-slides-stock-2.gif" alt="Graphiti structured + unstructured demo" width="700px">   
 </p>
 
-## Graphiti and Zep Memory
-
-Graphiti powers the core of [Zep's memory layer](https://www.getzep.com) for LLM-powered Assistants and Agents.
-
-We're excited to open-source Graphiti, believing its potential reaches far beyond memory applications.
-
 ## Installation
 
 Requirements:
@@ -125,7 +133,7 @@ poetry add graphiti-core
 
 > [!IMPORTANT]
 > Graphiti uses OpenAI for LLM inference and embedding. Ensure that an `OPENAI_API_KEY` is set in your environment.
-> Support for Anthropic and Groq LLM inferences is available, too.
+> Support for Anthropic and Groq LLM inferences is available, too. Other LLM providers may be supported via OpenAI compatible APIs.
 
 ```python
 from graphiti_core import Graphiti
@@ -216,13 +224,9 @@ as such this feature is off by default.
 
 Graphiti is under active development. We aim to maintain API stability while working on:
 
-- [x] Implementing node and edge CRUD operations
-- [ ] Improving performance and scalability
-- [ ] Achieving good performance with different LLM and embedding models
-- [x] Creating a dedicated embedder interface
 - [ ] Supporting custom graph schemas:
-    - Allow developers to provide their own defined node and edge classes when ingesting episodes
-    - Enable more flexible knowledge representation tailored to specific use cases
+  - Allow developers to provide their own defined node and edge classes when ingesting episodes
+  - Enable more flexible knowledge representation tailored to specific use cases
 - [x] Enhancing retrieval capabilities with more robust and configurable options
 - [ ] Expanding test coverage to ensure reliability and catch edge cases
 

{graphiti_core-0.5.2.dist-info → graphiti_core-0.6.0.dist-info}/RECORD

@@ -9,12 +9,12 @@ graphiti_core/embedder/client.py,sha256=HKIlpPLnzFT81jurPkry6z8F8nxfZVfejdcfxHVU
 graphiti_core/embedder/openai.py,sha256=FzEM9rtSDK1wTb4iYKjNjjdFf8BEBTDxG2vM_E-5W-8,1621
 graphiti_core/embedder/voyage.py,sha256=7kqrLG75J3Q6cdA2Nlx1JSYtpk2141ckdl3OtDDw0vU,1882
 graphiti_core/errors.py,sha256=ddHrHGQxhwkVAtSph4AV84UoOlgwZufMczXPwB7uqPo,1795
-graphiti_core/graphiti.py,sha256=qS3q9FmygplN2H7JL0jyO0VGvAc8IOl89xyipyJc84o,27039
+graphiti_core/graphiti.py,sha256=QN4YnAfpFPy6Cj5XCdab63yzgAHl-wGAEdVo2xwLxQU,28884
 graphiti_core/helpers.py,sha256=z7ApOgrm_J7hk5FN_XPAwkKyopEY943BgHjDJbSXr2s,2869
 graphiti_core/llm_client/__init__.py,sha256=PA80TSMeX-sUXITXEAxMDEt3gtfZgcJrGJUcyds1mSo,207
 graphiti_core/llm_client/anthropic_client.py,sha256=RlD6e49XvMJsTKU0krpq46gPSFm6-hfLkkq4Sfx27BE,2574
 graphiti_core/llm_client/client.py,sha256=l07SpE_k18rAhK7QbPYTx3pOb2566kYauTlKIOV3rBg,5034
-graphiti_core/llm_client/config.py,sha256=073WA7cyAGBm8N3zXnTR8tTOKZ4NnxfMeDOIMd5R770,2338
+graphiti_core/llm_client/config.py,sha256=ry6ndcB0dyUDxqnGEwPBWPOjqUkHqU_n3iMyQiN3CCM,2338
 graphiti_core/llm_client/errors.py,sha256=Vk0mj2SgNDg8E8p7m1UyUaerqLPNLCDKPVsMEnOSBdQ,1028
 graphiti_core/llm_client/groq_client.py,sha256=EesX0_iFOIvvIc3ql6Xa8EOm0dbGJ_o3VpqyDM83mKg,2498
 graphiti_core/llm_client/openai_client.py,sha256=_kLK35oSwhP20RQ9n20P8m5QxjmqqqmvU4UlOOhoLhw,6798
@@ -25,7 +25,7 @@ graphiti_core/models/edges/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 graphiti_core/models/edges/edge_db_queries.py,sha256=2UoLkmazO-FJYqjc3g0LuL-pyjekzQxxed_XHVv_HZE,2671
 graphiti_core/models/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 graphiti_core/models/nodes/node_db_queries.py,sha256=I0top_N23FN0U5ZbypaS5IXvtfx2zgJmKUCT_7mpUdo,2257
-graphiti_core/nodes.py,sha256=W5E7Tce02yF8fgo_rimVmPTrwYJ7qoqlfAtlcBs9jjk,15921
+graphiti_core/nodes.py,sha256=_ExaTj2HU-xDczbls4aFcLdpc8zwPZUZ8JgVOrBiEdw,16098
 graphiti_core/prompts/__init__.py,sha256=EA-x9xUki9l8wnu2l8ek_oNf75-do5tq5hVq7Zbv8Kw,101
 graphiti_core/prompts/dedupe_edges.py,sha256=EuX8ngeItBzrlMBOgeHrpExzxIFHD2aoDyaX1ZniF6I,3556
 graphiti_core/prompts/dedupe_nodes.py,sha256=mqvNATL-4Vo33vaxUEZfOq6hXXOiL-ftY0zcx2G-82I,4624
@@ -40,10 +40,11 @@ graphiti_core/prompts/prompt_helpers.py,sha256=-9TABwIcIQUVHcNANx6wIZd-FT2DgYKyG
 graphiti_core/prompts/summarize_nodes.py,sha256=5J_IONG7fHYiQZWnCaUyw7w2zunEaN7V89nEluRP-qY,3461
 graphiti_core/py.typed,sha256=vlmmzQOt7bmeQl9L3XJP4W6Ry0iiELepnOrinKz5KQg,79
 graphiti_core/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core/search/search.py,sha256=_-N8ztFv9_OpfNci-AwImhgw8NOLj5FDV_7Cv5GSiRo,12028
+graphiti_core/search/search.py,sha256=4DaeP5aRT7ZOByDO3H5UK0edxfwQ4mzAOdFjnjwaDJs,12454
 graphiti_core/search/search_config.py,sha256=UZN8jFA4pBlw2O5N1cuhVRBdTwMLR9N3Oyo6sQ4MDVw,3117
 graphiti_core/search/search_config_recipes.py,sha256=yUqiLnn9vFg39M8eVwjVKfBCL_ptGrfDMQ47m_Blb0g,6885
-graphiti_core/search/search_utils.py,sha256=lL6CsFFn65tEVlfBLBZu4ynZ9cyBW5SWqc0ss9mlF0Y,23485
+graphiti_core/search/search_filters.py,sha256=_E_Od3hUoZm6H2UVCcxhfS34AqGF2lNx0NJPCw0gAQs,5333
+graphiti_core/search/search_utils.py,sha256=GwF7tsvjKgVXtv6q4lXA1tZn1_0izy6rHNwL8d0cYU4,24348
 graphiti_core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 graphiti_core/utils/bulk_utils.py,sha256=FYal4tSspGVohNsnDoyW_YjMiscySuYPuQLPSwVCy24,14110
 graphiti_core/utils/datetime_utils.py,sha256=Ti-2tnrDFRzBsbfblzsHybsM3jaDLP4-VT2t0VhpIzU,1357
@@ -54,7 +55,7 @@ graphiti_core/utils/maintenance/graph_data_operations.py,sha256=qds9ALk9PhpQs1CN
 graphiti_core/utils/maintenance/node_operations.py,sha256=A-6H2ohqcGJRA_sg_-0m_AA7syiP_gVBsyY7VTTbfuA,12036
 graphiti_core/utils/maintenance/temporal_operations.py,sha256=RdNtubCyYhOVrvcOIq2WppHls1Q-BEjtsN8r38l-Rtc,3691
 graphiti_core/utils/maintenance/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphiti_core-0.5.2.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
-graphiti_core-0.5.2.dist-info/METADATA,sha256=dHPZHwbQ0U4q-2OBrft-iuXFwmlODd5Dgp_kgFSLENw,10058
-graphiti_core-0.5.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-graphiti_core-0.5.2.dist-info/RECORD,,
+graphiti_core-0.6.0.dist-info/LICENSE,sha256=KCUwCyDXuVEgmDWkozHyniRyWjnWUWjkuDHfU6o3JlA,11325
+graphiti_core-0.6.0.dist-info/METADATA,sha256=y9SsrlB4L8EVV0G9xYn39WenebenJFnlBvX_jikVh04,10242
+graphiti_core-0.6.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+graphiti_core-0.6.0.dist-info/RECORD,,