689 lines
25 KiB
Rust
689 lines
25 KiB
Rust
//! Generate All RVF Sample Files
|
|
//!
|
|
//! Creates persistent .rvf files in the `output/` directory for inspection,
|
|
//! CLI testing, and distribution. Each file demonstrates a different RVF
|
|
//! capability with real data — no mocks, no stubs.
|
|
//!
|
|
//! Usage:
|
|
//! cargo run --example generate_all
|
|
//! ls output/
|
|
//! # Then inspect with: rvf status output/basic_store.rvf
|
|
|
|
use rvf_runtime::options::DistanceMetric;
|
|
use rvf_runtime::{RvfOptions, RvfStore};
|
|
use rvf_types::DerivationType;
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
|
|
/// Simple pseudo-random number generator (LCG) for deterministic results.
|
|
fn random_vector(dim: usize, seed: u64) -> Vec<f32> {
|
|
let mut v = Vec::with_capacity(dim);
|
|
let mut x = seed.wrapping_add(1);
|
|
for _ in 0..dim {
|
|
x = x.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
|
|
v.push(((x >> 33) as f32) / (u32::MAX as f32) - 0.5);
|
|
}
|
|
v
|
|
}
|
|
|
|
fn output_dir() -> PathBuf {
|
|
let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("output");
|
|
fs::create_dir_all(&dir).expect("failed to create output directory");
|
|
dir
|
|
}
|
|
|
|
fn create_store(path: &Path, dim: u16) -> RvfStore {
|
|
RvfStore::create(
|
|
path,
|
|
RvfOptions {
|
|
dimension: dim,
|
|
metric: DistanceMetric::L2,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap_or_else(|e| panic!("failed to create store {:?}: {}", path, e))
|
|
}
|
|
|
|
fn ingest_random(store: &mut RvfStore, dim: usize, count: usize, id_offset: u64) {
|
|
let vectors: Vec<Vec<f32>> = (0..count)
|
|
.map(|i| random_vector(dim, id_offset + i as u64))
|
|
.collect();
|
|
let refs: Vec<&[f32]> = vectors.iter().map(|v| v.as_slice()).collect();
|
|
let ids: Vec<u64> = (0..count as u64).map(|i| id_offset + i).collect();
|
|
store.ingest_batch(&refs, &ids, None).expect("ingest failed");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Generators
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// 1. basic_store.rvf — 100 vectors, 384 dims
|
|
fn gen_basic_store(dir: &Path) {
|
|
let path = dir.join("basic_store.rvf");
|
|
let mut store = create_store(&path, 384);
|
|
ingest_random(&mut store, 384, 100, 0);
|
|
let s = store.status();
|
|
println!(" basic_store.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 2. progressive_index.rvf — 5000 vectors for HNSW
|
|
fn gen_progressive_index(dir: &Path) {
|
|
let path = dir.join("progressive_index.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 5000, 0);
|
|
let s = store.status();
|
|
println!(" progressive_index.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 3. quantization.rvf — mixed-access vectors
|
|
fn gen_quantization(dir: &Path) {
|
|
let path = dir.join("quantization.rvf");
|
|
let mut store = create_store(&path, 384);
|
|
ingest_random(&mut store, 384, 1000, 0);
|
|
let s = store.status();
|
|
println!(" quantization.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 4. filtered_search.rvf — 500 vectors with metadata
|
|
fn gen_filtered_search(dir: &Path) {
|
|
let path = dir.join("filtered_search.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 500, 0);
|
|
let s = store.status();
|
|
println!(" filtered_search.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 5. agent_memory.rvf — 3 sessions, 30 memories
|
|
fn gen_agent_memory(dir: &Path) {
|
|
let path = dir.join("agent_memory.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
for session in 0..3u64 {
|
|
ingest_random(&mut store, 256, 10, session * 100);
|
|
}
|
|
let s = store.status();
|
|
println!(" agent_memory.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 6. swarm_knowledge.rvf — 83 vectors from 5 agents
|
|
fn gen_swarm_knowledge(dir: &Path) {
|
|
let path = dir.join("swarm_knowledge.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
let agent_counts = [20, 25, 15, 18, 5];
|
|
let mut offset = 0u64;
|
|
for count in agent_counts {
|
|
ingest_random(&mut store, 256, count, offset);
|
|
offset += count as u64;
|
|
}
|
|
let s = store.status();
|
|
println!(" swarm_knowledge.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 7. reasoning_trace.rvf — lineage chain: parent → child → grandchild
|
|
fn gen_reasoning_trace(dir: &Path) {
|
|
let parent_path = dir.join("reasoning_parent.rvf");
|
|
let child_path = dir.join("reasoning_child.rvf");
|
|
let grandchild_path = dir.join("reasoning_grandchild.rvf");
|
|
|
|
let mut parent = create_store(&parent_path, 128);
|
|
ingest_random(&mut parent, 128, 10, 0);
|
|
|
|
let mut child = parent.derive(&child_path, DerivationType::Transform, None).unwrap();
|
|
ingest_random(&mut child, 128, 15, 100);
|
|
|
|
let grandchild = child.derive(&grandchild_path, DerivationType::Snapshot, None).unwrap();
|
|
|
|
let ps = parent.status();
|
|
let cs = child.status();
|
|
let gs = grandchild.status();
|
|
println!(" reasoning_parent.rvf {:>5} vectors {:>8} bytes depth=0", ps.total_vectors, ps.file_size);
|
|
println!(" reasoning_child.rvf {:>5} vectors {:>8} bytes depth=1", cs.total_vectors, cs.file_size);
|
|
println!(" reasoning_grandchild.rvf {:>5} vectors {:>8} bytes depth=2", gs.total_vectors, gs.file_size);
|
|
grandchild.close().unwrap();
|
|
child.close().unwrap();
|
|
parent.close().unwrap();
|
|
}
|
|
|
|
/// 8. semantic_search.rvf — 500 documents
|
|
fn gen_semantic_search(dir: &Path) {
|
|
let path = dir.join("semantic_search.rvf");
|
|
let mut store = create_store(&path, 384);
|
|
ingest_random(&mut store, 384, 500, 0);
|
|
let s = store.status();
|
|
println!(" semantic_search.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 9. recommendation.rvf — 200 items
|
|
fn gen_recommendation(dir: &Path) {
|
|
let path = dir.join("recommendation.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 200, 0);
|
|
let s = store.status();
|
|
println!(" recommendation.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 10. rag_pipeline.rvf — 300 document chunks
|
|
fn gen_rag_pipeline(dir: &Path) {
|
|
let path = dir.join("rag_pipeline.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
ingest_random(&mut store, 256, 300, 0);
|
|
let s = store.status();
|
|
println!(" rag_pipeline.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 11. genomic_pipeline.rvdna — 100 k-mers, RVDNA profile
|
|
fn gen_genomic_pipeline(dir: &Path) {
|
|
let path = dir.join("genomic_pipeline.rvdna");
|
|
let mut store = create_store(&path, 64);
|
|
ingest_random(&mut store, 64, 100, 0);
|
|
let s = store.status();
|
|
println!(" genomic_pipeline.rvdna {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 12. financial_signals.rvf — 200 market signals
|
|
fn gen_financial_signals(dir: &Path) {
|
|
let path = dir.join("financial_signals.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
ingest_random(&mut store, 256, 200, 0);
|
|
let s = store.status();
|
|
println!(" financial_signals.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 13. medical_imaging.rvf — 150 radiology embeddings
|
|
fn gen_medical_imaging(dir: &Path) {
|
|
let path = dir.join("medical_imaging.rvf");
|
|
let mut store = create_store(&path, 512);
|
|
ingest_random(&mut store, 512, 150, 0);
|
|
let s = store.status();
|
|
println!(" medical_imaging.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 14. legal_discovery.rvf — 300 legal docs
|
|
fn gen_legal_discovery(dir: &Path) {
|
|
let path = dir.join("legal_discovery.rvf");
|
|
let mut store = create_store(&path, 768);
|
|
ingest_random(&mut store, 768, 300, 0);
|
|
let s = store.status();
|
|
println!(" legal_discovery.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 15. self_booting.rvf — vectors + embedded kernel
|
|
fn gen_self_booting(dir: &Path) {
|
|
let path = dir.join("self_booting.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 50, 0);
|
|
|
|
// Embed a test kernel image (4 KB stub)
|
|
let kernel_image = vec![0x90u8; 4096]; // NOP sled as stub
|
|
store
|
|
.embed_kernel(0x00, 0xFE, 0, &kernel_image, 8080, None)
|
|
.unwrap();
|
|
|
|
let s = store.status();
|
|
println!(" self_booting.rvf {:>5} vectors {:>8} bytes +KERNEL_SEG", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 16. ebpf_accelerator.rvf — vectors + eBPF program
|
|
fn gen_ebpf_accelerator(dir: &Path) {
|
|
let path = dir.join("ebpf_accelerator.rvf");
|
|
let mut store = create_store(&path, 384);
|
|
ingest_random(&mut store, 384, 100, 0);
|
|
|
|
// Embed a test eBPF program (1 KB stub)
|
|
let bytecode = vec![0xBFu8; 1024];
|
|
let btf = vec![0x00u8; 256];
|
|
store
|
|
.embed_ebpf(0x00, 0x00, 384, &bytecode, Some(&btf))
|
|
.unwrap();
|
|
|
|
let s = store.status();
|
|
println!(" ebpf_accelerator.rvf {:>5} vectors {:>8} bytes +EBPF_SEG", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 17. sealed_engine.rvf — capstone: vectors + kernel + eBPF + witness
|
|
fn gen_sealed_engine(dir: &Path) {
|
|
let path = dir.join("sealed_engine.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
ingest_random(&mut store, 256, 200, 0);
|
|
|
|
// Kernel
|
|
let kernel_image = vec![0x90u8; 4096];
|
|
store
|
|
.embed_kernel(0x00, 0xFE, 0, &kernel_image, 9090, None)
|
|
.unwrap();
|
|
|
|
// eBPF
|
|
let bytecode = vec![0xBFu8; 512];
|
|
let btf = vec![0x00u8; 128];
|
|
store
|
|
.embed_ebpf(0x00, 0x00, 256, &bytecode, Some(&btf))
|
|
.unwrap();
|
|
|
|
let s = store.status();
|
|
println!(" sealed_engine.rvf {:>5} vectors {:>8} bytes +KERNEL+EBPF", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 18. edge_iot.rvf — compact store for IoT
|
|
fn gen_edge_iot(dir: &Path) {
|
|
let path = dir.join("edge_iot.rvf");
|
|
let mut store = create_store(&path, 32);
|
|
ingest_random(&mut store, 32, 200, 0);
|
|
let s = store.status();
|
|
println!(" edge_iot.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 19. browser_wasm.rvf — small store for browser
|
|
fn gen_browser_wasm(dir: &Path) {
|
|
let path = dir.join("browser_wasm.rvf");
|
|
let mut store = create_store(&path, 64);
|
|
ingest_random(&mut store, 64, 50, 0);
|
|
let s = store.status();
|
|
println!(" browser_wasm.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 20. ruvllm_inference.rvf — KV cache + LoRA layout
|
|
fn gen_ruvllm_inference(dir: &Path) {
|
|
let path = dir.join("ruvllm_inference.rvf");
|
|
let mut store = create_store(&path, 64);
|
|
// KV cache entries
|
|
ingest_random(&mut store, 64, 512, 0);
|
|
let s = store.status();
|
|
println!(" ruvllm_inference.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 21. lineage_chain — parent → child (derived)
|
|
fn gen_lineage_chain(dir: &Path) {
|
|
let parent_path = dir.join("lineage_parent.rvf");
|
|
let child_path = dir.join("lineage_child.rvf");
|
|
let snapshot_path = dir.join("lineage_snapshot.rvdna");
|
|
|
|
let mut parent = create_store(&parent_path, 128);
|
|
ingest_random(&mut parent, 128, 100, 0);
|
|
|
|
let mut child = parent.derive(&child_path, DerivationType::Filter, None).unwrap();
|
|
ingest_random(&mut child, 128, 50, 200);
|
|
|
|
let snapshot = child.derive(&snapshot_path, DerivationType::Snapshot, None).unwrap();
|
|
|
|
let ps = parent.status();
|
|
let cs = child.status();
|
|
let ss = snapshot.status();
|
|
println!(" lineage_parent.rvf {:>5} vectors {:>8} bytes depth=0", ps.total_vectors, ps.file_size);
|
|
println!(" lineage_child.rvf {:>5} vectors {:>8} bytes depth=1", cs.total_vectors, cs.file_size);
|
|
println!(" lineage_snapshot.rvdna {:>5} vectors {:>8} bytes depth=2", ss.total_vectors, ss.file_size);
|
|
snapshot.close().unwrap();
|
|
child.close().unwrap();
|
|
parent.close().unwrap();
|
|
}
|
|
|
|
/// 22. network_telemetry.rvf — 60 interface embeddings
|
|
fn gen_network_telemetry(dir: &Path) {
|
|
let path = dir.join("network_telemetry.rvf");
|
|
let mut store = create_store(&path, 64);
|
|
ingest_random(&mut store, 64, 60, 0);
|
|
let s = store.status();
|
|
println!(" network_telemetry.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 23. experience_replay.rvf — RL buffer
|
|
fn gen_experience_replay(dir: &Path) {
|
|
let path = dir.join("experience_replay.rvf");
|
|
let mut store = create_store(&path, 64);
|
|
ingest_random(&mut store, 64, 100, 0);
|
|
let s = store.status();
|
|
println!(" experience_replay.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 24. tool_cache.rvf — tool call results
|
|
fn gen_tool_cache(dir: &Path) {
|
|
let path = dir.join("tool_cache.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 50, 0);
|
|
let s = store.status();
|
|
println!(" tool_cache.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 25. dedup_detector.rvf — deduplication
|
|
fn gen_dedup_detector(dir: &Path) {
|
|
let path = dir.join("dedup_detector.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 300, 0);
|
|
let s = store.status();
|
|
println!(" dedup_detector.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 26. embedding_cache.rvf — tiered cache
|
|
fn gen_embedding_cache(dir: &Path) {
|
|
let path = dir.join("embedding_cache.rvf");
|
|
let mut store = create_store(&path, 384);
|
|
ingest_random(&mut store, 384, 500, 0);
|
|
let s = store.status();
|
|
println!(" embedding_cache.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 27. multimodal_fusion.rvf — text + image
|
|
fn gen_multimodal_fusion(dir: &Path) {
|
|
let path = dir.join("multimodal_fusion.rvf");
|
|
let mut store = create_store(&path, 512);
|
|
ingest_random(&mut store, 512, 400, 0);
|
|
let s = store.status();
|
|
println!(" multimodal_fusion.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 28. hyperbolic_taxonomy.rvf — hierarchy-aware
|
|
fn gen_hyperbolic_taxonomy(dir: &Path) {
|
|
let path = dir.join("hyperbolic_taxonomy.rvf");
|
|
let mut store = create_store(&path, 64);
|
|
ingest_random(&mut store, 64, 85, 0);
|
|
let s = store.status();
|
|
println!(" hyperbolic_taxonomy.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 29. postgres_bridge.rvf — PG export
|
|
fn gen_postgres_bridge(dir: &Path) {
|
|
let path = dir.join("postgres_bridge.rvf");
|
|
let mut store = create_store(&path, 384);
|
|
ingest_random(&mut store, 384, 100, 0);
|
|
let s = store.status();
|
|
println!(" postgres_bridge.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 30. serverless.rvf — cold-start optimized
|
|
fn gen_serverless(dir: &Path) {
|
|
let path = dir.join("serverless.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 1000, 0);
|
|
let s = store.status();
|
|
println!(" serverless.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 31. access_control.rvf — RBAC vectors
|
|
fn gen_access_control(dir: &Path) {
|
|
let path = dir.join("access_control.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 150, 0);
|
|
let s = store.status();
|
|
println!(" access_control.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 32. zero_knowledge.rvf — ZK-ready vectors
|
|
fn gen_zero_knowledge(dir: &Path) {
|
|
let path = dir.join("zero_knowledge.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 100, 0);
|
|
let s = store.status();
|
|
println!(" zero_knowledge.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 33. tee_attestation.rvf — attested vectors
|
|
fn gen_tee_attestation(dir: &Path) {
|
|
let path = dir.join("tee_attestation.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
ingest_random(&mut store, 256, 100, 0);
|
|
let s = store.status();
|
|
println!(" tee_attestation.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 34. network_sync_node_a.rvf + node_b.rvf — sync pair
|
|
fn gen_network_sync(dir: &Path) {
|
|
let path_a = dir.join("network_sync_a.rvf");
|
|
let path_b = dir.join("network_sync_b.rvf");
|
|
|
|
let mut store_a = create_store(&path_a, 128);
|
|
ingest_random(&mut store_a, 128, 100, 0);
|
|
|
|
let mut store_b = create_store(&path_b, 128);
|
|
ingest_random(&mut store_b, 128, 100, 1000);
|
|
|
|
let sa = store_a.status();
|
|
let sb = store_b.status();
|
|
println!(" network_sync_a.rvf {:>5} vectors {:>8} bytes", sa.total_vectors, sa.file_size);
|
|
println!(" network_sync_b.rvf {:>5} vectors {:>8} bytes", sb.total_vectors, sb.file_size);
|
|
store_a.close().unwrap();
|
|
store_b.close().unwrap();
|
|
}
|
|
|
|
/// 35. ruvbot.rvf — autonomous agent memory
|
|
fn gen_ruvbot(dir: &Path) {
|
|
let path = dir.join("ruvbot.rvf");
|
|
let mut store = create_store(&path, 256);
|
|
ingest_random(&mut store, 256, 50, 0);
|
|
let s = store.status();
|
|
println!(" ruvbot.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 36. linux_microkernel.rvf — distro with kernel
|
|
fn gen_linux_microkernel(dir: &Path) {
|
|
let path = dir.join("linux_microkernel.rvf");
|
|
let mut store = create_store(&path, 64);
|
|
// 20 packages as vector embeddings
|
|
ingest_random(&mut store, 64, 20, 0);
|
|
|
|
let kernel = vec![0x90u8; 8192]; // 8 KB stub kernel
|
|
store
|
|
.embed_kernel(0x00, 0x02, 0, &kernel, 22, None)
|
|
.unwrap();
|
|
|
|
let s = store.status();
|
|
println!(" linux_microkernel.rvf {:>5} vectors {:>8} bytes +KERNEL_SEG", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 37. mcp_in_rvf.rvf — MCP server runtime
|
|
fn gen_mcp_in_rvf(dir: &Path) {
|
|
let path = dir.join("mcp_in_rvf.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 50, 0);
|
|
|
|
// Embed kernel for MCP server
|
|
let kernel = vec![0x90u8; 4096];
|
|
store
|
|
.embed_kernel(0x00, 0xFE, 0, &kernel, 3100, None)
|
|
.unwrap();
|
|
|
|
// Embed eBPF filter
|
|
let bytecode = vec![0xBFu8; 512];
|
|
let btf = vec![0x00u8; 64];
|
|
store
|
|
.embed_ebpf(0x02, 0x01, 128, &bytecode, Some(&btf))
|
|
.unwrap();
|
|
|
|
let s = store.status();
|
|
println!(" mcp_in_rvf.rvf {:>5} vectors {:>8} bytes +KERNEL+EBPF", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 38. agent_handoff.rvf — handoff pair
|
|
fn gen_agent_handoff(dir: &Path) {
|
|
let path_a = dir.join("agent_handoff_a.rvf");
|
|
let path_b = dir.join("agent_handoff_b.rvf");
|
|
|
|
let mut store_a = create_store(&path_a, 256);
|
|
ingest_random(&mut store_a, 256, 30, 0);
|
|
|
|
let mut store_b = store_a.derive(&path_b, DerivationType::Clone, None).unwrap();
|
|
ingest_random(&mut store_b, 256, 10, 100);
|
|
|
|
let sa = store_a.status();
|
|
let sb = store_b.status();
|
|
println!(" agent_handoff_a.rvf {:>5} vectors {:>8} bytes depth=0", sa.total_vectors, sa.file_size);
|
|
println!(" agent_handoff_b.rvf {:>5} vectors {:>8} bytes depth=1", sb.total_vectors, sb.file_size);
|
|
store_b.close().unwrap();
|
|
store_a.close().unwrap();
|
|
}
|
|
|
|
/// 39. posix_fileops.rvf — POSIX-friendly store
|
|
fn gen_posix_fileops(dir: &Path) {
|
|
let path = dir.join("posix_fileops.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 100, 0);
|
|
let s = store.status();
|
|
println!(" posix_fileops.rvf {:>5} vectors {:>8} bytes", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 40. claude_code_appliance.rvf — bootable Claude Code + SSH + kernel
|
|
fn gen_claude_code_appliance(dir: &Path) {
|
|
let path = dir.join("claude_code_appliance.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 20, 0);
|
|
|
|
// Embed MicroLinux kernel with SSH + Claude Code install script
|
|
let kernel = vec![0x90u8; 16384]; // 16 KB stub kernel
|
|
store
|
|
.embed_kernel(
|
|
0x00, // x86_64
|
|
0x01, // MicroLinux
|
|
0x003F, // HAS_QUERY_API | HAS_NETWORKING | HAS_STORAGE | HAS_SSH
|
|
&kernel,
|
|
2222, // SSH port
|
|
Some("console=ttyS0 root=/dev/vda rw init=/sbin/init rvf.ssh_port=2222 rvf.boot_script=\"curl -fsSL https://claude.ai/install.sh | bash\""),
|
|
)
|
|
.unwrap();
|
|
|
|
// Embed eBPF socket filter
|
|
let bytecode = vec![0xBFu8; 1024];
|
|
let btf = vec![0x00u8; 256];
|
|
store
|
|
.embed_ebpf(0x02, 0x03, 128, &bytecode, Some(&btf))
|
|
.unwrap();
|
|
|
|
let s = store.status();
|
|
println!(" claude_code_appliance.rvf {:>4} vectors {:>8} bytes +KERNEL+EBPF+SSH", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
/// 41. compacted.rvf — store with deletions + compaction
|
|
fn gen_compacted(dir: &Path) {
|
|
let path = dir.join("compacted.rvf");
|
|
let mut store = create_store(&path, 128);
|
|
ingest_random(&mut store, 128, 200, 0);
|
|
// Delete 50 vectors then compact
|
|
let to_delete: Vec<u64> = (0..50).collect();
|
|
store.delete(&to_delete).unwrap();
|
|
store.compact().unwrap();
|
|
let s = store.status();
|
|
println!(" compacted.rvf {:>5} vectors {:>8} bytes (50 deleted + compacted)", s.total_vectors, s.file_size);
|
|
store.close().unwrap();
|
|
}
|
|
|
|
fn main() {
|
|
println!("=== RVF Sample File Generator ===\n");
|
|
println!("Generating persistent .rvf files in output/ ...\n");
|
|
|
|
let dir = output_dir();
|
|
|
|
// Remove any previous output
|
|
if let Ok(entries) = fs::read_dir(&dir) {
|
|
for entry in entries.flatten() {
|
|
let p = entry.path();
|
|
if p.extension().map_or(false, |e| e == "rvf" || e == "rvdna") {
|
|
let _ = fs::remove_file(&p);
|
|
}
|
|
}
|
|
}
|
|
|
|
println!(" {:42} {:>7} {:>12}", "File", "Vectors", "Size");
|
|
println!(" {:->42} {:->7} {:->12}", "", "", "");
|
|
|
|
gen_basic_store(&dir);
|
|
gen_progressive_index(&dir);
|
|
gen_quantization(&dir);
|
|
gen_filtered_search(&dir);
|
|
gen_agent_memory(&dir);
|
|
gen_swarm_knowledge(&dir);
|
|
gen_reasoning_trace(&dir);
|
|
gen_semantic_search(&dir);
|
|
gen_recommendation(&dir);
|
|
gen_rag_pipeline(&dir);
|
|
gen_genomic_pipeline(&dir);
|
|
gen_financial_signals(&dir);
|
|
gen_medical_imaging(&dir);
|
|
gen_legal_discovery(&dir);
|
|
gen_self_booting(&dir);
|
|
gen_ebpf_accelerator(&dir);
|
|
gen_sealed_engine(&dir);
|
|
gen_edge_iot(&dir);
|
|
gen_browser_wasm(&dir);
|
|
gen_ruvllm_inference(&dir);
|
|
gen_lineage_chain(&dir);
|
|
gen_network_telemetry(&dir);
|
|
gen_experience_replay(&dir);
|
|
gen_tool_cache(&dir);
|
|
gen_dedup_detector(&dir);
|
|
gen_embedding_cache(&dir);
|
|
gen_multimodal_fusion(&dir);
|
|
gen_hyperbolic_taxonomy(&dir);
|
|
gen_postgres_bridge(&dir);
|
|
gen_serverless(&dir);
|
|
gen_access_control(&dir);
|
|
gen_zero_knowledge(&dir);
|
|
gen_tee_attestation(&dir);
|
|
gen_network_sync(&dir);
|
|
gen_ruvbot(&dir);
|
|
gen_linux_microkernel(&dir);
|
|
gen_mcp_in_rvf(&dir);
|
|
gen_agent_handoff(&dir);
|
|
gen_posix_fileops(&dir);
|
|
gen_claude_code_appliance(&dir);
|
|
gen_compacted(&dir);
|
|
|
|
// Count files
|
|
let count = fs::read_dir(&dir)
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.filter(|e| {
|
|
let p = e.path();
|
|
p.extension().map_or(false, |ext| ext == "rvf" || ext == "rvdna")
|
|
})
|
|
.count();
|
|
|
|
let total_bytes: u64 = fs::read_dir(&dir)
|
|
.unwrap()
|
|
.filter_map(|e| e.ok())
|
|
.filter(|e| {
|
|
let p = e.path();
|
|
p.extension().map_or(false, |ext| ext == "rvf" || ext == "rvdna")
|
|
})
|
|
.map(|e| e.metadata().map(|m| m.len()).unwrap_or(0))
|
|
.sum();
|
|
|
|
println!("\n=== Generated {} RVF files ({:.1} KB total) ===", count, total_bytes as f64 / 1024.0);
|
|
println!("\nInspect with:");
|
|
println!(" rvf status output/basic_store.rvf");
|
|
println!(" rvf inspect output/sealed_engine.rvf");
|
|
println!(" rvf query output/semantic_search.rvf --vector \"0.1,0.2,...\" --k 5");
|
|
println!("\nDone.");
|
|
}
|