nidx-binding 6.3.4.post178__tar.gz → 6.3.4.post183__tar.gz

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.3.4.post178
+Version: 6.3.4.post183
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/nidx_protos/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.3.4.post178"
+version = "6.3.4.post183"
 license = { text = "AGPL" }
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [ { name = "Nuclia", email = "nucliadb@nuclia.com" }]

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/nidx_relation/src/reader.rs

@@ -17,15 +17,13 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //
-use std::collections::HashSet;
 use std::fmt::Debug;
 use std::path::Path;
 
 use nidx_protos::graph_search_request::QueryKind;
-use nidx_protos::relation_prefix_search_request::Search;
 use nidx_protos::{
-    EntitiesSubgraphResponse, GraphSearchRequest, GraphSearchResponse, RelationNode, RelationPrefixSearchResponse,
-    RelationSearchRequest, RelationSearchResponse,
+    EntitiesSubgraphResponse, GraphSearchRequest, GraphSearchResponse, RelationNode, RelationSearchRequest,
+    RelationSearchResponse,
 };
 use nidx_types::prefilter::{FieldId, PrefilterResult};
 use tantivy::collector::TopDocs;
@@ -36,7 +34,7 @@ use uuid::Uuid;
 
 use crate::graph_collector::{Selector, TopUniqueCollector};
 use crate::graph_query_parser::{
-    BoolGraphQuery, BoolNodeQuery, Expression, FuzzyTerm, GraphQuery, GraphQueryParser, Node, NodeQuery, Term,
+    BoolGraphQuery, BoolNodeQuery, Expression, GraphQuery, GraphQueryParser, Node, NodeQuery,
 };
 use crate::schema::{Schema, decode_node, decode_relation, encode_field_id};
 use crate::top_unique_n::TopUniqueN;
