Struct SemanticEngineClient 

pub struct SemanticEngineClient<T> { /* private fields */ }

Implementations

impl SemanticEngineClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>

where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

Examples found in repository

examples/grpc_verify.rs (line 10)

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(())
}

impl<T> SemanticEngineClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> SemanticEngineClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn ingest_triples( &mut self, request: impl IntoRequest<IngestRequest>, ) -> Result<Response<IngestResponse>, Status>

Ingests a batch of triples

Examples found in repository

examples/grpc_verify.rs (lines 41-44)

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(())
}

pub async fn ingest_file( &mut self, request: impl IntoRequest<IngestFileRequest>, ) -> Result<Response<IngestResponse>, Status>

Ingests a file (CSV, Markdown)

pub async fn get_neighbors( &mut self, request: impl IntoRequest<NodeRequest>, ) -> Result<Response<NeighborResponse>, Status>

Queries the graph (Basic traversal for now)

pub async fn search( &mut self, request: impl IntoRequest<SearchRequest>, ) -> Result<Response<SearchResponse>, Status>

Vector Search (Placeholder for hybrid query)

pub async fn resolve_id( &mut self, request: impl IntoRequest<ResolveRequest>, ) -> Result<Response<ResolveResponse>, Status>

Resolves a string URI to a Node ID

pub async fn get_all_triples( &mut self, request: impl IntoRequest<EmptyRequest>, ) -> Result<Response<TriplesResponse>, Status>

Get all stored triples (for graph visualization)

pub async fn query_sparql( &mut self, request: impl IntoRequest<SparqlRequest>, ) -> Result<Response<SparqlResponse>, Status>

Executes a SPARQL query

pub async fn delete_namespace_data( &mut self, request: impl IntoRequest<EmptyRequest>, ) -> Result<Response<DeleteResponse>, Status>

Deletes all data associated with a namespace

pub async fn hybrid_search( &mut self, request: impl IntoRequest<HybridSearchRequest>, ) -> Result<Response<SearchResponse>, Status>

Hybrid search combining vector similarity and graph traversal

Examples found in repository

examples/grpc_verify.rs (lines 62-69)

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(())
}

pub async fn apply_reasoning( &mut self, request: impl IntoRequest<ReasoningRequest>, ) -> Result<Response<ReasoningResponse>, Status>

Applies automated reasoning to a namespace

Examples found in repository

examples/grpc_verify.rs (lines 51-55)

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(())
}

Trait Implementations

impl<T: Clone> Clone for SemanticEngineClient<T>

fn clone(&self) -> SemanticEngineClient<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for SemanticEngineClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.