graphiti-core 0.20.4__py3-none-any.whl → 0.21.0rc2__py3-none-any.whl

graphiti_core/search/search_utils.py

@@ -23,7 +23,13 @@ import numpy as np
 from numpy._typing import NDArray
 from typing_extensions import LiteralString
 
-from graphiti_core.driver.driver import GraphDriver, GraphProvider
+from graphiti_core.driver.driver import (
+    ENTITY_EDGE_INDEX_NAME,
+    ENTITY_INDEX_NAME,
+    EPISODE_INDEX_NAME,
+    GraphDriver,
+    GraphProvider,
+)
 from graphiti_core.edges import EntityEdge, get_entity_edge_from_record
 from graphiti_core.graph_queries import (
     get_nodes_query,
@@ -51,6 +57,8 @@ from graphiti_core.nodes import (
 )
 from graphiti_core.search.search_filters import (
     SearchFilters,
+    build_aoss_edge_filters,
+    build_aoss_node_filters,
     edge_search_filter_query_constructor,
     node_search_filter_query_constructor,
 )
@@ -200,7 +208,6 @@ async def edge_fulltext_search(
     if driver.provider == GraphProvider.NEPTUNE:
         res = driver.run_aoss_query('edge_name_and_fact', query)  # pyright: ignore reportAttributeAccessIssue
         if res['hits']['total']['value'] > 0:
-            # Calculate Cosine similarity then return the edge ids
             input_ids = []
             for r in res['hits']['hits']:
                 input_ids.append({'id': r['_source']['uuid'], 'score': r['_score']})
@@ -208,11 +215,11 @@ async def edge_fulltext_search(
             # Match the edge ids and return the values
             query = (
                 """
-                                                UNWIND $ids as id
-                                                MATCH (n:Entity)-[e:RELATES_TO]->(m:Entity)
-                                                WHERE e.group_id IN $group_ids 
-                                                AND id(e)=id 
-                                                """
+                                                                                                                                        UNWIND $ids as id
+                                                                                                                                        MATCH (n:Entity)-[e:RELATES_TO]->(m:Entity)
+                                                                                                                                        WHERE e.group_id IN $group_ids 
+                                                                                                                                        AND id(e)=id 
+                                                                                                                                        """
                 + filter_query
                 + """
                 AND id(e)=id
@@ -244,6 +251,35 @@ async def edge_fulltext_search(
             )
         else:
             return []
+    elif driver.aoss_client:
+        route = group_ids[0] if group_ids else None
+        filters = build_aoss_edge_filters(group_ids or [], search_filter)
+        res = await driver.aoss_client.search(
+            index=ENTITY_EDGE_INDEX_NAME,
+            params={'routing': route},
+            body={
+                'size': limit,
+                '_source': ['uuid'],
+                'query': {
+                    'bool': {
+                        'filter': filters,
+                        'must': [{'match': {'fact': {'query': query, 'operator': 'or'}}}],
+                    }
+                },
+            },
+        )
+
+        if res['hits']['total']['value'] > 0:
+            input_uuids = {}
+            for r in res['hits']['hits']:
+                input_uuids[r['_source']['uuid']] = r['_score']
+
+            # Get edges
+            entity_edges = await EntityEdge.get_by_uuids(driver, list(input_uuids.keys()))
+            entity_edges.sort(key=lambda e: input_uuids.get(e.uuid, 0), reverse=True)
+            return entity_edges
+        else:
+            return []
     else:
         query = (
             get_relationships_query('edge_name_and_fact', limit=limit, provider=driver.provider)
@@ -318,8 +354,8 @@ async def edge_similarity_search(
     if driver.provider == GraphProvider.NEPTUNE:
         query = (
             """
-                        MATCH (n:Entity)-[e:RELATES_TO]->(m:Entity)
-                        """
+                                                                                                                MATCH (n:Entity)-[e:RELATES_TO]->(m:Entity)
+                                                                                                                """
             + filter_query
             + """
             RETURN DISTINCT id(e) as id, e.fact_embedding as embedding
@@ -377,6 +413,38 @@ async def edge_similarity_search(
             )
         else:
             return []
+    elif driver.aoss_client:
+        route = group_ids[0] if group_ids else None
+        filters = build_aoss_edge_filters(group_ids or [], search_filter)
+        res = await driver.aoss_client.search(
+            index=ENTITY_EDGE_INDEX_NAME,
+            params={'routing': route},
+            body={
+                'size': limit,
+                '_source': ['uuid'],
+                'query': {
+                    'knn': {
+                        'fact_embedding': {
+                            'vector': list(map(float, search_vector)),
+                            'k': limit,
+                            'filter': {'bool': {'filter': filters}},
+                        }
+                    }
+                },
+            },
+        )
+
+        if res['hits']['total']['value'] > 0:
+            input_uuids = {}
+            for r in res['hits']['hits']:
+                input_uuids[r['_source']['uuid']] = r['_score']
+
+            # Get edges
+            entity_edges = await EntityEdge.get_by_uuids(driver, list(input_uuids.keys()))
+            entity_edges.sort(key=lambda e: input_uuids.get(e.uuid, 0), reverse=True)
+            return entity_edges
+        return []
+
     else:
         query = (
             match_query
@@ -563,7 +631,6 @@ async def node_fulltext_search(
     if driver.provider == GraphProvider.NEPTUNE:
         res = driver.run_aoss_query('node_name_and_summary', query, limit=limit)  # pyright: ignore reportAttributeAccessIssue
         if res['hits']['total']['value'] > 0:
-            # Calculate Cosine similarity then return the edge ids
             input_ids = []
             for r in res['hits']['hits']:
                 input_ids.append({'id': r['_source']['uuid'], 'score': r['_score']})
@@ -571,11 +638,11 @@ async def node_fulltext_search(
             # Match the edge ides and return the values
             query = (
                 """
-                                                UNWIND $ids as i
-                                                MATCH (n:Entity)
-                                                WHERE n.uuid=i.id
-                                                RETURN
-                                """
+                                                                                                                                        UNWIND $ids as i
+                                                                                                                                        MATCH (n:Entity)
+                                                                                                                                        WHERE n.uuid=i.id
+                                                                                                                                        RETURN
+                                                                                                                        """
                 + get_entity_node_return_query(driver.provider)
                 + """
                 ORDER BY i.score DESC
@@ -592,6 +659,43 @@ async def node_fulltext_search(
             )
         else:
             return []
+    elif driver.aoss_client:
+        route = group_ids[0] if group_ids else None
+        filters = build_aoss_node_filters(group_ids or [], search_filter)
+        res = await driver.aoss_client.search(
+            index=ENTITY_INDEX_NAME,
+            params={'routing': route},
+            body={
+                '_source': ['uuid'],
+                'size': limit,
+                'query': {
+                    'bool': {
+                        'filter': filters,
+                        'must': [
+                            {
+                                'multi_match': {
+                                    'query': query,
+                                    'fields': ['name', 'summary'],
+                                    'operator': 'or',
+                                }
+                            }
+                        ],
+                    }
+                },
+            },
+        )
+
+        if res['hits']['total']['value'] > 0:
+            input_uuids = {}
+            for r in res['hits']['hits']:
+                input_uuids[r['_source']['uuid']] = r['_score']
+
+            # Get nodes
+            entities = await EntityNode.get_by_uuids(driver, list(input_uuids.keys()))
+            entities.sort(key=lambda e: input_uuids.get(e.uuid, 0), reverse=True)
+            return entities
+        else:
+            return []
     else:
         query = (
             get_nodes_query(
@@ -648,8 +752,8 @@ async def node_similarity_search(
     if driver.provider == GraphProvider.NEPTUNE:
         query = (
             """
-                        MATCH (n:Entity)
-                        """
+                                                                                                                MATCH (n:Entity)
+                                                                                                                """
             + filter_query
             + """
             RETURN DISTINCT id(n) as id, n.name_embedding as embedding
@@ -678,11 +782,11 @@ async def node_similarity_search(
             # Match the edge ides and return the values
             query = (
                 """
-                                                    UNWIND $ids as i
-                                                    MATCH (n:Entity)
-                                                    WHERE id(n)=i.id
-                                                    RETURN 
-                                                    """
+                                                                                                                                            UNWIND $ids as i
+                                                                                                                                            MATCH (n:Entity)
+                                                                                                                                            WHERE id(n)=i.id
+                                                                                                                                            RETURN 
+                                                                                                                                            """
                 + get_entity_node_return_query(driver.provider)
                 + """
                     ORDER BY i.score DESC
@@ -700,11 +804,42 @@ async def node_similarity_search(
             )
         else:
             return []
+    elif driver.aoss_client:
+        route = group_ids[0] if group_ids else None
+        filters = build_aoss_node_filters(group_ids or [], search_filter)
+        res = await driver.aoss_client.search(
+            index=ENTITY_INDEX_NAME,
+            params={'routing': route},
+            body={
+                'size': limit,
+                '_source': ['uuid'],
+                'query': {
+                    'knn': {
+                        'name_embedding': {
+                            'vector': list(map(float, search_vector)),
+                            'k': limit,
+                            'filter': {'bool': {'filter': filters}},
+                        }
+                    }
+                },
+            },
+        )
+
+        if res['hits']['total']['value'] > 0:
+            input_uuids = {}
+            for r in res['hits']['hits']:
+                input_uuids[r['_source']['uuid']] = r['_score']
+
+            # Get edges
+            entity_nodes = await EntityNode.get_by_uuids(driver, list(input_uuids.keys()))
+            entity_nodes.sort(key=lambda e: input_uuids.get(e.uuid, 0), reverse=True)
+            return entity_nodes
+        return []
     else:
         query = (
             """
-                        MATCH (n:Entity)
-                        """
+                                                                                                                MATCH (n:Entity)
+                                                                                                                """
             + filter_query
             + """
             WITH n, """
@@ -843,7 +978,6 @@ async def episode_fulltext_search(
     if driver.provider == GraphProvider.NEPTUNE:
         res = driver.run_aoss_query('episode_content', query, limit=limit)  # pyright: ignore reportAttributeAccessIssue
         if res['hits']['total']['value'] > 0:
-            # Calculate Cosine similarity then return the edge ids
             input_ids = []
             for r in res['hits']['hits']:
                 input_ids.append({'id': r['_source']['uuid'], 'score': r['_score']})
@@ -852,7 +986,7 @@ async def episode_fulltext_search(
             query = """
                 UNWIND $ids as i
                 MATCH (e:Episodic)
-                WHERE e.uuid=i.id
+                WHERE e.uuid=i.uuid
             RETURN
                     e.content AS content,
                     e.created_at AS created_at,
@@ -876,6 +1010,40 @@ async def episode_fulltext_search(
             )
         else:
             return []
+    elif driver.aoss_client:
+        route = group_ids[0] if group_ids else None
+        res = await driver.aoss_client.search(
+            index=EPISODE_INDEX_NAME,
+            params={'routing': route},
+            body={
+                'size': limit,
+                '_source': ['uuid'],
+                'bool': {
+                    'filter': {'terms': group_ids},
+                    'must': [
+                        {
+                            'multi_match': {
+                                'query': query,
+                                'field': ['name', 'content'],
+                                'operator': 'or',
+                            }
+                        }
+                    ],
+                },
+            },
+        )
+
+        if res['hits']['total']['value'] > 0:
+            input_uuids = {}
+            for r in res['hits']['hits']:
+                input_uuids[r['_source']['uuid']] = r['_score']
+
+            # Get nodes
+            episodes = await EpisodicNode.get_by_uuids(driver, list(input_uuids.keys()))
+            episodes.sort(key=lambda e: input_uuids.get(e.uuid, 0), reverse=True)
+            return episodes
+        else:
+            return []
     else:
         query = (
             get_nodes_query('episode_content', '$query', limit=limit, provider=driver.provider)
@@ -1003,8 +1171,8 @@ async def community_similarity_search(
     if driver.provider == GraphProvider.NEPTUNE:
         query = (
             """
-                        MATCH (n:Community)
-                        """
+                                                                                                                MATCH (n:Community)
+                                                                                                                """
             + group_filter_query
             + """
             RETURN DISTINCT id(n) as id, n.name_embedding as embedding
@@ -1063,8 +1231,8 @@ async def community_similarity_search(
 
         query = (
             """
-                        MATCH (c:Community)
-                        """
+                                                                                                                MATCH (c:Community)
+                                                                                                                """
             + group_filter_query
             + """
             WITH c,
@@ -1206,9 +1374,9 @@ async def get_relevant_nodes(
         # FIXME: Kuzu currently does not support using variables such as `node.fulltext_query` as an input to FTS, which means `get_relevant_nodes()` won't work with Kuzu as the graph driver.
         query = (
             """
-                        UNWIND $nodes AS node
-                        MATCH (n:Entity {group_id: $group_id})
-                        """
+                                                                                                                UNWIND $nodes AS node
+                                                                                                                MATCH (n:Entity {group_id: $group_id})
+                                                                                                                """
             + filter_query
             + """
             WITH node, n, """
@@ -1253,9 +1421,9 @@ async def get_relevant_nodes(
     else:
         query = (
             """
-                        UNWIND $nodes AS node
-                        MATCH (n:Entity {group_id: $group_id})
-                        """
+                                                                                                                UNWIND $nodes AS node
+                                                                                                                MATCH (n:Entity {group_id: $group_id})
+                                                                                                                """
             + filter_query
             + """
             WITH node, n, """
@@ -1344,9 +1512,9 @@ async def get_relevant_edges(
     if driver.provider == GraphProvider.NEPTUNE:
         query = (
             """
-                        UNWIND $edges AS edge
-                        MATCH (n:Entity {uuid: edge.source_node_uuid})-[e:RELATES_TO {group_id: edge.group_id}]-(m:Entity {uuid: edge.target_node_uuid})
-                        """
+                                                                                                                UNWIND $edges AS edge
+                                                                                                                MATCH (n:Entity {uuid: edge.source_node_uuid})-[e:RELATES_TO {group_id: edge.group_id}]-(m:Entity {uuid: edge.target_node_uuid})
+                                                                                                                """
             + filter_query
             + """
             WITH e, edge
@@ -1416,9 +1584,9 @@ async def get_relevant_edges(
 
             query = (
                 """
-                            UNWIND $edges AS edge
-                            MATCH (n:Entity {uuid: edge.source_node_uuid})-[:RELATES_TO]-(e:RelatesToNode_ {group_id: edge.group_id})-[:RELATES_TO]-(m:Entity {uuid: edge.target_node_uuid})
-                            """
+                                                                                                                    UNWIND $edges AS edge
+                                                                                                                    MATCH (n:Entity {uuid: edge.source_node_uuid})-[:RELATES_TO]-(e:RelatesToNode_ {group_id: edge.group_id})-[:RELATES_TO]-(m:Entity {uuid: edge.target_node_uuid})
+                                                                                                                    """
                 + filter_query
                 + """
                 WITH e, edge, n, m, """
@@ -1454,9 +1622,9 @@ async def get_relevant_edges(
         else:
             query = (
                 """
-                            UNWIND $edges AS edge
-                            MATCH (n:Entity {uuid: edge.source_node_uuid})-[e:RELATES_TO {group_id: edge.group_id}]-(m:Entity {uuid: edge.target_node_uuid})
-                            """
+                                                                                                                    UNWIND $edges AS edge
+                                                                                                                    MATCH (n:Entity {uuid: edge.source_node_uuid})-[e:RELATES_TO {group_id: edge.group_id}]-(m:Entity {uuid: edge.target_node_uuid})
+                                                                                                                    """
                 + filter_query
                 + """
                 WITH e, edge, """
@@ -1529,10 +1697,10 @@ async def get_edge_invalidation_candidates(
     if driver.provider == GraphProvider.NEPTUNE:
         query = (
             """
-                        UNWIND $edges AS edge
-                        MATCH (n:Entity)-[e:RELATES_TO {group_id: edge.group_id}]->(m:Entity)
-                        WHERE n.uuid IN [edge.source_node_uuid, edge.target_node_uuid] OR m.uuid IN [edge.target_node_uuid, edge.source_node_uuid]
-                        """
+                                                                                                                UNWIND $edges AS edge
+                                                                                                                MATCH (n:Entity)-[e:RELATES_TO {group_id: edge.group_id}]->(m:Entity)
+                                                                                                                WHERE n.uuid IN [edge.source_node_uuid, edge.target_node_uuid] OR m.uuid IN [edge.target_node_uuid, edge.source_node_uuid]
+                                                                                                                """
             + filter_query
             + """
             WITH e, edge
@@ -1602,10 +1770,10 @@ async def get_edge_invalidation_candidates(
 
             query = (
                 """
-                            UNWIND $edges AS edge
-                            MATCH (n:Entity)-[:RELATES_TO]->(e:RelatesToNode_ {group_id: edge.group_id})-[:RELATES_TO]->(m:Entity)
-                            WHERE (n.uuid IN [edge.source_node_uuid, edge.target_node_uuid] OR m.uuid IN [edge.target_node_uuid, edge.source_node_uuid])
-                            """
+                                                                                                                    UNWIND $edges AS edge
+                                                                                                                    MATCH (n:Entity)-[:RELATES_TO]->(e:RelatesToNode_ {group_id: edge.group_id})-[:RELATES_TO]->(m:Entity)
+                                                                                                                    WHERE (n.uuid IN [edge.source_node_uuid, edge.target_node_uuid] OR m.uuid IN [edge.target_node_uuid, edge.source_node_uuid])
+                                                                                                                    """
                 + filter_query
                 + """
                 WITH edge, e, n, m, """
@@ -1641,10 +1809,10 @@ async def get_edge_invalidation_candidates(
         else:
             query = (
                 """
-                            UNWIND $edges AS edge
-                            MATCH (n:Entity)-[e:RELATES_TO {group_id: edge.group_id}]->(m:Entity)
-                            WHERE n.uuid IN [edge.source_node_uuid, edge.target_node_uuid] OR m.uuid IN [edge.target_node_uuid, edge.source_node_uuid]
-                            """
+                                                                                                                    UNWIND $edges AS edge
+                                                                                                                    MATCH (n:Entity)-[e:RELATES_TO {group_id: edge.group_id}]->(m:Entity)
+                                                                                                                    WHERE n.uuid IN [edge.source_node_uuid, edge.target_node_uuid] OR m.uuid IN [edge.target_node_uuid, edge.source_node_uuid]
+                                                                                                                    """
                 + filter_query
                 + """
                 WITH edge, e, """

graphiti_core/utils/bulk_utils.py

@@ -23,7 +23,14 @@ import numpy as np
 from pydantic import BaseModel, Field
 from typing_extensions import Any
 
-from graphiti_core.driver.driver import GraphDriver, GraphDriverSession, GraphProvider
+from graphiti_core.driver.driver import (
+    ENTITY_EDGE_INDEX_NAME,
+    ENTITY_INDEX_NAME,
+    EPISODE_INDEX_NAME,
+    GraphDriver,
+    GraphDriverSession,
+    GraphProvider,
+)
 from graphiti_core.edges import Edge, EntityEdge, EpisodicEdge, create_entity_edge_embeddings
 from graphiti_core.embedder import EmbedderClient
 from graphiti_core.graphiti_types import GraphitiClients
@@ -187,12 +194,25 @@ async def add_nodes_and_edges_bulk_tx(
             await tx.run(episodic_edge_query, **edge.model_dump())
     else:
         await tx.run(get_episode_node_save_bulk_query(driver.provider), episodes=episodes)
-        await tx.run(get_entity_node_save_bulk_query(driver.provider, nodes), nodes=nodes)
+        await tx.run(
+            get_entity_node_save_bulk_query(driver.provider, nodes),
+            nodes=nodes,
+            has_aoss=bool(driver.aoss_client),
+        )
         await tx.run(
             get_episodic_edge_save_bulk_query(driver.provider),
             episodic_edges=[edge.model_dump() for edge in episodic_edges],
         )
-        await tx.run(get_entity_edge_save_bulk_query(driver.provider), entity_edges=edges)
+        await tx.run(
+            get_entity_edge_save_bulk_query(driver.provider),
+            entity_edges=edges,
+            has_aoss=bool(driver.aoss_client),
+        )
+
+        if driver.aoss_client:
+            await driver.save_to_aoss(EPISODE_INDEX_NAME, episodes)
+            await driver.save_to_aoss(ENTITY_INDEX_NAME, nodes)
+            await driver.save_to_aoss(ENTITY_EDGE_INDEX_NAME, edges)
 
 
 async def extract_nodes_and_edges_bulk(

graphiti_core/utils/maintenance/edge_operations.py

@@ -36,8 +36,10 @@ from graphiti_core.nodes import CommunityNode, EntityNode, EpisodicNode
 from graphiti_core.prompts import prompt_library
 from graphiti_core.prompts.dedupe_edges import EdgeDuplicate
 from graphiti_core.prompts.extract_edges import ExtractedEdges, MissingFacts
+from graphiti_core.search.search import search
+from graphiti_core.search.search_config import SearchResults
+from graphiti_core.search.search_config_recipes import EDGE_HYBRID_SEARCH_RRF
 from graphiti_core.search.search_filters import SearchFilters
-from graphiti_core.search.search_utils import get_edge_invalidation_candidates, get_relevant_edges
 from graphiti_core.utils.datetime_utils import ensure_utc, utc_now
 
 logger = logging.getLogger(__name__)
@@ -258,12 +260,44 @@ async def resolve_extracted_edges(
     embedder = clients.embedder
     await create_entity_edge_embeddings(embedder, extracted_edges)
 
-    search_results = await semaphore_gather(
-        get_relevant_edges(driver, extracted_edges, SearchFilters()),
-        get_edge_invalidation_candidates(driver, extracted_edges, SearchFilters(), 0.2),
+    valid_edges_list: list[list[EntityEdge]] = await semaphore_gather(
+        *[
+            EntityEdge.get_between_nodes(driver, edge.source_node_uuid, edge.target_node_uuid)
+            for edge in extracted_edges
+        ]
+    )
+
+    related_edges_results: list[SearchResults] = await semaphore_gather(
+        *[
+            search(
+                clients,
+                extracted_edge.fact,
+                group_ids=[extracted_edge.group_id],
+                config=EDGE_HYBRID_SEARCH_RRF,
+                search_filter=SearchFilters(edge_uuids=[edge.uuid for edge in valid_edges]),
+            )
+            for extracted_edge, valid_edges in zip(extracted_edges, valid_edges_list, strict=True)
+        ]
     )
 
-    related_edges_lists, edge_invalidation_candidates = search_results
+    related_edges_lists: list[list[EntityEdge]] = [result.edges for result in related_edges_results]
+
+    edge_invalidation_candidate_results: list[SearchResults] = await semaphore_gather(
+        *[
+            search(
+                clients,
+                extracted_edge.fact,
+                group_ids=[extracted_edge.group_id],
+                config=EDGE_HYBRID_SEARCH_RRF,
+                search_filter=SearchFilters(),
+            )
+            for extracted_edge in extracted_edges
+        ]
+    )
+
+    edge_invalidation_candidates: list[list[EntityEdge]] = [
+        result.edges for result in edge_invalidation_candidate_results
+    ]
 
     logger.debug(
         f'Related edges lists: {[(e.name, e.uuid) for edges_lst in related_edges_lists for e in edges_lst]}'

graphiti_core/utils/maintenance/graph_data_operations.py

@@ -34,7 +34,7 @@ logger = logging.getLogger(__name__)
 
 
 async def build_indices_and_constraints(driver: GraphDriver, delete_existing: bool = False):
-    if driver.provider == GraphProvider.NEPTUNE:
+    if driver.aoss_client:
         await driver.create_aoss_indices()  # pyright: ignore[reportAttributeAccessIssue]
         return
     if delete_existing:
@@ -56,7 +56,9 @@ async def build_indices_and_constraints(driver: GraphDriver, delete_existing: bo
 
     range_indices: list[LiteralString] = get_range_indices(driver.provider)
 
-    fulltext_indices: list[LiteralString] = get_fulltext_indices(driver.provider)
+    # Don't create fulltext indices if OpenSearch is being used
+    if not driver.aoss_client:
+        fulltext_indices: list[LiteralString] = get_fulltext_indices(driver.provider)
 
     if driver.provider == GraphProvider.KUZU:
         # Skip creating fulltext indices if they already exist. Need to do this manually
@@ -93,6 +95,8 @@ async def clear_data(driver: GraphDriver, group_ids: list[str] | None = None):
 
         async def delete_all(tx):
             await tx.run('MATCH (n) DETACH DELETE n')
+            if driver.aoss_client:
+                await driver.clear_aoss_indices()
 
         async def delete_group_ids(tx):
             labels = ['Entity', 'Episodic', 'Community']
@@ -149,9 +153,9 @@ async def retrieve_episodes(
 
     query: LiteralString = (
         """
-                MATCH (e:Episodic)
-                WHERE e.valid_at <= $reference_time
-                """
+                        MATCH (e:Episodic)
+                        WHERE e.valid_at <= $reference_time
+                        """
         + query_filter
         + """
         RETURN

{graphiti_core-0.20.4.dist-info → graphiti_core-0.21.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.20.4
+Version: 0.21.0rc2
 Summary: A temporal graph building library
 Project-URL: Homepage, https://help.getzep.com/graphiti/graphiti/overview
 Project-URL: Repository, https://github.com/getzep/graphiti
@@ -47,6 +47,9 @@ Provides-Extra: groq
 Requires-Dist: groq>=0.2.0; extra == 'groq'
 Provides-Extra: kuzu
 Requires-Dist: kuzu>=0.11.2; extra == 'kuzu'
+Provides-Extra: neo4j-opensearch
+Requires-Dist: boto3>=1.39.16; extra == 'neo4j-opensearch'
+Requires-Dist: opensearch-py>=3.0.0; extra == 'neo4j-opensearch'
 Provides-Extra: neptune
 Requires-Dist: boto3>=1.39.16; extra == 'neptune'
 Requires-Dist: langchain-aws>=0.2.29; extra == 'neptune'