synapse-core 0.8.5

A neuro-symbolic semantic engine for OpenClaw, combining graph databases with vector operations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::env;
use synapse_core::server::proto::semantic_engine_server::SemanticEngine; // Correct Trait path
use synapse_core::server::{
    proto::{IngestRequest, NodeRequest, Triple},
    MySemanticEngine,
};
use tonic::Request;

#[tokio::test]
async fn test_graph_traversal_scoring() {
    env::set_var("MOCK_EMBEDDINGS", "true");
    let storage_path = "/tmp/synapse_test_traversal";
    let _ = std::fs::remove_dir_all(storage_path);

    let engine = MySemanticEngine::new(storage_path);
    let namespace = "default"; // Use default for anonymous access

    // Build graph
    // A -> Hub
    // Hub -> X1..X10
    // A -> Leaf
    // Leaf -> Y1

    let mut triples = vec![
        Triple {
            subject: "A".into(),
            predicate: "to".into(),
            object: "Hub".into(),
            ..Default::default()
        },
        Triple {
            subject: "A".into(),
            predicate: "to".into(),
            object: "Leaf".into(),
            ..Default::default()
        },
        Triple {
            subject: "Leaf".into(),
            predicate: "to".into(),
            object: "Y1".into(),
            ..Default::default()
        },
    ];

    for i in 0..10 {
        triples.push(Triple {
            subject: "Hub".into(),
            predicate: "to".into(),
            object: format!("X{}", i),
            ..Default::default()
        });
    }

    let req = Request::new(IngestRequest {
        triples,
        namespace: namespace.into(),
    });
    engine.ingest_triples(req).await.unwrap();

    // Get ID for "A"
    // Use store directly or resolve
    let store = engine.get_store(namespace).unwrap();
    let a_id = store.get_or_create_id("http://synapse.os/A");

    // Test Default Strategy
    let req_default = Request::new(NodeRequest {
        node_id: a_id,
        namespace: namespace.into(),
        direction: "outgoing".into(),
        depth: 1,
        edge_filter: "".into(),
        limit_per_layer: 0,
        scoring_strategy: "default".into(),
        node_type_filter: "".into(),
    });

    let resp_default = engine
        .get_neighbors(req_default)
        .await
        .unwrap()
        .into_inner();
    let neighbors_default = resp_default.neighbors;

    println!("Neighbors: {:?}", neighbors_default);

    let hub_node = neighbors_default
        .iter()
        .find(|n| n.uri.contains("Hub"))
        .unwrap();
    let leaf_node = neighbors_default
        .iter()
        .find(|n| n.uri.contains("Leaf"))
        .unwrap();

    assert!(
        (hub_node.score - leaf_node.score).abs() < 0.001,
        "Default scores should be equal (same depth)"
    );

    // Test Degree Strategy
    let req_degree = Request::new(NodeRequest {
        node_id: a_id,
        namespace: namespace.into(),
        direction: "outgoing".into(),
        depth: 1,
        edge_filter: "".into(),
        limit_per_layer: 0,
        scoring_strategy: "degree".into(),
        node_type_filter: "".into(),
    });

    let resp_degree = engine.get_neighbors(req_degree).await.unwrap().into_inner();
    let neighbors_degree = resp_degree.neighbors;

    let hub_node_d = neighbors_degree
        .iter()
        .find(|n| n.uri.contains("Hub"))
        .unwrap();
    let leaf_node_d = neighbors_degree
        .iter()
        .find(|n| n.uri.contains("Leaf"))
        .unwrap();

    println!(
        "Hub Score: {}, Leaf Score: {}",
        hub_node_d.score, leaf_node_d.score
    );

    assert!(
        hub_node_d.score < leaf_node_d.score,
        "Hub should be penalized"
    );
}