Rust SDK

cargo add rcp-protocol

[dependencies]
rcp-protocol = "1"     # published on crates.io; the crate is imported as `rcp`

use rcp::{obj, Capability, Json, Method, Server};

fn main() {
    let mut s = Server::new();
    s.set_info("my-engine", "1.0");
    s.advertise(Capability::Retrieve, obj(&[("maxK", 200.into())]));
    s.advertise(Capability::Embed, obj(&[("dimension", 384.into())]));

    s.on(Method::RETRIEVE, |params| {
        let q = params.get_str("query").unwrap_or("");
        let hits = my_index_search(q); // -> Json array of { id, score, text }
        Ok(obj(&[("hits", hits)]))
    });

    s.on(Method::EMBED, |params| {
        let items = params.get("inputs").or_else(|| params.get("texts")); // inputs preferred
        Ok(obj(&[("vectors", embed_all(items))]))
    });

    s.serve_stdio();          // or: s.serve_http(8000).unwrap();
}

use rcp::Capability;

fn main() -> Result<(), rcp::RcpError> {
    let mut c = rcp::connect_stdio(&["my_engine"])?;
    // or: let mut c = rcp::connect_http("http://127.0.0.1:8000/rcp")?;

    println!("{} (RCP/{})", c.server(), c.protocol_version());

    if c.supports(Capability::Retrieve) {
        for h in c.retrieve("eiffel tower", 3)? {
            println!("{} {} {}", h.id, h.score, h.text);
        }
    }

    if c.supports(Capability::Embed) {
        let vecs = c.embed(&["hello world"], None)?;
        println!("dim {}", vecs[0].len());
    }

    c.shutdown();
    Ok(())
}

match c.rerank("q", &["a", "b"]) {
    Err(e) => assert_eq!(e.code, rcp::Errc::CAPABILITY_MISSING), // -32003
    Ok(_) => {}
}

let sel = rcp::Selector::load("rcp.json")?;
let mut c = sel.select_capable(rcp::Capability::Retrieve)?;

use rcp::{fusion, vectors, obj};

// Merge per-engine ranked lists; deterministic tie-break, origin tags.
let a = vec![obj(&[("id", "x".into())])];
let b = vec![obj(&[("id", "x".into())]), obj(&[("id", "y".into())])];
let fused = fusion::rrf_fuse(&[("A", &a), ("B", &b)], Some(10), fusion::RRF_K_DEFAULT, None);
// fusion::weighted_fuse(&engines, k, weights) when scores are comparable.

// Compact embeddings for the wire.
let blob = vectors::encode_f32_base64(&vector);
let back = vectors::decode_f32_base64(&[blob], Some(1024))?;

cd sdk/rust
cargo test     # incl. Rust client <-> C++ server + registry selector