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

use synapse_core::server::proto::semantic_engine_client::SemanticEngineClient;
use synapse_core::server::proto::{
    HybridSearchRequest, IngestRequest, Provenance, ReasoningRequest, ReasoningStrategy,
    SearchMode, Triple,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Connecting to Synapse gRPC server...");
    let mut client = SemanticEngineClient::connect("http://[::1]:50051").await?;

    println!("✅ Connected!");

    // 1. Ingest Data
    let triple = Triple {
        subject: "http://example.org/Socrates".to_string(),
        predicate: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type".to_string(),
        object: "http://example.org/Human".to_string(),
        provenance: Some(Provenance {
            source: "client_test".to_string(),
            timestamp: "now".to_string(),
            method: "grpc".to_string(),
        }),
        embedding: vec![],
    };

    let triple2 = Triple {
        subject: "http://example.org/Human".to_string(),
        predicate: "http://www.w3.org/2000/01/rdf-schema#subClassOf".to_string(),
        object: "http://example.org/Mortal".to_string(),
        provenance: Some(Provenance {
            source: "client_test".to_string(),
            timestamp: "now".to_string(),
            method: "grpc".to_string(),
        }),
        embedding: vec![],
    };

    println!("Sending IngestRequest...");
    let response = client
        .ingest_triples(IngestRequest {
            triples: vec![triple, triple2],
            namespace: "test_verification".to_string(),
        })
        .await?;
    println!("Response: {:?}", response.into_inner());

    // 2. Apply Reasoning (RDFS Transitivity)
    println!("\nApplying RDFS Reasoning (Internal)...");
    let reasoning_response = client
        .apply_reasoning(ReasoningRequest {
            namespace: "test_verification".to_string(),
            strategy: ReasoningStrategy::Rdfs as i32,
            materialize: false,
        })
        .await?;
    println!("Reasoning Result: {:?}", reasoning_response.into_inner());

    // 3. Hybrid Search
    println!("\nPerforming Hybrid Search for 'Socrates'...");
    let search_response = client
        .hybrid_search(HybridSearchRequest {
            query: "Socrates".to_string(),
            namespace: "test_verification".to_string(),
            vector_k: 5,
            graph_depth: 1,
            mode: SearchMode::Hybrid as i32,
            limit: 10,
        })
        .await?;

    println!("Search Results:");
    for result in search_response.into_inner().results {
        println!(
            " - [Score: {:.4}] {} ({})",
            result.score, result.content, result.uri
        );
    }

    Ok(())
}