sqlrite 1.0.2

RAG-oriented SQLite wrapper for AI agent workloads
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

// Run: cargo run --example query_use_cases
// Demonstrates: text/vector/hybrid, metadata filters, doc scope, RRF, and candidate tuning.

use serde_json::json;
use sqlrite::{ChunkInput, FusionStrategy, Result, SearchRequest, SearchResult, SqlRite};

fn main() -> Result<()> {
    let db = SqlRite::open_in_memory()?;
    seed(&db)?;

    println!("== 1) Text-only query ==");
    print_results(&db.search(SearchRequest::text("local sqlite rag", 3))?, 3);

    println!("\n== 2) Vector-only query ==");
    print_results(
        &db.search(SearchRequest::vector(vec![0.95, 0.05, 0.0], 3))?,
        3,
    );

    println!("\n== 3) Hybrid query with alpha tuning ==");
    let mut hybrid = SearchRequest::hybrid("audit logging", vec![0.55, 0.45, 0.0], 3);
    hybrid.alpha = 0.35;
    print_results(&db.search(hybrid)?, 3);

    println!("\n== 4) Metadata-filtered query (tenant/topic) ==");
    let filtered = SearchRequest::builder()
        .query_text("policy governance")
        .metadata_filter("tenant", "acme")
        .metadata_filter("topic", "security")
        .top_k(5)
        .build()?;
    print_results(&db.search(filtered)?, 5);

    println!("\n== 5) Doc-scoped query ==");
    let doc_scoped = SearchRequest::builder()
        .query_text("ingestion checkpoint")
        .doc_id("doc-ingest")
        .top_k(5)
        .build()?;
    print_results(&db.search(doc_scoped)?, 5);

    println!("\n== 6) RRF fusion query ==");
    let rrf = SearchRequest::builder()
        .query_text("latency throughput")
        .query_embedding(vec![0.15, 0.85, 0.0])
        .fusion_strategy(FusionStrategy::ReciprocalRankFusion {
            rank_constant: 60.0,
        })
        .top_k(3)
        .build()?;
    print_results(&db.search(rrf)?, 3);

    println!("\n== 7) Candidate-limit tuning (precision/latency control) ==");
    let tuned = SearchRequest::builder()
        .query_text("retrieval memory")
        .query_embedding(vec![0.7, 0.3, 0.0])
        .candidate_limit(25)
        .top_k(3)
        .build()?;
    print_results(&db.search(tuned)?, 3);

    Ok(())
}

fn seed(db: &SqlRite) -> Result<()> {
    db.ingest_chunks(&[
        ChunkInput::new(
            "c1",
            "doc-rag",
            "SQLite powers local-first RAG memory for agents.",
            vec![0.98, 0.02, 0.0],
        )
        .with_metadata(json!({"tenant": "acme", "topic": "retrieval"})),
        ChunkInput::new(
            "c2",
            "doc-security",
            "Policy enforcement and audit logging are critical for tenant governance.",
            vec![0.50, 0.50, 0.0],
        )
        .with_metadata(json!({"tenant": "acme", "topic": "security"})),
        ChunkInput::new(
            "c3",
            "doc-ingest",
            "Ingestion checkpoints support restart-safe pipelines.",
            vec![0.75, 0.25, 0.0],
        )
        .with_metadata(json!({"tenant": "acme", "topic": "ingestion"})),
        ChunkInput::new(
            "c4",
            "doc-perf",
            "Benchmark latency and throughput to tune retrieval performance.",
            vec![0.10, 0.90, 0.0],
        )
        .with_metadata(json!({"tenant": "acme", "topic": "performance"})),
        ChunkInput::new(
            "c5",
            "doc-rag",
            "Hybrid retrieval blends embeddings with lexical ranking.",
            vec![0.85, 0.15, 0.0],
        )
        .with_metadata(json!({"tenant": "acme", "topic": "retrieval"})),
        ChunkInput::new(
            "c6",
            "doc-security",
            "Key rotation and encrypted metadata protect sensitive fields.",
            vec![0.35, 0.65, 0.0],
        )
        .with_metadata(json!({"tenant": "beta", "topic": "security"})),
    ])?;
    Ok(())
}

fn print_results(results: &[SearchResult], max_rows: usize) {
    if results.is_empty() {
        println!("(no results)");
        return;
    }

    for result in results.iter().take(max_rows) {
        let tenant = result
            .metadata
            .get("tenant")
            .and_then(serde_json::Value::as_str)
            .unwrap_or("n/a");
        let topic = result
            .metadata
            .get("topic")
            .and_then(serde_json::Value::as_str)
            .unwrap_or("n/a");
        println!(
            "- {} | doc={} | tenant={} | topic={} | hybrid={:.3} | vector={:.3} | text={:.3}",
            result.chunk_id,
            result.doc_id,
            tenant,
            topic,
            result.hybrid_score,
            result.vector_score,
            result.text_score
        );
    }
}