@@ -107,7 +105,7 @@ impl RelationsReaderService {
     pub fn relation_search(&self, request: &RelationSearchRequest) -> anyhow::Result<RelationSearchResponse> {
         Ok(RelationSearchResponse {
             subgraph: self.entities_subgraph_search(request)?,
-            prefix: self.prefix_search(request)?,
+            prefix: None,
         })
     }
 
@@ -383,133 +381,6 @@ impl RelationsReaderService {
 
         Ok(Some(response))
     }
-
-    fn prefix_search(&self, request: &RelationSearchRequest) -> anyhow::Result<Option<RelationPrefixSearchResponse>> {
-        let Some(prefix_request) = request.prefix.as_ref() else {
-            return Ok(None);
-        };
-
-        let Some(search) = &prefix_request.search else {
-            return Err(anyhow::anyhow!("Search terms needed"));
-        };
-
-        let query_parser = GraphQueryParser::new(&self.schema);
-
-        let mut source_q: Vec<(Occur, Box<dyn Query>)> = Vec::new();
-        let mut target_q: Vec<(Occur, Box<dyn Query>)> = Vec::new();
-
-        // Node filters: only search nodes with the specified type/subtype
-        let node_filters: Vec<Node> = prefix_request
-            .node_filters
-            .iter()
-            .map(|node_filter| Node {
-                node_type: Some(node_filter.node_type()),
-                node_subtype: node_filter.node_subtype.clone(),
-                ..Default::default()
-            })
-            .collect();
-
-        if !node_filters.is_empty() {
-            source_q.push((
-                Occur::Must,
-                query_parser.parse(GraphQuery::NodeQuery(NodeQuery::SourceNode(Expression::Or(
-                    node_filters.clone(),
-                )))),
-            ));
-            target_q.push((
-                Occur::Must,
-                query_parser.parse(GraphQuery::NodeQuery(NodeQuery::DestinationNode(Expression::Or(
-                    node_filters,
-                )))),
-            ))
-        }
-
-        let searcher = self.reader.searcher();
-        // FIXME: we are using a topdocs collector to get prefix results from source and target
-        // nodes. However, we are deduplicating afterwards, and this means we could end up with less
-        // results although results may exist. As a quick fix, we increase here the limit of the
-        // collector. The proper solution would be implementing a custom collector for this task
-        let topdocs = TopDocs::with_limit(NUMBER_OF_RESULTS_SUGGEST * 2);
-        let schema = &self.schema;
-
-        match search {
-            // TODO: no longer used, we can remove it
-            Search::Query(query) => {
-                let mut prefix_nodes_q = Vec::new();
-
-                let words: Vec<_> = query.split_whitespace().collect();
-                for word in words {
-                    prefix_nodes_q.push(Node {
-                        value: Some(Term::FuzzyWord(FuzzyTerm {
-                            value: word.to_string(),
-                            fuzzy_distance: FUZZY_DISTANCE,
-                            is_prefix: false,
-                        })),
-                        ..Default::default()
-                    });
-                }
-
-                // add fuzzy query for all prefixes
-                source_q.push((
-                    Occur::Must,
-                    query_parser.parse(GraphQuery::NodeQuery(NodeQuery::SourceNode(Expression::Or(
-                        prefix_nodes_q.clone(),
-                    )))),
-                ));
-                target_q.push((
-                    Occur::Must,
-                    query_parser.parse(GraphQuery::NodeQuery(NodeQuery::DestinationNode(Expression::Or(
-                        prefix_nodes_q,
-                    )))),
-                ));
-            }
-            Search::Prefix(prefix) => {
-                let normalized_prefix = schema.normalize(prefix);
-                let node_filter = Node {
-                    value: Some(Term::Fuzzy(FuzzyTerm {
-                        value: normalized_prefix.clone(),
-                        fuzzy_distance: FUZZY_DISTANCE,
-                        is_prefix: true,
-                    })),
-                    ..Default::default()
-                };
-                source_q.push((
-                    Occur::Must,
-                    query_parser.parse(GraphQuery::NodeQuery(NodeQuery::SourceNode(Expression::Value(
-                        node_filter.clone(),
-                    )))),
-                ));
-                target_q.push((
-                    Occur::Must,
-                    query_parser.parse(GraphQuery::NodeQuery(NodeQuery::DestinationNode(Expression::Value(
-                        node_filter,
-                    )))),
-                ));
-            }
-        }
-
-        let source_prefix_query = BooleanQuery::new(source_q);
-        let target_prefix_query = BooleanQuery::new(target_q);
-
-        let mut response = RelationPrefixSearchResponse::default();
-        let mut results = HashSet::new();
-        for (_, source_res_addr) in searcher.search(&source_prefix_query, &topdocs)? {
-            let source_res_doc = searcher.doc(source_res_addr)?;
-            let relation_node = io_maps::source_to_relation_node(schema, &source_res_doc);
-            results.insert(HashedRelationNode(relation_node));
-        }
-        for (_, target_res_addr) in searcher.search(&target_prefix_query, &topdocs)? {
-            let target_res_doc = searcher.doc(target_res_addr)?;
-            let relation_node = io_maps::target_to_relation_node(schema, &target_res_doc);
-            results.insert(HashedRelationNode(relation_node));
-        }
-        response.nodes = results
-            .into_iter()
-            .take(NUMBER_OF_RESULTS_SUGGEST)
-            .map(Into::into)
-            .collect();
-        Ok(Some(response))
-    }
 }
 
 #[derive(Debug)]
