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

graphiti_core/nodes.py

@@ -273,20 +273,6 @@ class EpisodicNode(Node):
     )
 
     async def save(self, driver: GraphDriver):
-        if driver.provider == GraphProvider.NEPTUNE:
-            driver.save_to_aoss(  # pyright: ignore reportAttributeAccessIssue
-                'episode_content',
-                [
-                    {
-                        'uuid': self.uuid,
-                        'group_id': self.group_id,
-                        'source': self.source.value,
-                        'content': self.content,
-                        'source_description': self.source_description,
-                    }
-                ],
-            )
-
         episode_args = {
             'uuid': self.uuid,
             'name': self.name,
@@ -299,6 +285,12 @@ class EpisodicNode(Node):
             'source': self.source.value,
         }
 
+        if driver.aoss_client:
+            driver.save_to_aoss(  # pyright: ignore reportAttributeAccessIssue
+                'episodes',
+                [episode_args],
+            )
+
         result = await driver.execute_query(
             get_episode_node_save_query(driver.provider), **episode_args
         )
@@ -433,6 +425,22 @@ class EntityNode(Node):
                 MATCH (n:Entity {uuid: $uuid})
                 RETURN [x IN split(n.name_embedding, ",") | toFloat(x)] as name_embedding
             """
+        elif driver.aoss_client:
+            resp = driver.aoss_client.search(
+                body={
+                    'query': {'multi_match': {'query': self.uuid, 'fields': ['uuid']}},
+                    'size': 1,
+                },
+                index='entities',
+                routing=self.group_id,
+            )
+
+            if resp['hits']['hits']:
+                self.name_embedding = resp['hits']['hits'][0]['_source']['name_embedding']
+                return
+            else:
+                raise NodeNotFoundError(self.uuid)
+
         else:
             query: LiteralString = """
                 MATCH (n:Entity {uuid: $uuid})
@@ -470,11 +478,11 @@ class EntityNode(Node):
             entity_data.update(self.attributes or {})
             labels = ':'.join(self.labels + ['Entity'])
 
-            if driver.provider == GraphProvider.NEPTUNE:
-                driver.save_to_aoss('node_name_and_summary', [entity_data])  # pyright: ignore reportAttributeAccessIssue
+            if driver.aoss_client:
+                driver.save_to_aoss('entities', [entity_data])  # pyright: ignore reportAttributeAccessIssue
 
             result = await driver.execute_query(
-                get_entity_node_save_query(driver.provider, labels),
+                get_entity_node_save_query(driver.provider, labels, bool(driver.aoss_client)),
                 entity_data=entity_data,
             )
 
