Feat/mcp/new tools

api/build.rs

@@ -17,8 +17,8 @@ fn main() {
         .map(|desc| desc.trim().to_string())
         .unwrap_or_else(|| "unknown".to_string());
 
-    println!("cargo::rustc-env=GIT_COMMIT={}", git_hash);
-    println!("cargo::rustc-env=GIT_TAG={}", git_tag);
+    println!("cargo::rustc-env=GIT_COMMIT={git_hash}");
+    println!("cargo::rustc-env=GIT_TAG={git_tag}");
 
     // Always rerun if any git changes occur
     println!("cargo::rerun-if-changed=.git/HEAD");

api/src/query_mapping.rs

@@ -28,7 +28,7 @@ impl QueryMapper {
         self.node_counter += 1;
 
         self.match_statements
-            .push(format!("MATCH ({} {{id: \"{id}\"}})", node_var));
+            .push(format!("MATCH ({node_var} {{id: \"{id}\"}})"));
         self.return_statement_vars.insert(node_var.clone());
 
         selection
@@ -50,10 +50,8 @@ impl QueryMapper {
         self.relation_counter += 1;
         self.node_counter += 1;
 
-        self.match_statements.push(format!(
-            "MATCH ({}) -[{}]-> ({})",
-            node_var, relation_var, to_var
-        ));
+        self.match_statements
+            .push(format!("MATCH ({node_var}) -[{relation_var}]-> ({to_var})"));
         self.return_statement_vars.insert(self.relation_var());
 
         selection

grc20-core/src/ids/base58.rs

@@ -34,7 +34,7 @@ pub fn decode_base58_to_uuid(encoded: &str) -> Result<String, &'static str> {
         }
     }
 
-    let hex_str = format!("{:032x}", decoded);
+    let hex_str = format!("{decoded:032x}");
     Ok(format!(
         "{}-{}-{}-{}-{}",
         &hex_str[0..8],

grc20-core/src/ids/id.rs

@@ -43,11 +43,11 @@ pub fn create_merged_version_id(merged_version_ids: Vec<&str>) -> String {
 }
 
 pub fn create_version_id(space_id: &str, proposal_id: &str) -> String {
-    create_id_from_unique_string(format!("{}:{}", space_id, proposal_id))
+    create_id_from_unique_string(format!("{space_id}:{proposal_id}"))
 }
 
 pub fn create_version_id_from_block(space_id: &str, block: u64) -> String {
-    create_id_from_unique_string(format!("{}:{}", space_id, block))
+    create_id_from_unique_string(format!("{space_id}:{block}"))
 }
 
 /**
@@ -56,7 +56,7 @@ pub fn create_version_id_from_block(space_id: &str, block: u64) -> String {
  * the new one that they're creating.
  */
 pub fn create_space_id(network: &str, address: &str) -> String {
-    create_id_from_unique_string(format!("{}:{}", network, address))
+    create_id_from_unique_string(format!("{network}:{address}"))
 }
 
 pub fn create_id_from_unique_string(text: impl Into<String>) -> String {

grc20-core/src/mapping/entity/mod.rs

@@ -6,6 +6,7 @@ pub mod find_path;
 pub mod insert_many;
 pub mod insert_one;
 pub mod models;
+pub mod search_with_traversals;
 pub mod semantic_search;
 pub mod utils;
 
@@ -15,6 +16,7 @@ pub use find_one::FindOneQuery;
 pub use find_path::FindPathQuery;
 pub use insert_one::InsertOneQuery;
 pub use models::{Entity, EntityNode, EntityNodeRef, SystemProperties};
+pub use search_with_traversals::SearchWithTraversals;
 pub use semantic_search::SemanticSearchQuery;
 pub use utils::{EntityFilter, EntityRelationFilter, TypesFilter};
 
@@ -130,6 +132,13 @@ pub fn search<T>(neo4j: &neo4rs::Graph, vector: Vec<f64>) -> SemanticSearchQuery
     SemanticSearchQuery::new(neo4j, vector)
 }
 
+pub fn search_from_restictions<T>(
+    neo4j: &neo4rs::Graph,
+    vector: Vec<f64>,
+) -> SearchWithTraversals<T> {
+    SearchWithTraversals::new(neo4j, vector)
+}
+
 // TODO: add docs for use via GraphQL
 pub fn find_path(neo4j: &neo4rs::Graph, id1: String, id2: String) -> FindPathQuery {
     FindPathQuery::new(neo4j, id1, id2)

grc20-core/src/mapping/entity/search_with_traversals.rs

@@ -0,0 +1,206 @@
+use futures::{Stream, StreamExt, TryStreamExt};
+
+use crate::{
+    entity::utils::MatchEntity,
+    error::DatabaseError,
+    mapping::{
+        query_utils::VersionFilter, AttributeNode, FromAttributes, PropFilter, QueryBuilder,
+        QueryStream, Subquery, EFFECTIVE_SEARCH_RATIO,
+    },
+};
+
+use super::{Entity, EntityFilter, EntityNode};
+
+pub struct SearchWithTraversals<T> {
+    neo4j: neo4rs::Graph,
+    vector: Vec<f64>,
+    filters: Vec<EntityFilter>,
+    space_id: Option<PropFilter<String>>,
+    version: VersionFilter,
+    limit: usize,
+    skip: Option<usize>,
+    threshold: f64,
+
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T> SearchWithTraversals<T> {
+    pub fn new(neo4j: &neo4rs::Graph, vector: Vec<f64>) -> Self {
+        Self {
+            neo4j: neo4j.clone(),
+            vector,
+            filters: Vec::new(),
+            space_id: None,
+            version: VersionFilter::default(),
+            limit: 100,
+            skip: None,
+            threshold: 0.75,
+
+            _marker: std::marker::PhantomData,
+        }
+    }
+
+    pub fn filter(mut self, filter: EntityFilter) -> Self {
+        self.filters.push(filter);
+        self
+    }
+
+    pub fn space_id(mut self, filter: PropFilter<String>) -> Self {
+        self.space_id = Some(filter);
+        self
+    }
+
+    pub fn version(mut self, version: impl Into<String>) -> Self {
+        self.version.version_mut(version.into());
+        self
+    }
+
+    pub fn limit(mut self, limit: usize) -> Self {
+        self.limit = limit;
+        self
+    }
+
+    pub fn limit_opt(mut self, limit: Option<usize>) -> Self {
+        if let Some(limit) = limit {
+            self.limit = limit;
+        }
+        self
+    }
+
+    pub fn skip(mut self, skip: usize) -> Self {
+        self.skip = Some(skip);
+        self
+    }
+
+    pub fn skip_opt(mut self, skip: Option<usize>) -> Self {
+        self.skip = skip;
+        self
+    }
+
+    pub fn threshold(mut self, threshold: f64) -> Self {
+        if (0.0..=1.0).contains(&threshold) {
+            self.threshold = threshold
+        }
+        self
+    }
+
+    fn subquery(&self) -> QueryBuilder {
+        const QUERY: &str = r#"
+            CALL db.index.vector.queryNodes('vector_index', $limit * $effective_search_ratio, $vector)
+            YIELD node AS n, score AS score
+            WHERE score > $threshold
+            MATCH (e:Entity) -[r:ATTRIBUTE]-> (n)
+        "#;
+
+        self.filters
+            .iter()
+            .fold(QueryBuilder::default().subquery(QUERY), |query, filter| {
+                query.subquery(filter.subquery("e"))
+            })
+            .limit(self.limit)
+            .skip_opt(self.skip)
+            .params("vector", self.vector.clone())
+            .params("effective_search_ratio", EFFECTIVE_SEARCH_RATIO)
+            .params("limit", self.limit as i64)
+            .params("threshold", self.threshold)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct SearchWithTraversalsResult<T> {
+    pub entity: T,
+}
+
+impl QueryStream<SearchWithTraversalsResult<EntityNode>> for SearchWithTraversals<EntityNode> {
+    async fn send(
+        self,
+    ) -> Result<
+        impl Stream<Item = Result<SearchWithTraversalsResult<EntityNode>, DatabaseError>>,
+        DatabaseError,
+    > {
+        let query = self.subquery().r#return("DISTINCT e");
+
+        if cfg!(debug_assertions) || cfg!(test) {
+            tracing::info!(
+                "entity_node::SearchWithTraversals::<EntityNode>:\n{}\nparams:{:?}",
+                query.compile(),
+                query.params()
+            );
+        };
+
+        #[derive(Debug, serde::Deserialize)]
+        struct RowResult {
+            e: EntityNode,
+        }
+
+        Ok(self
+            .neo4j
+            .execute(query.build())
+            .await?
+            .into_stream_as::<RowResult>()
+            .map_err(DatabaseError::from)
+            .and_then(|row| async move { Ok(SearchWithTraversalsResult { entity: row.e }) }))
+    }
+}
+
+impl<T: FromAttributes> QueryStream<SearchWithTraversalsResult<Entity<T>>>
+    for SearchWithTraversals<Entity<T>>
+{
+    async fn send(
+        self,
+    ) -> Result<
+        impl Stream<Item = Result<SearchWithTraversalsResult<Entity<T>>, DatabaseError>>,
+        DatabaseError,
+    > {
+        let match_entity = MatchEntity::new(&self.space_id, &self.version);
+
+        let query = self.subquery().with(
+            vec!["e".to_string()],
+            match_entity.chain(
+                "e",
+                "attrs",
+                "types",
+                Some(vec![]),
+                "RETURN e{.*, attrs: attrs, types: types}",
+            ),
+        );
+
+        if cfg!(debug_assertions) || cfg!(test) {
+            tracing::info!(
+                "entity_node::SearchWithTraversals::<Entity<T>>:\n{}\nparams:{:?}",
+                query.compile(),
+                query.params
+            );
+        };
+
+        #[derive(Debug, serde::Deserialize)]
+        struct RowResult {
+            #[serde(flatten)]
+            node: EntityNode,
+            attrs: Vec<AttributeNode>,
+            types: Vec<EntityNode>,
+        }
+
+        let stream = self
+            .neo4j
+            .execute(query.build())
+            .await?
+            .into_stream_as::<RowResult>()
+            .map_err(DatabaseError::from)
+            .map(|row_result| {
+                row_result.and_then(|row| {
+                    T::from_attributes(row.attrs.into())
+                        .map(|data| SearchWithTraversalsResult {
+                            entity: Entity {
+                                node: row.node,
+                                attributes: data,
+                                types: row.types.into_iter().map(|t| t.id).collect(),
+                            },
+                        })
+                        .map_err(DatabaseError::from)
+                })
+            });
+
+        Ok(stream)
+    }
+}

grc20-core/src/mapping/entity/semantic_search.rs

@@ -5,7 +5,7 @@ use crate::{
     error::DatabaseError,
     mapping::{
         query_utils::VersionFilter, AttributeNode, FromAttributes, PropFilter, QueryBuilder,
-        QueryStream, Subquery,
+        QueryStream, Subquery, EFFECTIVE_SEARCH_RATIO,
     },
 };
 
@@ -112,9 +112,6 @@ pub struct SemanticSearchResult<T> {
     pub entity: T,
     pub score: f64,
 }
-
-const EFFECTIVE_SEARCH_RATIO: f64 = 10000.0; // Adjust this ratio based on your needs
-
 impl QueryStream<SemanticSearchResult<EntityNode>> for SemanticSearchQuery<EntityNode> {
     async fn send(
         self,