Rust client

[dependencies]
quiver-client = { git = "https://github.com/HilthonTT/quiver" }
quiver-types = { git = "https://github.com/HilthonTT/quiver" }
serde_json = "1"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

use quiver_client::{Client, ClientError, RecommendRequest, SearchRequest, Selector};
use quiver_types::{CollectionConfig, MetadataMode, Metric, PointInput};
use serde_json::json;
 
#[tokio::main]
async fn main() -> Result<(), ClientError> {
    // An empty key (no QUIVER_API_KEY) sends no Authorization header.
    let key = std::env::var("QUIVER_API_KEY").unwrap_or_default();
    let client = Client::new("http://localhost:6900")?.with_api_key(key);
 
    let config = CollectionConfig::new(3).metric(Metric::Cosine);
    client.create_collection("books", &config).await?;
 
    let point = |id: &str, vector: Vec<f32>, year: u32| PointInput {
        id: Some(id.into()),
        vector,
        vectors: Default::default(),
        sparse_vectors: Default::default(),
        metadata: Some(json!({ "year": year })),
    };
    let written = client
        .upsert(
            "books",
            vec![
                point("dune", vec![0.9, 0.1, 0.0], 1965),
                point("foundation", vec![0.8, 0.2, 0.1], 1951),
                point("hobbit", vec![0.1, 0.9, 0.2], 1937),
            ],
        )
        .await?;
    println!("upserted {} points: {:?}", written.upserted, written.ids);
 
    let mut query = SearchRequest::new(vec![1.0, 0.0, 0.0], 2);
    query.filter = Some(json!({ "year": { "$lt": 1960 } }));
    for hit in client.search("books", &query).await? {
        println!("{} {:.4}", hit.id, hit.distance);
    }
 
    let near_dune = client.search("books", &SearchRequest::by_id("dune", 1)).await?;
    let liked = RecommendRequest::new(vec!["hobbit".into()], 1);
    let recommended = client.recommend("books", &liked).await?;
    println!("near dune: {}, like hobbit: {}", near_dune[0].id, recommended[0].id);
 
    let updated = client
        .update_metadata("books", &Selector::Ids(vec!["dune".into()]), &json!({ "seen": true }), MetadataMode::Merge)
        .await?;
    let old = client.count("books", Some(&json!({ "year": { "$lt": 1960 } }))).await?;
    println!("updated {updated}, {old} published before 1960");
 
    let page = client.scroll("books", None, 2, false).await?;
    println!("first page: {:?}, next cursor {:?}", page.points.iter().map(|p| &p.id).collect::<Vec<_>>(), page.next_cursor);
 
    match client.get_point("books", "nope").await? {
        Some(p) => println!("found {}", p.id),
        None => println!("no point `nope`"),
    }
    if let Err(ClientError::Api { status, code, .. }) = client.create_collection("books", &config).await {
        println!("{status} {code}");
    }
    Ok(())
}

upserted 3 points: ["dune", "foundation", "hobbit"]
foundation 0.0369
hobbit 0.8922
near dune: foundation, like hobbit: foundation
updated 1, 2 published before 1960
first page: ["dune", "foundation"], next cursor Some("foundation")
no point `nope`
409 Conflict already_exists