@@ -570,7 +578,7 @@ class CommunityNode(Node):
     async def save(self, driver: GraphDriver):
         if driver.provider == GraphProvider.NEPTUNE:
             driver.save_to_aoss(  # pyright: ignore reportAttributeAccessIssue
-                'community_name',
+                'communities',
                 [{'name': self.name, 'uuid': self.uuid, 'group_id': self.group_id}],
             )
         result = await driver.execute_query(

graphiti_core/search/search_filters.py

@@ -54,6 +54,16 @@ class SearchFilters(BaseModel):
     expired_at: list[list[DateFilter]] | None = Field(default=None)
 
 
+def cypher_to_opensearch_operator(op: ComparisonOperator) -> str:
+    mapping = {
+        ComparisonOperator.greater_than: 'gt',
+        ComparisonOperator.less_than: 'lt',
+        ComparisonOperator.greater_than_equal: 'gte',
+        ComparisonOperator.less_than_equal: 'lte',
+    }
+    return mapping.get(op, op.value)
+
+
 def node_search_filter_query_constructor(
     filters: SearchFilters,
     provider: GraphProvider,
@@ -234,3 +244,38 @@ def edge_search_filter_query_constructor(
         filter_queries.append(expired_at_filter)
 
     return filter_queries, filter_params
+
+
+def build_aoss_node_filters(group_ids: list[str], search_filters: SearchFilters) -> list[dict]:
+    filters = [{'terms': {'group_id': group_ids}}]
+
+    if search_filters.node_labels:
+        filters.append({'terms': {'node_labels': search_filters.node_labels}})
+
+    return filters
+
+
+def build_aoss_edge_filters(group_ids: list[str], search_filters: SearchFilters) -> list[dict]:
+    filters: list[dict] = [{'terms': {'group_id': group_ids}}]
+
+    if search_filters.edge_types:
+        filters.append({'terms': {'edge_types': search_filters.edge_types}})
+
+    for field in ['valid_at', 'invalid_at', 'created_at', 'expired_at']:
+        ranges = getattr(search_filters, field)
+        if ranges:
+            # OR of ANDs
+            should_clauses = []
+            for and_group in ranges:
+                and_filters = []
+                for df in and_group:  # df is a DateFilter
+                    range_query = {
+                        'range': {
+                            field: {cypher_to_opensearch_operator(df.comparison_operator): df.date}
+                        }
+                    }
+                    and_filters.append(range_query)
+                should_clauses.append({'bool': {'filter': and_filters}})
+            filters.append({'bool': {'should': should_clauses, 'minimum_should_match': 1}})
+
+    return filters

graphiti_core/search/search_utils.py

@@ -51,6 +51,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 +202,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 +209,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 +245,31 @@ 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 = driver.aoss_client.search(
+            index='entity_edges',
+            routing=route,
+            _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 +344,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 +403,32 @@ 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 = driver.aoss_client.search(
+            index='entity_edges',
+            routing=route,
+            _source=['uuid'],
+            knn={
+                'field': 'fact_embedding',
+                'query_vector': search_vector,
+                'k': limit,
+                'num_candidates': 1000,
+            },
+            query={'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
+
     else:
         query = (
             match_query
@@ -563,7 +615,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 +622,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 +643,41 @@ 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 = driver.aoss_client.search(
+            'entities',
+            routing=route,
+            _source=['uuid'],
+            query={
+                'bool': {
+                    'filter': filters,
+                    'must': [
+                        {
+                            'multi_match': {
+                                'query': query,
+                                'field': ['name', 'summary'],
+                                'operator': 'or',
+                            }
+                        }
+                    ],
+                }
+            },
+            limit=limit,
+        )
+
+        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 +734,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 +764,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 +786,36 @@ 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 = driver.aoss_client.search(
+            index='entities',
+            routing=route,
+            _source=['uuid'],
+            knn={
+                'field': 'fact_embedding',
+                'query_vector': search_vector,
+                'k': limit,
+                'num_candidates': 1000,
+            },
+            query={'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
     else:
         query = (
             """
-                        MATCH (n:Entity)
-                        """
+                                                                    MATCH (n:Entity)
+                                                                    """
             + filter_query
             + """
             WITH n, """
@@ -843,7 +954,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 +962,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 +986,40 @@ async def episode_fulltext_search(
             )
         else:
             return []
+    elif driver.aoss_client:
+        route = group_ids[0] if group_ids else None
+        res = driver.aoss_client.search(
+            'episodes',
+            routing=route,
+            _source=['uuid'],
+            query={
+                'bool': {
+                    'filter': {'terms': group_ids},
+                    'must': [
+                        {
+                            'multi_match': {
+                                'query': query,
+                                'field': ['name', 'content'],
+                                'operator': 'or',
+                            }
+                        }
+                    ],
+                }
+            },
+            limit=limit,
+        )
+
+        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 +1147,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 +1207,8 @@ async def community_similarity_search(
 
         query = (
             """
-                        MATCH (c:Community)
-                        """
+                                                                    MATCH (c:Community)
+                                                                    """
             + group_filter_query
             + """
             WITH c,
@@ -1206,9 +1350,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 +1397,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 +1488,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 +1560,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 +1598,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 +1673,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 +1746,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 +1785,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

@@ -187,12 +187,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:
+            driver.save_to_aoss('episodes', episodes)
+            driver.save_to_aoss('entities', nodes)
+            driver.save_to_aoss('entity_edges', edges)
 
 
 async def extract_nodes_and_edges_bulk(

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
@@ -149,9 +151,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.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphiti-core
-Version: 0.20.4
+Version: 0.21.0rc1
 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'