@@ -546,7 +417,8 @@ impl std::hash::Hash for HashedRelationNode {
 
 #[cfg(test)]
 mod tests {
-    // This is the outer module
+    use std::collections::HashSet;
+
     use super::*;
 
     #[test]

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/nidx_relation/tests/test_reader.rs

@@ -24,10 +24,8 @@ use std::collections::HashMap;
 use nidx_protos::entities_subgraph_request::DeletedEntities;
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
-use nidx_protos::relation_prefix_search_request::Search;
 use nidx_protos::{
-    EntitiesSubgraphRequest, IndexRelations, RelationMetadata, RelationNodeFilter, RelationPrefixSearchRequest,
-    RelationSearchRequest, Resource, ResourceId,
+    EntitiesSubgraphRequest, IndexRelations, RelationMetadata, RelationSearchRequest, Resource, ResourceId,
 };
 use nidx_relation::{RelationConfig, RelationIndexer, RelationSearcher};
 use tempfile::TempDir;
@@ -286,130 +284,3 @@ fn test_search_metadata() -> anyhow::Result<()> {
 
     Ok(())
 }
-
-#[test]
-fn test_prefix_search() -> anyhow::Result<()> {
-    let reader = create_reader()?;
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Prefix("".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-
-    // max number of prefixes is fixed (to 20)
-    assert_eq!(result.prefix.unwrap().nodes.len(), 14);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Prefix("do".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-
-    assert_eq!(result.prefix.unwrap().nodes.len(), 2);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Prefix("ann".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-
-    assert_eq!(result.prefix.unwrap().nodes.len(), 3);
-    Ok(())
-}
-
-#[test]
-fn test_prefix_query_search() -> anyhow::Result<()> {
-    let reader = create_reader()?;
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Query("Films with James Bond played by Roger Moore".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-    assert_eq!(result.prefix.unwrap().nodes.len(), 1);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Query("Films with Jomes Bond played by Roger Moore".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-    assert_eq!(result.prefix.unwrap().nodes.len(), 1);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Query("Just Bond".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-    assert_eq!(result.prefix.unwrap().nodes.len(), 1);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Query("James Bond or Anastasia".to_string())),
-            ..Default::default()
-        }),
-        ..Default::default()
-    })?;
-    assert_eq!(result.prefix.unwrap().nodes.len(), 2);
-
-    Ok(())
-}
-
-#[test]
-fn test_prefix_search_with_filters() -> anyhow::Result<()> {
-    let reader = create_reader()?;
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Prefix("".to_string())),
-            node_filters: vec![RelationNodeFilter {
-                node_type: NodeType::Entity as i32,
-                node_subtype: Some("ANIMALS".to_string()),
-            }],
-        }),
-        ..Default::default()
-    })?;
-
-    assert_eq!(result.prefix.unwrap().nodes.len(), 4);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Prefix("".to_string())),
-            node_filters: vec![RelationNodeFilter {
-                node_type: NodeType::Resource as i32,
-                node_subtype: None,
-            }],
-        }),
-        ..Default::default()
-    })?;
-
-    assert_eq!(result.prefix.unwrap().nodes.len(), 1);
-
-    let result = reader.search(&RelationSearchRequest {
-        prefix: Some(RelationPrefixSearchRequest {
-            search: Some(Search::Prefix("".to_string())),
-            node_filters: vec![RelationNodeFilter {
-                node_type: NodeType::Resource as i32,
-                node_subtype: Some("foobarmissing".to_string()),
-            }],
-        }),
-        ..Default::default()
-    })?;
-
-    // XXX WHY ISN'T THIS WORKING?
-    assert_eq!(result.prefix.unwrap().nodes.len(), 0);
-
-    Ok(())
-}

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/nidx_text/src/schema.rs

