OxiRouter

Autonomous Semantic Federation Engine for the Edge — Learned source selection for SPARQL federated queries with context-awareness.

Status

Features

Quick Start

Add to Cargo.toml:

[dependencies]
oxirouter = "0.1"

use oxirouter::core::source::SourceCapabilities;
use oxirouter::prelude::*;

fn main() -> Result<(), OxiRouterError> {
    let mut router = Router::new();

    router.add_source(
        DataSource::new("dbpedia", "https://dbpedia.org/sparql")
            .with_capabilities(SourceCapabilities::full())
            .with_vocabulary("http://dbpedia.org/ontology/")
            .with_region("EU"),
    );

    router.add_source(
        DataSource::new("wikidata", "https://query.wikidata.org/sparql")
            .with_capabilities(SourceCapabilities::full())
            .with_vocabulary("http://www.wikidata.org/")
            .with_region("EU"),
    );

    let query = Query::parse(
        r"
        PREFIX dbo: <http://dbpedia.org/ontology/>
        SELECT ?name WHERE {
            ?person a dbo:Person .
            ?person dbo:name ?name .
        }
        LIMIT 100
        ",
    )?;

    let ranking = router.route(&query)?;

    if let Some(best) = ranking.best() {
        println!("Best source: {} (confidence {:.2})", best.source_id, best.confidence);
    }
    Ok(())
}

Learning from outcomes

let ranking = router.route_and_log(&query)?;
let query_id = query.predicate_hash();

// After executing the query, feed back the observed outcome:
router.learn_from_outcome(query_id, "dbpedia", true, 150, 100)?;

SPARQL Integration

Enable with features = ["sparql"].

Query::from_sparql performs accurate PREFIX-declaration parsing and projection extraction. Router::route_sparql is the single-call convenience wrapper:

#[cfg(feature = "sparql")]
fn route_sparql_example(router: &oxirouter::core::router::Router)
    -> oxirouter::core::error::Result<()>
{
    let ranking = router.route_sparql(
        r"
        PREFIX schema: <http://schema.org/>
        SELECT ?name WHERE { ?s schema:name ?name }
        ",
    )?;

    for sel in ranking.sources.iter() {
        println!("{}: {:.2}", sel.source_id, sel.confidence);
    }
    Ok(())
}

Agent Actions

Enable with features = ["agent"]. OxiRouter exposes three self-describing actions compatible with the OpenAI tool-call and Anthropic tool-use protocols.

oxirouter.route input schema (excerpt)

{
  "type": "object",
  "properties": {
    "query":            { "type": "string",  "description": "SPARQL query string to route" },
    "max_sources":      { "type": "integer", "minimum": 1 },
    "domain":           { "type": "string",  "description": "Domain hint, e.g. 'biology'" },
    "expected_results": { "type": "integer", "minimum": 0 }
  },
  "required": ["query"]
}

oxirouter.learn input fields

oxirouter.explain output fields

Edge / WASM Deployment

OxiRouter targets wasm32-unknown-unknown with the release-edge profile (fat LTO, opt-level = "z", panic = "abort", stripped symbols).

# Install the WASM target once
rustup target add wasm32-unknown-unknown

# Standard edge build (features: alloc,wasm,ml,rl,cache)
./scripts/build-wasm.sh

# Minimal build without ML (smaller binary)
OXIROUTER_FEATURES=wasm ./scripts/build-wasm.sh

# Use the lighter release-wasm profile
OXIROUTER_PROFILE=release-wasm ./scripts/build-wasm.sh

The script validates the target, runs cargo build --no-default-features --features "alloc,${OXIROUTER_FEATURES}", reports the artifact size, and runs wasm-opt -Oz --strip-debug automatically when binaryen is available.

Output artifact: target/wasm32-unknown-unknown/release-edge/oxirouter.wasm

License

Licensed under the Apache License, Version 2.0 (see LICENSE).