shardmap 0.3.0

Sharded embedded in-memory map with optional cache, protocol, and server internals
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

use shardmap::{SemanticCacheError, ShardCache};

struct User<'a> {
    tenant: &'a str,
    groups: &'a [&'a str],
}

fn can_use_cached_answer(user: &User<'_>, metadata: &[u8]) -> bool {
    let Ok(metadata) = std::str::from_utf8(metadata) else {
        return false;
    };

    let tenant_ok = metadata.contains(&format!("tenant={}", user.tenant));
    let group_ok = user
        .groups
        .iter()
        .any(|group| metadata.contains(&format!("group={group}")));
    tenant_ok && group_ok
}

fn main() -> Result<(), SemanticCacheError> {
    let cache = ShardCache::new();

    cache.insert_semantic_slice(
        b"prompt:shipping",
        b"Standard shipping takes three to five business days.",
        &[1.0, 0.0],
    )?;
    cache.insert_semantic_slice_with_governance(
        b"prompt:refunds",
        b"Refunds are available within 30 days.",
        &[0.0, 1.0],
        b"tenant=acme;group=support;doc=refund-policy;policy=7",
    )?;

    let shipping = cache.semantic_search(&[0.95, 0.05], 0.75)?.unwrap();
    assert_eq!(
        shipping.value.as_ref(),
        b"Standard shipping takes three to five business days."
    );
    assert!(shipping.governance.is_none());

    let support_user = User {
        tenant: "acme",
        groups: &["support"],
    };
    let refund = cache
        .semantic_search_with_governance_filter(&[0.05, 0.95], 0.75, |metadata| {
            metadata.is_some_and(|bytes| can_use_cached_answer(&support_user, bytes))
        })?
        .unwrap();
    assert_eq!(
        refund.value.as_ref(),
        b"Refunds are available within 30 days."
    );

    let sales_user = User {
        tenant: "acme",
        groups: &["sales"],
    };
    let blocked =
        cache.semantic_search_with_governance_filter(&[0.05, 0.95], 0.75, |metadata| {
            metadata.is_some_and(|bytes| can_use_cached_answer(&sales_user, bytes))
        })?;
    assert!(blocked.is_none());

    Ok(())
}