@@ -84,7 +84,7 @@ impl TextSchema {
         // Using a bytes field is slow due to tantivy's implementation being slow with many unique values.
         // A better implementation is tracked in https://github.com/quickwit-oss/tantivy/issues/2090
         let encoded_field_id = if version >= 2 {
-            Some(sb.add_u64_field("encoded_field_id", FAST))
+            Some(sb.add_u64_field("encoded_field_id", FAST | INDEXED))
         } else {
             None
         };

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/pyproject.toml

@@ -13,7 +13,7 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
-version = "6.3.4.post178"
+version = "6.3.4.post183"
 
 [project.urls]
 Homepage = "https://nuclia.com"

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/src/searcher/query_planner.rs

@@ -172,14 +172,11 @@ fn compute_vectors_request(search_request: &SearchRequest) -> anyhow::Result<Opt
 }
 
 fn compute_relations_request(search_request: &SearchRequest) -> Option<RelationSearchRequest> {
-    if search_request.relation_prefix.is_none() && search_request.relation_subgraph.is_none() {
-        return None;
-    }
+    search_request.relation_subgraph.as_ref()?;
 
     #[allow(deprecated)]
     Some(RelationSearchRequest {
         shard_id: search_request.shard.clone(),
-        prefix: search_request.relation_prefix.clone(),
         subgraph: search_request.relation_subgraph.clone(),
     })
 }

{nidx_binding-6.3.4.post178 → nidx_binding-6.3.4.post183}/tests/test_search_relations.rs

@@ -31,13 +31,11 @@ use nidx_protos::graph_search_request::QueryKind;
 use nidx_protos::prost_types::Timestamp;
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
-use nidx_protos::relation_prefix_search_request::Search;
 use nidx_protos::resource::ResourceStatus;
 use nidx_protos::{
     EntitiesSubgraphRequest, FilterExpression, GraphQuery, GraphSearchRequest, IndexMetadata, IndexRelation,
-    IndexRelations, NewShardRequest, Relation, RelationMetadata, RelationNode, RelationNodeFilter,
-    RelationPrefixSearchRequest, RelationSearchRequest, RelationSearchResponse, Resource, ResourceId, TextInformation,
-    graph_query,
+    IndexRelations, NewShardRequest, Relation, RelationMetadata, RelationNode, RelationSearchRequest,
+    RelationSearchResponse, Resource, ResourceId, TextInformation, graph_query,
 };
 use nidx_protos::{SearchRequest, VectorIndexConfig};
 use nidx_tests::graph::friendly_parse;
@@ -46,180 +44,6 @@ use sqlx::PgPool;
 use tonic::Request;
 use uuid::Uuid;
 
-#[sqlx::test]
-async fn test_search_relations_by_prefix(pool: PgPool) -> Result<(), Box<dyn std::error::Error>> {
-    let mut fixture = NidxFixture::new(pool).await?;
-    let shard_id = create_shard(&mut fixture).await?;
-    create_knowledge_graph(&mut fixture, shard_id.clone()).await;
-    fixture.wait_sync().await;
-
-    // --------------------------------------------------------------
-    // Test: prefixed search with empty term. Results are limited
-    // --------------------------------------------------------------
-
-    let response = relation_search(
-        &mut fixture,
-        RelationSearchRequest {
-            shard_id: shard_id.clone(),
-            prefix: Some(RelationPrefixSearchRequest {
-                search: Some(Search::Prefix(String::new())),
-                ..Default::default()
-            }),
-            ..Default::default()
-        },
-    )
-    .await?;
-
-    assert!(response.prefix.is_some());
-    let prefix_response = response.prefix.as_ref().unwrap();
-    let results = &prefix_response.nodes;
-    // This test will be removed soon, no need to update this
-    // // TODO this constants is spread between relations and paragraphs. It should
-    // // be in a single place and common for everyone
-    // const MAX_SUGGEST_RESULTS: usize = 20;
-    assert_eq!(results.len(), 15);
-
-    // --------------------------------------------------------------
-    // Test: prefixed search with "cat" term (some results)
-    // --------------------------------------------------------------
-
-    let response = relation_search(
-        &mut fixture,
-        RelationSearchRequest {
-            shard_id: shard_id.clone(),
-            prefix: Some(RelationPrefixSearchRequest {
-                search: Some(Search::Prefix("cat".to_string())),
-                node_filters: vec![RelationNodeFilter {
-                    node_subtype: None,
-                    node_type: NodeType::Entity as i32,
-                }],
-            }),
-            ..Default::default()
-        },
-    )
-    .await?;
-
-    let expected = HashSet::from_iter(["Cat".to_string(), "Catwoman".to_string(), "Batman".to_string()]);
-    assert!(response.prefix.is_some());
-    let prefix_response = response.prefix.as_ref().unwrap();
-    let results = prefix_response
-        .nodes
-        .iter()
-        .map(|node| node.value.to_owned())
-        .collect::<HashSet<_>>();
-    assert_eq!(results, expected);
-
-    // --------------------------------------------------------------
-    // Test: prefixed search with "cat" and filters
-    // --------------------------------------------------------------
-
-    let response = relation_search(
-        &mut fixture,
-        RelationSearchRequest {
-            shard_id: shard_id.clone(),
-            prefix: Some(RelationPrefixSearchRequest {
-                search: Some(Search::Prefix("cat".to_string())),
-                node_filters: vec![RelationNodeFilter {
-                    node_subtype: Some("animal".to_string()),
-                    node_type: NodeType::Entity as i32,
-                }],
-            }),
-            ..Default::default()
-        },
-    )
-    .await?;
-
-    let expected = HashSet::from_iter(["Cat".to_string()]);
-    assert!(response.prefix.is_some());
-    let prefix_response = response.prefix.as_ref().unwrap();
-    let results = prefix_response
-        .nodes
-        .iter()
-        .map(|node| node.value.to_owned())
-        .collect::<HashSet<_>>();
-    assert_eq!(results, expected);
-
-    let response = relation_search(
-        &mut fixture,
-        RelationSearchRequest {
-            shard_id: shard_id.clone(),
-            prefix: Some(RelationPrefixSearchRequest {
-                search: Some(Search::Prefix("cat".to_string())),
-                node_filters: vec![RelationNodeFilter {
-                    node_subtype: Some("superhero".to_string()),
-                    node_type: NodeType::Entity as i32,
-                }],
-            }),
-            ..Default::default()
-        },
-    )
-    .await?;
-
-    let expected = HashSet::from_iter(["Catwoman".to_string()]);
-    assert!(response.prefix.is_some());
-    let prefix_response = response.prefix.as_ref().unwrap();
-    let results = prefix_response
-        .nodes
-        .iter()
-        .map(|node| node.value.to_owned())
-        .collect::<HashSet<_>>();
-    assert_eq!(results, expected);
-
-    // --------------------------------------------------------------
-    // Test: prefixed search with node filters and empty query
-    // --------------------------------------------------------------
-
-    let response = relation_search(
-        &mut fixture,
-        RelationSearchRequest {
-            shard_id: shard_id.clone(),
-            prefix: Some(RelationPrefixSearchRequest {
-                search: Some(Search::Prefix(String::new())),
-                node_filters: vec![RelationNodeFilter {
-                    node_type: NodeType::Entity as i32,
-                    node_subtype: Some("animal".to_string()),
-                }],
-            }),
-            ..Default::default()
-        },
-    )
-    .await?;
-
-    let expected = HashSet::from_iter(["Cat".to_string()]);
-    assert!(response.prefix.is_some());
-    let prefix_response = response.prefix.as_ref().unwrap();
-    let results = prefix_response
-        .nodes
-        .iter()
-        .map(|node| node.value.to_owned())
-        .collect::<HashSet<_>>();
-    assert_eq!(results, expected);
-
-    // --------------------------------------------------------------
-    // Test: prefixed search with "zzz" term (empty results)
-    // --------------------------------------------------------------
-
-    let response = relation_search(
-        &mut fixture,
-        RelationSearchRequest {
-            shard_id: shard_id.clone(),
-            prefix: Some(RelationPrefixSearchRequest {
-                search: Some(Search::Prefix("zzz".to_string())),
-                ..Default::default()
-            }),
-            ..Default::default()
-        },
-    )
-    .await?;
-
-    assert!(response.prefix.is_some());
-    let prefix_response = response.prefix.as_ref().unwrap();
-    let results = &prefix_response.nodes;
-    assert!(results.is_empty());
-
-    Ok(())
-}
-
 #[sqlx::test]
 async fn test_search_relations_neighbours(pool: PgPool) -> Result<(), Box<dyn std::error::Error>> {
     let mut fixture = NidxFixture::new(pool).await?;
@@ -255,7 +79,6 @@ async fn test_search_relations_neighbours(pool: PgPool) -> Result<(), Box<dyn st
                 depth: Some(1),
                 ..Default::default()
             }),
-            ..Default::default()
         },
     )
     .await?;
@@ -284,7 +107,6 @@ async fn test_search_relations_neighbours(pool: PgPool) -> Result<(), Box<dyn st
                 depth: Some(1),
                 ..Default::default()
             }),
-            ..Default::default()
         },
     )
     .await?;
@@ -315,7 +137,6 @@ async fn test_search_relations_neighbours(pool: PgPool) -> Result<(), Box<dyn st
                 depth: Some(1),
                 ..Default::default()
             }),
-            ..Default::default()
         },
     )
     .await?;
@@ -336,7 +157,6 @@ async fn test_search_relations_neighbours(pool: PgPool) -> Result<(), Box<dyn st
                 depth: Some(1),
                 ..Default::default()
             }),
-            ..Default::default()
         },
     )
     .await?;
@@ -464,7 +284,7 @@ async fn test_graph_search_nodes(pool: PgPool) -> anyhow::Result<()> {
     let nodes = &response.nodes;
     assert_eq!(nodes.len(), 18);
 
-    // Search all ANIMAL nodes
+    // Limit by top_k
     let response = fixture
         .searcher_client
         .graph_search(GraphSearchRequest {
@@ -472,25 +292,22 @@ async fn test_graph_search_nodes(pool: PgPool) -> anyhow::Result<()> {
             query: Some(GraphQuery {
                 path: Some(graph_query::PathQuery {
                     query: Some(path_query::Query::Path(graph_query::Path {
-                        source: Some(graph_query::Node {
-                            node_subtype: Some("ANIMAL".to_string()),
-                            ..Default::default()
-                        }),
+                        source: Some(graph_query::Node::default()),
                         undirected: true,
                         ..Default::default()
                     })),
                 }),
             }),
-            top_k: 100,
+            top_k: 10,
             kind: QueryKind::Nodes.into(),
             ..Default::default()
         })
         .await?
         .into_inner();
     let nodes = &response.nodes;
-    assert_eq!(nodes.len(), 4);
+    assert_eq!(nodes.len(), 10);
 
-    // Limit by top_k
+    // Search all ANIMAL nodes
     let response = fixture
         .searcher_client
         .graph_search(GraphSearchRequest {
@@ -498,20 +315,23 @@ async fn test_graph_search_nodes(pool: PgPool) -> anyhow::Result<()> {
             query: Some(GraphQuery {
                 path: Some(graph_query::PathQuery {
                     query: Some(path_query::Query::Path(graph_query::Path {
-                        source: Some(graph_query::Node::default()),
+                        source: Some(graph_query::Node {
+                            node_subtype: Some("ANIMAL".to_string()),
+                            ..Default::default()
+                        }),
                         undirected: true,
                         ..Default::default()
                     })),
                 }),
             }),
-            top_k: 10,
+            top_k: 100,
             kind: QueryKind::Nodes.into(),
             ..Default::default()
         })
         .await?
         .into_inner();
     let nodes = &response.nodes;
-    assert_eq!(nodes.len(), 10);
+    assert_eq!(nodes.len(), 4);
 
     Ok(())
 }
@@ -1298,7 +1118,6 @@ async fn relation_search(
     let request = SearchRequest {
         shard: request.shard_id,
         vectorset: "english".to_string(),
-        relation_prefix: request.prefix,
         relation_subgraph: request.subgraph,
         ..Default::default()
     };