Crate ipfrs_semantic

Expand description

§IPFRS Semantic - Vector Search and Semantic Routing

This crate provides high-performance semantic search and routing capabilities for IPFRS, enabling content discovery based on vector embeddings and semantic similarity.

§Features

HNSW-based Vector Search - Fast approximate nearest neighbor search
Semantic Routing - Content discovery based on embeddings
Hybrid Search - Combine vector search with metadata filtering
Vector Quantization - Memory-efficient index compression (PQ, OPQ, Scalar)
Learned Indices - ML-based indexing with Recursive Model Index (RMI)
Logic Integration - TensorLogic reasoning with embeddings
DiskANN - Disk-based indexing for 100M+ vectors
SIMD Optimization - ARM NEON and x86 SSE/AVX acceleration
Caching - Hot embedding cache with LRU eviction
Batch Query Processing - Parallel batch queries for high throughput
Query Re-ranking - Multi-criteria result re-ranking with weighted scoring
Query Analytics - Performance tracking and query pattern analysis
Multi-Modal Search - Unified search across text, image, audio, video, and code
Differential Privacy - Privacy-preserving embeddings with configurable privacy budgets
Dynamic Updates - Online embedding updates and version migration
Vector Quality Analysis - Data validation, anomaly detection, and quality metrics (NEW!)
Index Diagnostics - Health monitoring, performance profiling, and issue detection (NEW!)
Index Optimization - Automatic parameter tuning and resource management (NEW!)
Auto-Scaling Advisor - Intelligent scaling recommendations for production deployments (NEW!)

§Quick Start

§Basic Semantic Search

use ipfrs_semantic::{SemanticRouter, RouterConfig};
use ipfrs_core::Cid;

// Create a semantic router with default configuration
let router = SemanticRouter::with_defaults()?;

// Index content with embeddings (typically from a model like BERT, CLIP, etc.)
let cid1: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let embedding1 = vec![0.1, 0.2, 0.3]; // 768-dim embedding in real use

// Add to index
router.add(&cid1, &vec![0.5; 768])?;

// Query for similar content
let query_embedding = vec![0.5; 768];
let results = router.query(&query_embedding, 10).await?;

for result in results {
    println!("CID: {}, Score: {}", result.cid, result.score);
}

§Batch Query for High Throughput

use ipfrs_semantic::{SemanticRouter, RouterConfig};
use ipfrs_core::Cid;

// Create a semantic router
let router = SemanticRouter::with_defaults()?;

// Index multiple items
let items = vec![
    ("bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse::<Cid>()?, vec![0.1; 768]),
    ("bafybeihpjhkeuiq3k6nqa3fkgeigeri7iebtrsuyuey5y6vy36n345xmbi".parse::<Cid>()?, vec![0.2; 768]),
    ("bafybeif2pall7dybz7vecqka3zo24irdwabwdi4wc55jznaq75q7eaavvu".parse::<Cid>()?, vec![0.3; 768]),
];

router.add_batch(&items)?;

// Batch query - process multiple queries in parallel
let query_embeddings = vec![
    vec![0.15; 768],
    vec![0.25; 768],
    vec![0.35; 768],
];

// More efficient than querying one by one
let batch_results = router.query_batch(&query_embeddings, 10).await?;

for (i, results) in batch_results.iter().enumerate() {
    println!("Query {} found {} results", i, results.len());
}

// Get batch statistics
let stats = router.batch_stats(&batch_results);
println!("Total queries: {}", stats.total_queries);
println!("Avg results per query: {:.2}", stats.avg_results_per_query);
println!("Avg score: {:.4}", stats.avg_score);

§Hybrid Search with Metadata Filtering

use ipfrs_semantic::{HybridIndex, HybridConfig, HybridQuery, Metadata, MetadataValue, MetadataFilter};
use ipfrs_core::Cid;

// Create hybrid index
let config = HybridConfig::default();
let index = HybridIndex::new(config)?;

// Index content with metadata
let cid: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let embedding = vec![0.5; 768];

let mut metadata = Metadata::new();
metadata.set("type", MetadataValue::String("image".to_string()));
metadata.set("size", MetadataValue::Integer(1024));

index.insert(&cid, &embedding, Some(metadata))?;

// Query with filters using builder pattern
let filter = MetadataFilter::eq("type", MetadataValue::String("image".to_string()));
let query = HybridQuery::knn(vec![0.5; 768], 10)
    .with_filter(filter);

let response = index.search(query).await?;
println!("Found {} results", response.results.len());

§Vector Quantization for Memory Efficiency

use ipfrs_semantic::{ProductQuantizer, ScalarQuantizer};

// Create Product Quantizer (8-32x compression)
let dimension = 768;
let num_subspaces = 8;
let bits_per_subspace = 8;

let mut pq = ProductQuantizer::new(dimension, num_subspaces, bits_per_subspace)?;

// Train on representative data (1000 training samples, max 10 iterations)
let training_data: Vec<Vec<f32>> = vec![vec![0.5; 768]; 1000];
pq.train(&training_data, 10)?;

// Quantize embeddings
let embedding = vec![0.5; 768];
let quantized = pq.quantize(&embedding)?;

println!("Original size: {} bytes", dimension * 4);
println!("Quantized size: {} bytes", quantized.codes.len());

§DiskANN for Large-Scale Indexing

use ipfrs_semantic::{DiskANNIndex, DiskANNConfig};
use ipfrs_core::Cid;

// Create DiskANN index for 100M+ vectors
let config = DiskANNConfig {
    dimension: 768,
    max_degree: 32,
    ..Default::default()
};

let mut index = DiskANNIndex::new(config);
index.create("/path/to/diskann_index")?;

// Insert vectors (stored on disk, not in RAM)
let cid: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let embedding = vec![0.5; 768];
index.insert(&cid, &embedding)?;

// Search with constant memory usage
let results = index.search(&embedding, 10)?;
println!("Found {} results from disk", results.len());

§Learned Index Structures

use ipfrs_semantic::{LearnedIndex, RMIConfig, ModelType};
use ipfrs_core::Cid;

// Create a learned index with Recursive Model Index (RMI)
let config = RMIConfig {
    num_models: 10,              // Number of second-stage models
    model_type: ModelType::Linear, // Linear, Polynomial, or NeuralNetwork
    training_iterations: 100,
    learning_rate: 0.01,
    error_threshold: 0.05,
};

let mut index = LearnedIndex::new(config);

// Add embeddings - the index learns data distribution
for i in 0..1000 {
    let cid = Cid::default();
    let embedding = vec![i as f32 / 1000.0; 768];
    index.add(cid, embedding)?;
}

// The index automatically rebuilds and trains models
let query = vec![0.5; 768];
let results = index.search(&query, 10)?;

// Check statistics
let stats = index.stats();
println!("Indexed {} points using {} models",
         stats.data_points, stats.num_models);

§TensorLogic Integration

use ipfrs_semantic::{LogicSolver, SolverConfig};
use ipfrs_tensorlogic::{Predicate, Term, Constant};
use ipfrs_core::Cid;

// Create a logic solver with semantic similarity
let config = SolverConfig {
    max_depth: 100,
    similarity_threshold: 0.8,
    top_k_similar: 10,
    embedding_dim: 384,
    detect_cycles: true,
};

let mut solver = LogicSolver::new(config)?;

// Add facts to the knowledge base
let cid1: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let fact1 = Predicate::new("likes".to_string(), vec![
    Term::Const(Constant::String("alice".to_string())),
    Term::Const(Constant::String("rust".to_string())),
]);
solver.add_fact(fact1, cid1)?;

let cid2: Cid = "bafybeihpjhkeuiq3k6nqa3fkgeigeri7iebtrsuyuey5y6vy36n345xmbi".parse()?;
let fact2 = Predicate::new("likes".to_string(), vec![
    Term::Const(Constant::String("bob".to_string())),
    Term::Const(Constant::String("python".to_string())),
]);
solver.add_fact(fact2, cid2)?;

// Add a rule for similarity-based matching
// Rule: similar(X, Y) :- likes(X, Lang), likes(Y, Lang)
let head = Predicate::new("similar".to_string(), vec![
    Term::Var("X".to_string()),
    Term::Var("Y".to_string())
]);
let body = vec![
    Predicate::new("likes".to_string(), vec![
        Term::Var("X".to_string()),
        Term::Var("Lang".to_string())
    ]),
    Predicate::new("likes".to_string(), vec![
        Term::Var("Y".to_string()),
        Term::Var("Lang".to_string())
    ]),
];
solver.add_rule(head, body)?;

// Query using semantic similarity
let query = Predicate::new("likes".to_string(), vec![
    Term::Var("Who".to_string()),
    Term::Const(Constant::String("rust".to_string())),
]);

let results = solver.query(&query)?;
for substitution in results {
    println!("Found substitution: {:?}", substitution);
}

// Get solver statistics
let stats = solver.stats();
println!("Total facts: {}", stats.num_facts);
println!("Total rules: {}", stats.num_rules);
println!("Indexed predicates: {}", stats.num_indexed_predicates);

§Custom Embedding Model Integration

use ipfrs_semantic::{SemanticRouter, RouterConfig, DistanceMetric};
use ipfrs_core::Cid;

// Configure router for your embedding model
let config = RouterConfig {
    dimension: 768,  // BERT-base dimension
    metric: DistanceMetric::Cosine,
    max_connections: 16,
    ef_construction: 200,
    ef_search: 50,
    cache_size: 1000,
    ..RouterConfig::default()
};

let router = SemanticRouter::new(config)?;

// Function to generate embeddings from your model
// This is a placeholder - replace with your actual model
fn generate_embedding(text: &str) -> Vec<f32> {
    // Example: Use sentence-transformers, Hugging Face transformers, etc.
    // let model = SentenceTransformer::new("all-MiniLM-L6-v2");
    // model.encode(text)

    // For this example, just return a dummy embedding
    vec![0.5; 768]
}

// Index documents with embeddings
let documents = vec![
    ("Rust programming language", "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi"),
    ("Python machine learning", "bafybeihpjhkeuiq3k6nqa3fkgeigeri7iebtrsuyuey5y6vy36n345xmbi"),
    ("Distributed systems", "bafybeif2pall7dybz7vecqka3zo24irdwabwdi4wc55jznaq75q7eaavvu"),
];

for (text, cid_str) in documents {
    let cid: Cid = cid_str.parse()?;
    let embedding = generate_embedding(text);
    router.add(&cid, &embedding)?;
}

// Query with natural language
let query_text = "rust systems programming";
let query_embedding = generate_embedding(query_text);
let results = router.query(&query_embedding, 5).await?;

println!("Top results for '{}':", query_text);
for result in results {
    println!("  CID: {}, Score: {:.3}", result.cid, result.score);
}

§Distributed Semantic Search

For large-scale deployments across multiple nodes:

use ipfrs_semantic::{SemanticDHTNode, SemanticDHTConfig, VectorIndex, DistanceMetric};
use ipfrs_network::libp2p::PeerId;
use ipfrs_core::Cid;

// Configure distributed semantic DHT
let config = SemanticDHTConfig {
    embedding_dim: 768,
    replication_factor: 3,     // Replicate to 3 peers
    routing_table_size: 20,    // Top 20 nearest peers
    distance_metric: DistanceMetric::Cosine,
    max_hops: 5,               // Maximum query propagation hops
    query_timeout_ms: 5000,    // 5 second timeout
};

// Create local vector index
let local_index = VectorIndex::new(768, DistanceMetric::Cosine, 16, 200)?;

// Create DHT node
let local_peer_id = PeerId::random();
let dht_node = SemanticDHTNode::new(config, local_peer_id, local_index);

// Add peer to routing table
use ipfrs_semantic::SemanticPeer;
let peer_id = PeerId::random();
let peer_embedding = vec![0.5; 768];  // Aggregate embedding of peer's data
let peer = SemanticPeer::new(peer_id, peer_embedding);
dht_node.routing_table().add_peer(peer)?;

// Insert data (automatically replicated to nearest peers)
let cid: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let embedding = vec![0.7; 768];
dht_node.insert(&cid, &embedding).await?;

// Distributed k-NN search across the network
let query_embedding = vec![0.6; 768];
let results = dht_node.search_distributed(&query_embedding, 10).await?;

println!("Found {} results from distributed search", results.len());
for result in results {
    println!("  CID: {}, Score: {:.3}", result.cid, result.score);
}

// Update peer clusters for locality optimization
dht_node.routing_table().update_clusters(3)?;

// Get DHT statistics
let stats = dht_node.get_stats();
println!("DHT Stats:");
println!("  Peers: {}", stats.num_peers);
println!("  Clusters: {}", stats.num_clusters);
println!("  Local entries: {}", stats.num_local_entries);
println!("  Queries processed: {}", stats.queries_processed);
println!("  Avg latency: {:.2}ms", stats.avg_query_latency_ms);

§Federated Multi-Index Search

Query multiple indices simultaneously with heterogeneous distance metrics:

use ipfrs_semantic::{
    FederatedQueryExecutor, FederatedConfig, AggregationStrategy,
    LocalIndexAdapter, VectorIndex, DistanceMetric
};
use ipfrs_core::Cid;
use parking_lot::RwLock;
use std::sync::Arc;

// Configure federated queries
let mut config = FederatedConfig::default();
config.aggregation_strategy = AggregationStrategy::RankFusion; // Best for heterogeneous metrics
config.privacy_preserving = true;  // Enable differential privacy
config.privacy_noise_level = 0.01; // Small noise for privacy

let executor = FederatedQueryExecutor::new(config);

// Create multiple indices with different metrics
let index1 = VectorIndex::new(768, DistanceMetric::Cosine, 16, 200)?;
let index2 = VectorIndex::new(768, DistanceMetric::L2, 16, 200)?;
let index3 = VectorIndex::new(768, DistanceMetric::DotProduct, 16, 200)?;

// Populate indices with data
// (In practice, these might be from different organizations or data sources)
let cid1: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let embedding1 = vec![0.5; 768];
Arc::new(RwLock::new(index1)).write().insert(&cid1, &embedding1)?;

// Register indices for federated queries
let adapter1 = LocalIndexAdapter::new(
    Arc::new(RwLock::new(VectorIndex::new(768, DistanceMetric::Cosine, 16, 200)?)),
    "org1_index".to_string()
);
let adapter2 = LocalIndexAdapter::new(
    Arc::new(RwLock::new(VectorIndex::new(768, DistanceMetric::L2, 16, 200)?)),
    "org2_index".to_string()
);

executor.register_index(Arc::new(adapter1))?;
executor.register_index(Arc::new(adapter2))?;

// Query all registered indices simultaneously
let query_embedding = vec![0.6; 768];
let results = executor.query(&query_embedding, 10).await?;

println!("Federated search found {} results", results.len());
for result in results {
    println!(
        "  CID: {}, Score: {:.3}, Source: {}, Metric: {:?}",
        result.cid, result.score, result.source_index_id, result.source_metric
    );
}

// Query specific indices only
let specific_results = executor.query_indices(
    &query_embedding,
    10,
    &["org1_index".to_string()]
).await?;

// Get federated query statistics
let stats = executor.stats();
println!("Federated Query Stats:");
println!("  Total queries: {}", stats.total_queries);
println!("  Indices queried: {}", stats.total_indices_queried);
println!("  Avg latency: {:.2}ms", stats.avg_latency_ms);

Search across different data types (text, images, audio, etc.) in a unified embedding space:

use ipfrs_semantic::{MultiModalIndex, MultiModalConfig, MultiModalEmbedding, Modality};
use ipfrs_core::Cid;

// Create multi-modal index
let mut config = MultiModalConfig::default();
config.project_to_unified = true;  // Enable unified embedding space
config.unified_dim = 512;

let mut index = MultiModalIndex::new(config);

// Register different modalities with their native dimensions
index.register_modality(Modality::Text, 768)?;  // BERT embeddings
index.register_modality(Modality::Image, 512)?;  // ResNet embeddings
index.register_modality(Modality::Audio, 768)?;  // Wav2Vec embeddings

// Add text content
let text_cid: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let text_embedding = MultiModalEmbedding::new(
    vec![0.1; 768],  // Text embedding from BERT
    Modality::Text
);
index.add(text_cid, text_embedding)?;

// Add image content
let image_cid: Cid = "bafybeigvgzoolh3cxsculpsjkz3hxfpg37pszqx3j7i5fwzgjmrmtv5wmi".parse()?;
let image_embedding = MultiModalEmbedding::new(
    vec![0.2; 512],  // Image embedding from ResNet
    Modality::Image
);
index.add(image_cid, image_embedding)?;

// Search within a specific modality
let text_query = MultiModalEmbedding::new(vec![0.15; 768], Modality::Text);
let text_results = index.search_modality(&text_query, 5, None)?;

// Cross-modal search: find similar content across all modalities
let cross_modal_results = index.search_cross_modal(&text_query, 10, None)?;
for (cid, score, modality) in cross_modal_results {
    println!("Found {:?} content: {} (score: {:.3})", modality, cid, score);
}

// Get statistics
let stats = index.stats();
for (modality, stat) in stats {
    println!("{:?}: {} embeddings, {} dims", modality, stat.num_embeddings, stat.dimension);
}

§Privacy-Preserving Search with Differential Privacy

Protect embedding privacy while maintaining search utility:

use ipfrs_semantic::{PrivacyMechanism, PrivacyBudget, PrivateEmbedding, TradeoffAnalyzer};

// Create a privacy mechanism (epsilon-differential privacy)
let epsilon = 1.0;  // Privacy budget
let sensitivity = 1.0;  // L2 sensitivity of embeddings
let mechanism = PrivacyMechanism::laplacian(epsilon, sensitivity)?;

// Create a private embedding
let original_embedding = vec![0.5; 768];
let private_emb = PrivateEmbedding::new(original_embedding, mechanism);

// Use the noisy embedding for public release
let public_embedding = private_emb.public_embedding();
let (epsilon, delta) = private_emb.privacy_params();
println!("Privacy: ε={}, δ={}", epsilon, delta);
println!("Expected utility loss: {:.3}", private_emb.utility_loss());

// Track privacy budget across multiple queries
let budget = PrivacyBudget::new(10.0, 0.001)?;  // Total budget

// Consume budget for each query
budget.consume(0.5, 0.0001)?;
budget.consume(0.5, 0.0001)?;

println!("Remaining budget: {:.2}", budget.remaining());

// Analyze privacy-utility trade-offs
let analyzer = TradeoffAnalyzer::new(sensitivity);
let tradeoffs = analyzer.analyze(768);
for point in tradeoffs {
    println!("ε={:.1}: utility loss={:.2}", point.epsilon, point.utility_loss);
}

// Find best epsilon for target utility
if let Some(best_epsilon) = analyzer.find_epsilon_for_utility(768, 15.0) {
    println!("Best ε for utility loss <15.0: {:.2}", best_epsilon);
}

§Dynamic Embedding Updates and Version Migration

Manage evolving embeddings with version control and online updates:

use ipfrs_semantic::{DynamicIndex, ModelVersion, OnlineUpdater, EmbeddingTransform};
use ipfrs_core::Cid;

// Create a dynamic index with version tracking
let v1 = ModelVersion::new(1, 0, 0);
let index = DynamicIndex::new(v1.clone(), 768)?;

// Add embeddings to version 1.0.0
let cid: Cid = "bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi".parse()?;
let embedding_v1 = vec![0.5; 768];
index.insert(&cid, &embedding_v1, None)?;

// Add a new model version with transformation
let v2 = ModelVersion::new(1, 1, 0);
let transform = EmbeddingTransform::identity(v1.clone());
index.add_version(v2.clone(), Some(transform))?;

// Set the new version as active
index.set_active_version(v2.clone())?;

// Add new embeddings to v2
let cid2: Cid = "bafybeigvgzoolh3cxsculpsjkz3hxfpg37pszqx3j7i5fwzgjmrmtv5wmi".parse()?;
let embedding_v2 = vec![0.6; 768];
index.insert(&cid2, &embedding_v2, Some(v2))?;

// Online fine-tuning with momentum
let updater = OnlineUpdater::new(0.01, 0.9);  // learning_rate, momentum

// Apply gradient updates
let gradient = vec![0.001; 768];
let updated_embedding = updater.update(&cid, &embedding_v2, &gradient);

// Track versions
let stats = index.version_stats();
for (version, stat) in stats {
    println!("Version {}: {} embeddings (active: {})",
        version, stat.num_embeddings, stat.is_active);
}

// Online updater statistics
let updater_stats = updater.stats();
println!("Online updater: lr={}, momentum={}, tracking {} embeddings",
    updater_stats.learning_rate, updater_stats.momentum, updater_stats.num_tracked);

§Performance

§SIMD Acceleration

The crate includes SIMD-optimized distance computations:

use ipfrs_semantic::{l2_distance, cosine_distance, dot_product};

let vec1 = vec![1.0, 2.0, 3.0, 4.0];
let vec2 = vec![0.5, 1.5, 2.5, 3.5];

// Uses ARM NEON or x86 SSE/AVX when available
let l2_dist = l2_distance(&vec1, &vec2);
let cos_dist = cosine_distance(&vec1, &vec2);
let dot_prod = dot_product(&vec1, &vec2);

§Performance Targets

Query latency: < 1ms for 1M vectors (cached)
Query latency: < 5ms for 1M vectors (uncached)
Index build time: < 10min for 1M vectors
Memory usage: < 2GB for 1M × 768-dim vectors
Recall@10: > 95% for k-NN search

§Architecture

§Core Components

VectorIndex - HNSW-based vector search index
SemanticRouter - High-level routing with caching
HybridIndex - Hybrid search with metadata filtering
DiskANNIndex - Disk-based indexing for massive scale

§Optimization Layers

Quantization - ProductQuantizer, OptimizedProductQuantizer, ScalarQuantizer
Caching - HotEmbeddingCache, AlignedVector
SIMD - l2_distance, cosine_distance, dot_product

§Logic Integration

LogicSolver - TensorLogic reasoning with embeddings
QueryExecutor - SPARQL-like query language
ProvenanceTracker - Audit trails and provenance

§Use Cases

§Semantic Content Discovery

Find similar content based on embeddings from models like:

Text: BERT, RoBERTa, Sentence Transformers
Images: CLIP, ResNet, ViT
Multi-modal: CLIP, ALIGN

§Recommendation Systems

Build recommendation engines that find similar:

Documents based on text embeddings
Images based on visual features
Users based on behavior embeddings

§Distributed AI Model Routing

Route AI inference requests to:

Find similar cached results
Locate relevant model weights
Discover related training data

§Configuration

§Index Tuning

use ipfrs_semantic::{VectorIndex, DistanceMetric, ParameterTuner, UseCase};

// Get recommended parameters for your use case
let rec = ParameterTuner::recommend(
    100_000,              // number of vectors
    768,                  // dimension
    UseCase::HighRecall   // optimize for recall
);

// Create index with recommended parameters
let index = VectorIndex::new(
    768,
    DistanceMetric::Cosine,
    rec.m,
    rec.ef_construction
)?;

println!("M: {}, efConstruction: {}", rec.m, rec.ef_construction);
println!("Estimated recall@10: {:.2}%", rec.estimated_recall * 100.0);

§Query Language

The crate provides a SPARQL-like query language for complex knowledge base queries:

use ipfrs_semantic::{Query, QueryPattern, QueryExecutor, FilterExpr, TermPattern};
use ipfrs_tensorlogic::{KnowledgeBase, Predicate, Term, Constant};

// Create knowledge base
let mut kb = KnowledgeBase::new();

// Add some facts
let fact1 = Predicate::new("person".to_string(), vec![
    Term::Const(Constant::String("alice".to_string())),
]);
kb.add_fact(fact1);

let fact2 = Predicate::new("age".to_string(), vec![
    Term::Const(Constant::String("alice".to_string())),
    Term::Const(Constant::Int(30)),
]);
kb.add_fact(fact2);

// Create query executor
let executor = QueryExecutor::new(kb);

// Build a query using the builder pattern
let query = Query::new()
    .select("name")
    .select("age_val")
    .where_pattern(QueryPattern::Pattern {
        name: Some("person".to_string()),
        args: vec![TermPattern::Variable("name".to_string())],
    })
    .where_pattern(QueryPattern::Pattern {
        name: Some("age".to_string()),
        args: vec![
            TermPattern::Variable("name".to_string()),
            TermPattern::Variable("age_val".to_string()),
        ],
    })
    .limit(10);

// Execute the query
let result = executor.execute(query)?;

println!("Found {} results", result.bindings.len());
for binding in result.bindings {
    println!("  Name: {:?}, Age: {:?}", binding.get("name"), binding.get("age_val"));
}

// Query statistics
println!("Patterns evaluated: {}", result.stats.patterns_evaluated);
println!("Execution time: {} ms", result.stats.execution_time_ms);

§Query Features

SELECT clause: Specify variables to return
WHERE patterns: Pattern matching with wildcards and variables
FILTER expressions: Filter results with boolean logic
LIMIT/OFFSET: Pagination support
Query optimization: Automatic join order optimization and filter pushdown

§Boolean Queries

use ipfrs_semantic::{BooleanQuery, Query, FilterExpr};

// AND query: match both conditions
let and_query = BooleanQuery::And(vec![
    Query::new().select("x"),
    Query::new().select("y"),
]);

// OR query: match either condition
let or_query = BooleanQuery::Or(vec![
    Query::new().select("x"),
    Query::new().select("y"),
]);

// NOT query: negate a query
let not_query = BooleanQuery::Not(Box::new(
    Query::new().select("x")
));

§Error Handling

All operations return Result<T, ipfrs_core::Error>:

use ipfrs_semantic::SemanticRouter;
use ipfrs_core::Error;

match SemanticRouter::with_defaults() {
    Ok(router) => println!("Router created successfully"),
    Err(Error::InvalidInput(msg)) => eprintln!("Invalid input: {}", msg),
    Err(e) => eprintln!("Error: {}", e),
}

§Advanced Features

§Vector Quality Analysis

Validate embeddings and detect anomalies:

use ipfrs_semantic::{analyze_quality, detect_anomaly, compute_batch_stats};

// Analyze a single vector
let embedding = vec![0.1, 0.2, 0.3, 0.4, 0.5];
let quality = analyze_quality(&embedding);

println!("Quality score: {:.2}", quality.quality_score);
println!("Is valid: {}", quality.is_valid);
println!("Is normalized: {}", quality.is_normalized);
println!("Sparsity: {:.1}%", quality.sparsity * 100.0);

// Detect anomalies
let report = detect_anomaly(
    &embedding,
    0.3,   // expected mean
    0.15,  // expected std dev
    1.0,   // expected L2 norm
    0.1,   // mean tolerance
    0.1,   // std dev tolerance
    0.2,   // norm tolerance
);

if report.is_anomaly {
    println!("Anomaly detected: {}", report.description);
    println!("Confidence: {:.1}%", report.confidence * 100.0);
}

// Analyze batch of vectors
let vectors = vec![
    vec![0.1, 0.2, 0.3],
    vec![0.4, 0.5, 0.6],
    vec![0.7, 0.8, 0.9],
];
let batch_stats = compute_batch_stats(&vectors);

println!("Average quality: {:.2}", batch_stats.avg_quality);
println!("Valid vectors: {}/{}", batch_stats.valid_count, batch_stats.count);

§Index Diagnostics and Health Monitoring

Monitor index health and performance:

use ipfrs_semantic::{VectorIndex, diagnose_index, HealthMonitor, SearchProfiler};
use std::time::Duration;

let mut index = VectorIndex::with_defaults(128)?;

// Run diagnostics
let report = diagnose_index(&index);

println!("Health status: {:?}", report.status);
println!("Index size: {} vectors", report.size);
println!("Memory usage: ~{:.2} MB", report.memory_usage as f64 / 1e6);

for issue in &report.issues {
    println!("Issue ({:?}): {}", issue.severity, issue.description);
    if let Some(fix) = &issue.suggested_fix {
        println!("  Suggested fix: {}", fix);
    }
}

for rec in &report.recommendations {
    println!("Recommendation: {}", rec);
}

// Set up periodic health monitoring
let mut monitor = HealthMonitor::new(Duration::from_secs(60));

if monitor.should_check() {
    let report = monitor.check(&index);
    println!("Health check: {:?}", report.status);
}

// Profile search performance
let mut profiler = SearchProfiler::new();

// Simulate queries
profiler.record_query(Duration::from_millis(5));
profiler.record_query(Duration::from_millis(3));
profiler.record_query(Duration::from_millis(4));

let stats = profiler.stats();
println!("Total queries: {}", stats.total_queries);
println!("Average latency: {:?}", stats.avg_latency);
println!("QPS: {:.2}", stats.qps);

§Index Optimization

Automatically tune index parameters:

use ipfrs_semantic::{analyze_optimization, OptimizationGoal, QueryOptimizer, MemoryOptimizer};
use std::time::Duration;

// Analyze and get optimization recommendations
let result = analyze_optimization(
    50_000,  // index size
    768,     // dimension
    16,      // current M
    200,     // current ef_construction
    OptimizationGoal::Balanced,
);

println!("Current quality score: {:.2}", result.current_score);
println!("Recommended M: {}", result.recommended_m);
println!("Recommended ef_construction: {}", result.recommended_ef_construction);
println!("Recommended ef_search: {}", result.recommended_ef_search);
println!("Estimated improvement: {:.1}%", result.estimated_improvement * 100.0);

for reason in &result.reasoning {
    println!("  - {}", reason);
}

// Adaptive query optimization
let mut query_optimizer = QueryOptimizer::new(
    50,                            // initial ef_search
    Duration::from_millis(10),     // target latency
);

// The optimizer adjusts ef_search based on observed latency
for _ in 0..20 {
    query_optimizer.record_query(Duration::from_millis(15));
}

println!("Optimized ef_search: {}", query_optimizer.get_ef_search());

// Memory budget optimization
let mut memory_optimizer = MemoryOptimizer::new(1024 * 1024 * 1024); // 1GB

let (m, ef_c, max_vectors) = memory_optimizer.recommend_config(768);
println!("For 1GB budget:");
println!("  Recommended M: {}", m);
println!("  Recommended ef_construction: {}", ef_c);
println!("  Max vectors: {}", max_vectors);

Re-exports§

pub use query_cache::CachedQueryResult;
pub use query_cache::QueryCacheConfig;
pub use query_cache::QueryCacheStats;
pub use query_cache::SemanticQueryCache;
pub use query_rewriter::QueryRewriter;
pub use query_rewriter::QueryRewriterConfig;
pub use query_rewriter::QueryRewriterStats;
pub use query_rewriter::RewriteResult;
pub use query_rewriter::RewriteRule;
pub use query_rewriter::RewriteRuleType;
pub use query_rewriter::RewrittenTerm;
pub use hnsw::BuildHealthStats;
pub use hnsw::DistanceMetric;
pub use hnsw::IncrementalBuildStats;
pub use hnsw::ParameterRecommendation;
pub use hnsw::ParameterTuner;
pub use hnsw::RebuildStats;
pub use hnsw::SearchResult;
pub use hnsw::UseCase;
pub use hnsw::VectorIndex;
pub use router::BatchStats;
pub use router::CacheStats;
pub use router::IndexBackend;
pub use router::QueryFilter;
pub use router::RouterConfig;
pub use router::RouterStats;
pub use router::SemanticRouter;
pub use hybrid::FilterStrategy;
pub use hybrid::HybridConfig;
pub use hybrid::HybridIndex;
pub use hybrid::HybridQuery;
pub use hybrid::HybridResponse;
pub use hybrid::HybridResult;
pub use hybrid::PruningStats;
pub use metadata::Metadata;
pub use metadata::MetadataFilter;
pub use metadata::MetadataStore;
pub use metadata::MetadataValue;
pub use metadata::TemporalOptions;
pub use quantization::dequantize_i8_to_f32;
pub use quantization::quantize_f32_to_i8;
pub use quantization::BinaryVectorStore;
pub use quantization::OptimizedProductQuantizer;
pub use quantization::PQCode;
pub use quantization::ProductQuantizer;
pub use quantization::QuantizationBenchmark;
pub use quantization::QuantizationBenchmarker;
pub use quantization::QuantizationComparison;
pub use quantization::QuantizedVector;
pub use quantization::QuantizedVectorStore;
pub use quantization::ScalarQuantizer;
pub use stats::IndexHealth;
pub use stats::IndexStats;
pub use stats::MemoryUsage;
pub use stats::PerfTimer;
pub use stats::StatsSnapshot;
pub use result_aggregator::AggregatedResult;
pub use result_aggregator::AggregationStrategy as AggAggregationStrategy;
pub use result_aggregator::AggregatorConfig;
pub use result_aggregator::AggregatorStats;
pub use result_aggregator::ResultAggregator;
pub use result_aggregator::SearchResult as AggSearchResult;
pub use diskann::SearchResult as DiskANNSearchResult;
pub use diskann::CompactionStats;
pub use diskann::DiskANNConfig;
pub use diskann::DiskANNIndex;
pub use diskann::DiskANNStats;
pub use solver::LogicSolver;
pub use solver::PredicateEmbedder;
pub use solver::ProofSearch;
pub use solver::ProofTreeNode;
pub use solver::SolverConfig;
pub use solver::SolverStats;
pub use kb_query::BooleanQuery;
pub use kb_query::FilterExpr;
pub use kb_query::Query;
pub use kb_query::QueryExecutor;
pub use kb_query::QueryPattern;
pub use kb_query::QueryResult;
pub use kb_query::QueryStats;
pub use kb_query::TermPattern;
pub use kb_query::TermType;
pub use provenance::AuditLogEntry;
pub use provenance::AuditOperation;
pub use provenance::EmbeddingMetadata;
pub use provenance::EmbeddingSource;
pub use provenance::EmbeddingVersion;
pub use provenance::FeatureAttribution;
pub use provenance::ProvenanceStats;
pub use provenance::ProvenanceTracker;
pub use provenance::SearchExplanation;
pub use provenance::VersionHistory;
pub use simd::cosine_distance;
pub use simd::dot_product;
pub use simd::l2_distance;
pub use cache::AdaptiveCacheStrategy;
pub use cache::AlignedVector;
pub use cache::CacheInvalidator;
pub use cache::HotCacheStats;
pub use cache::HotEmbeddingCache;
pub use cache::InvalidationPolicy;
pub use multimodal::Modality;
pub use multimodal::ModalityAlignment;
pub use multimodal::ModalityStats;
pub use multimodal::MultiModalConfig;
pub use multimodal::MultiModalEmbedding;
pub use multimodal::MultiModalIndex;
pub use privacy::NoiseDistribution;
pub use privacy::PrivacyBudget;
pub use privacy::PrivacyBudgetStats;
pub use privacy::PrivacyMechanism;
pub use privacy::PrivateEmbedding;
pub use privacy::QueryRecord;
pub use privacy::TradeoffAnalyzer;
pub use privacy::TradeoffPoint;
pub use dynamic::DynamicIndex;
pub use dynamic::EmbeddingTransform;
pub use dynamic::ModelVersion;
pub use dynamic::OnlineUpdater;
pub use dynamic::OnlineUpdaterStats;
pub use dynamic::VersionStats;
pub use dht::DHTQuery;
pub use dht::DHTQueryResponse;
pub use dht::ReplicationStrategy;
pub use dht::SemanticDHTConfig;
pub use dht::SemanticDHTStats;
pub use dht::SemanticPeer;
pub use dht::SemanticRoutingTable;
pub use dht_node::SemanticDHTNode;
pub use dht_node::SyncStats;
pub use federated::AggregationStrategy;
pub use federated::FederatedConfig;
pub use federated::FederatedQueryExecutor;
pub use federated::FederatedQueryStats;
pub use federated::FederatedSearchResult;
pub use federated::LocalIndexAdapter;
pub use federated::QueryableIndex;
pub use reranking::ReRanker;
pub use reranking::ReRankingConfig;
pub use reranking::ReRankingStrategy;
pub use reranking::ScoreComponent;
pub use reranking::ScoredResult;
pub use analytics::AnalyticsSummary;
pub use analytics::AnalyticsTracker;
pub use analytics::DetectedPattern;
pub use analytics::QueryMetrics;
pub use analytics::QueryTimer;
pub use auto_scaling::ActionType;
pub use auto_scaling::AdvisorConfig;
pub use auto_scaling::AutoScalingAdvisor;
pub use auto_scaling::ScalingAction;
pub use auto_scaling::ScalingRecommendations;
pub use auto_scaling::TrendReport;
pub use auto_scaling::WorkloadMetrics;
pub use learned::LearnedIndex;
pub use learned::LearnedIndexStats;
pub use learned::ModelType;
pub use learned::RMIConfig;
pub use adapters::BackendConfig;
pub use adapters::BackendMigration;
pub use adapters::BackendRegistry;
pub use adapters::BackendSearchResult;
pub use adapters::BackendStats;
pub use adapters::IpfrsBackend;
pub use adapters::MigrationStats;
pub use adapters::VectorBackend;
pub use vector_quality::analyze_quality;
pub use vector_quality::compute_batch_stats;
pub use vector_quality::compute_diversity;
pub use vector_quality::compute_stats;
pub use vector_quality::cosine_similarity;
pub use vector_quality::detect_anomaly;
pub use vector_quality::find_outliers;
pub use vector_quality::AnomalyReport;
pub use vector_quality::AnomalyType;
pub use vector_quality::VectorQuality;
pub use vector_quality::VectorStats;
pub use diagnostics::diagnose_index;
pub use diagnostics::DiagnosticIssue;
pub use diagnostics::DiagnosticReport;
pub use diagnostics::HealthMonitor;
pub use diagnostics::HealthStatus;
pub use diagnostics::IssueCategory;
pub use diagnostics::IssueSeverity;
pub use diagnostics::PerformanceMetrics;
pub use diagnostics::ProfilerStats;
pub use diagnostics::SearchProfiler;
pub use optimization::analyze_optimization;
pub use optimization::MemoryOptimizer;
pub use optimization::OptimizationGoal;
pub use optimization::OptimizationResult;
pub use optimization::QueryOptimizer;
pub use utils::average_embedding;
pub use utils::create_hybrid_index_from_map;
pub use utils::health_check;
pub use utils::index_with_quality_check;
pub use utils::normalize_vector;
pub use utils::normalize_vectors;
pub use utils::validate_embeddings;
pub use utils::BatchEmbeddingStats;
pub use utils::BatchIndexResult;
pub use utils::HealthCheckResult;
pub use prod_tests::EnduranceTest;
pub use prod_tests::EnduranceTestConfig;
pub use prod_tests::EnduranceTestResults;
pub use prod_tests::StressTest;
pub use prod_tests::StressTestConfig;
pub use prod_tests::StressTestResults;
pub use regression::MetricSummary;
pub use regression::RegressionConfig;
pub use regression::RegressionDetector;
pub use regression::RegressionIssue;
pub use regression::RegressionReport;
pub use benchmark_comparison::BenchmarkResult;
pub use benchmark_comparison::BenchmarkSuite;
pub use benchmark_comparison::ComparisonReport;
pub use benchmark_comparison::IndexConfig;
pub use benchmark_comparison::ParameterSweep;
pub use migration::BatchMigration;
pub use migration::ConfigMigration;
pub use migration::DimensionMigration;
pub use migration::IndexMigration;
pub use migration::MetricMigration;
pub use migration::MigrationConfig;
pub use migration::MigrationProgress;
pub use shard_balancer::DhtShardRouter;
pub use shard_balancer::ShardAssignment;
pub use shard_balancer::ShardBalancer;
pub use shard_balancer::ShardConfig;
pub use shard_coordinator::ConsistentHashRing;
pub use shard_coordinator::ShardCoordinator;
pub use shard_coordinator::ShardError;
pub use shard_coordinator::ShardId;
pub use shard_coordinator::ShardStats;
pub use shard_coordinator::ShardStatsSnapshot;
pub use shard_coordinator::VectorShard;
pub use persistence::IncrementalSnapshot;
pub use persistence::IncrementalTracker;
pub use persistence::IndexEntry;
pub use persistence::IndexPersistence;
pub use persistence::IndexSnapshot;
pub use partial_sync::DirtyRegionTracker;
pub use partial_sync::EmbeddingDelta;
pub use partial_sync::EmbeddingRegion;
pub use partial_sync::PartialSyncManager;
pub use index_compactor::CompactionPlan;
pub use index_compactor::CompactionPolicy;
pub use index_compactor::CompactionPriority;
pub use index_compactor::CompactionReason;
pub use index_compactor::CompactorStats;
pub use index_compactor::CompactorStatsSnapshot;
pub use index_compactor::IndexCompactor;
pub use index_compactor::IndexFragmentStats;
pub use federated_search::CachedSearchResult;
pub use federated_search::FederatedSearchCoordinator;
pub use federated_search::FederatedSearchStats;
pub use federated_search::FederatedSearchStatsSnapshot;
pub use federated_search::QueryKey;
pub use federated_search::SearchPeer;
pub use federated_search::SearchResult as PeerSearchResult;
pub use embedding_normalizer::EmbeddingNormalizer;
pub use embedding_normalizer::NormStats;
pub use embedding_normalizer::NormalizationType;
pub use embedding_normalizer::NormalizerConfig;
pub use embedding_normalizer::NormalizerStats;
pub use embedding_pipeline::fnv1a_hash_f32;
pub use embedding_pipeline::EmbeddingInput;
pub use embedding_pipeline::EmbeddingPipeline;
pub use embedding_pipeline::EmbeddingPipelineConfig;
pub use embedding_pipeline::NormalizationStrategy;
pub use embedding_pipeline::PipelineError;
pub use embedding_pipeline::PipelineResult;
pub use embedding_pipeline::PipelineStage;
pub use embedding_pipeline::PipelineStats;
pub use embedding_pipeline::PipelineStatsSnapshot;
pub use embedding_pipeline::SemanticEmbeddingPipeline;
pub use embedding_pipeline::SemanticPipelineStats;
pub use quantization_error::QErrorError;
pub use quantization_error::QuantizationError;
pub use quantization_error::QuantizationErrorTracker;
pub use search_quality::EvalError;
pub use search_quality::EvaluatorStats;
pub use search_quality::EvaluatorStatsSnapshot;
pub use search_quality::GroundTruth;
pub use search_quality::QualityMetrics;
pub use search_quality::SearchQualityEvaluator;
pub use search_quality::SearchResultSet;
pub use search_explainer::ExplainerConfig;
pub use search_explainer::ExplainerStats;
pub use search_explainer::ExplanationNode;
pub use search_explainer::QueryContext;
pub use search_explainer::ScoreContribution;
pub use search_explainer::SearchExplainer;
pub use search_ranker::RankSignal;
pub use search_ranker::RankedResult;
pub use search_ranker::RankerConfig;
pub use search_ranker::RankerStats;
pub use search_ranker::RankingSignal;
pub use search_ranker::RawCandidate;
pub use search_ranker::SearchCandidate;
pub use search_ranker::SemanticRankedResult;
pub use search_ranker::SemanticRankerConfig;
pub use search_ranker::SemanticSearchRanker;
pub use search_ranker::VectorSearchRanker;
pub use anomaly_detector::AnomalyConfig;
pub use anomaly_detector::AnomalyDetectorStats;
pub use anomaly_detector::AnomalyMethod;
pub use anomaly_detector::AnomalyResult;
pub use anomaly_detector::DetectorConfig;
pub use anomaly_detector::DetectorStats;
pub use anomaly_detector::SemanticAnomalyDetector;
pub use anomaly_detector::SemanticAnomalyMethod;
pub use anomaly_detector::SemanticAnomalyResult;
pub use anomaly_detector::VectorAnomalyDetector;
pub use drift_monitor::BaselineStats;
pub use drift_monitor::DriftMonitorConfig;
pub use drift_monitor::DriftMonitorStats;
pub use drift_monitor::DriftSignal;
pub use drift_monitor::EmbeddingDriftMonitor;
pub use cluster_analyzer::AnalyzerConfig;
pub use cluster_analyzer::Cluster;
pub use cluster_analyzer::ClusterPoint;
pub use cluster_analyzer::ClusterStats;
pub use cluster_analyzer::SemanticClusterAnalyzer;
pub use multimodal_search::CoordinatorStats;
pub use multimodal_search::FusedResult;
pub use multimodal_search::FusionStrategy;
pub use multimodal_search::Modality as SearchModality;
pub use multimodal_search::ModalityResult;
pub use multimodal_search::MultiModalSearchCoordinator;
pub use multimodal_search::SearchQuery;
pub use vector_quantizer::Codebook;
pub use vector_quantizer::QuantizationConfig;
pub use vector_quantizer::QuantizationStats;
pub use vector_quantizer::QuantizerCode;
pub use vector_quantizer::VectorQuantizer;
pub use vector_quantizer::VqError;
pub use personalizer::InteractionRecord;
pub use personalizer::InteractionType;
pub use personalizer::PersonalizationBias;
pub use personalizer::SemanticPersonalizer;
pub use personalizer::UserProfile;
pub use tag_extractor::ExtractionConfig;
pub use tag_extractor::ExtractorStats;
pub use tag_extractor::SemanticTagExtractor;
pub use tag_extractor::Tag;
pub use tag_extractor::TagAssignment;
pub use graph_linker::EdgeType;
pub use graph_linker::GraphLinkerStats;
pub use graph_linker::GraphNode;
pub use graph_linker::LinkerConfig;
pub use graph_linker::SemanticEdge;
pub use graph_linker::SemanticGraphLinker;
pub use content_router::RouteScore;
pub use content_router::RouterConfig as ContentRouterConfig;
pub use content_router::RouterStats as ContentRouterStats;
pub use content_router::RoutingDecision;
pub use content_router::SemanticContentRouter;
pub use content_router::TopicEmbedding;
pub use hotspot_detector::cosine_sim as hotspot_cosine_sim;
pub use hotspot_detector::HotspotConfig;
pub use hotspot_detector::HotspotRegion;
pub use hotspot_detector::HotspotStats;
pub use hotspot_detector::QueryHit;
pub use hotspot_detector::SemanticHotspotDetector;
pub use query_expander::ExpandedQuery;
pub use query_expander::ExpanderStats;
pub use query_expander::ExpansionStrategy;
pub use query_expander::SemanticQueryExpander;
pub use query_expander::TermEntry;
pub use query_expander::TermRelation;
pub use query_expander::VectorExpandedQuery;
pub use query_expander::VectorExpanderConfig;
pub use query_expander::VectorExpanderStats;
pub use query_expander::VectorQueryExpander;
pub use query_expander::VectorQueryExpansion;
pub use near_dup_detector::cosine_sim as near_dup_cosine_sim;
pub use near_dup_detector::DupCandidate;
pub use near_dup_detector::DupDetectorStats;
pub use near_dup_detector::DuplicatePair;
pub use near_dup_detector::LshBand;
pub use near_dup_detector::MinHashConfig;
pub use near_dup_detector::MinHashNearDupDetector;
pub use near_dup_detector::MinHashSignature;
pub use near_dup_detector::NearDupConfig;
pub use near_dup_detector::NearDupDetectorStats;
pub use near_dup_detector::SemanticNearDupDetector;
pub use concept_hierarchy::ConceptEdge;
pub use concept_hierarchy::ConceptNode;
pub use concept_hierarchy::ConceptRelation;
pub use concept_hierarchy::HierarchyStats;
pub use concept_hierarchy::SemanticConceptHierarchy;
pub use concept_extractor::Concept;
pub use concept_extractor::ConceptExtractor;
pub use concept_extractor::ConceptType;
pub use concept_extractor::ExtractorConfig as ConceptExtractorConfig;
pub use concept_extractor::ExtractorStats as ConceptExtractorStats;
pub use topic_modeler::cosine_sim as topic_cosine_sim;
pub use topic_modeler::DocumentTopics;
pub use topic_modeler::LdaTopic;
pub use topic_modeler::ModelDocument;
pub use topic_modeler::ModellerConfig;
pub use topic_modeler::SemanticTopicModeller;
pub use topic_modeler::TopicAssignment;
pub use topic_modeler::TopicModel;
pub use topic_modeler::TopicModelConfig;
pub use topic_modeler::TopicModelError;
pub use topic_modeler::TopicModelResult;
pub use topic_modeler::TopicModeler;
pub use topic_modeler::TopicModelerStats;
pub use topic_modeler::TopicModellerStats;
pub use topic_modeler::TopicWord;
pub use query_pipeline::PipelineConfig;
pub use query_pipeline::PipelineRun;
pub use query_pipeline::PipelineStageKind;
pub use query_pipeline::PipelineStats as QueryPipelineStats;
pub use query_pipeline::QueryResult as PipelineQueryResult;
pub use query_pipeline::SemanticQueryPipeline;
pub use query_pipeline::StageMetrics;
pub use knowledge_graph::cosine_sim as knowledge_graph_cosine_sim;
pub use knowledge_graph::EntityKind;
pub use knowledge_graph::GraphEdge;
pub use knowledge_graph::GraphEntity;
pub use knowledge_graph::GraphQuery;
pub use knowledge_graph::KnowledgeGraphStats;
pub use knowledge_graph::SemanticKnowledgeGraph;
pub use entity_linker::cosine_sim;
pub use entity_linker::KbEntity;
pub use entity_linker::LinkedMention;
pub use entity_linker::LinkerConfig as EntityLinkerConfig;
pub use entity_linker::LinkerStats;
pub use entity_linker::MentionKind;
pub use entity_linker::SemanticEntityLinker;
pub use entity_resolution::CanonicalEntity;
pub use entity_resolution::EntityMention;
pub use entity_resolution::EntityResolver;
pub use entity_resolution::EntityType;
pub use entity_resolution::ResolutionMethod;
pub use entity_resolution::ResolutionResult;
pub use entity_resolution::ResolverConfig;
pub use entity_resolution::ResolverStats;
pub use relevance_feedback::cosine_similarity as relevance_cosine_similarity;
pub use relevance_feedback::FeedbackItem;
pub use relevance_feedback::FeedbackLabel;
pub use relevance_feedback::FeedbackSession;
pub use relevance_feedback::FeedbackStats;
pub use relevance_feedback::RocchioConfig;
pub use relevance_feedback::SemanticRelevanceFeedback;
pub use diversifier::cosine_similarity as diversifier_cosine_similarity;
pub use diversifier::DiversificationCandidate;
pub use diversifier::DiversifiedResult;
pub use diversifier::DiversifierConfig;
pub use diversifier::DiversifierStats;
pub use diversifier::SemanticDiversifier;
pub use synonym_expander::ExpandedTerm;
pub use synonym_expander::ExpanderConfig as SynonymExpanderConfig;
pub use synonym_expander::SemanticSynonymExpander;
pub use synonym_expander::SynonymEdge;
pub use synonym_expander::SynonymExpanderStats;
pub use synonym_expander::SynonymRelation;
pub use cluster_manager::euclidean_distance as cluster_euclidean_distance;
pub use cluster_manager::vec_mean as cluster_vec_mean;
pub use cluster_manager::BatchCluster;
pub use cluster_manager::BatchClusterConfig;
pub use cluster_manager::BatchClusterManagerStats;
pub use cluster_manager::BatchSemanticClusterManager;
pub use cluster_manager::ClusterAssignment;
pub use cluster_manager::ClusterManagerConfig;
pub use cluster_manager::ClusterManagerStats;
pub use cluster_manager::SemanticCluster;
pub use cluster_manager::SemanticClusterManager;
pub use document_summarizer::cosine_similarity as ds_cosine_similarity;
pub use document_summarizer::split_sentences as ds_split_sentences;
pub use document_summarizer::tf_idf as ds_tf_idf;
pub use document_summarizer::tokenize as ds_tokenize;
pub use document_summarizer::xorshift64 as ds_xorshift64;
pub use document_summarizer::DocumentChunk;
pub use document_summarizer::DocumentSummarizer;
pub use document_summarizer::SentenceScore as DsSentenceScore;
pub use document_summarizer::SummarizerConfig as DsSummarizerConfig;
pub use document_summarizer::SummarizerError as DsSummarizerError;
pub use document_summarizer::SummarizerStats;
pub use document_summarizer::SummaryResult;
pub use document_summarizer::SummaryStyle;
pub use intent_classifier::ClassifierConfig as IntentClassifierConfig;
pub use intent_classifier::ClassifierStats as IntentClassifierStats;
pub use intent_classifier::IntentClassification;
pub use intent_classifier::IntentKind;
pub use intent_classifier::IntentPrototype;
pub use intent_classifier::SemanticIntentClassifier;
pub use context_window::ContextEntry;
pub use context_window::ContextStats;
pub use context_window::SemanticContextWindow;
pub use context_window::WindowConfig;
pub use multilingual_index::CrossLingualQuery;
pub use multilingual_index::Language;
pub use multilingual_index::MultilingualDoc;
pub use multilingual_index::MultilingualIndexStats;
pub use multilingual_index::MultilingualResult;
pub use multilingual_index::SemanticMultilingualIndex;
pub use attribution_tracker::AttributionRecord;
pub use attribution_tracker::AttributionSource;
pub use attribution_tracker::AttributionStats;
pub use attribution_tracker::SemanticAttributionTracker;
pub use embedding_pool::EmbeddingBuffer;
pub use embedding_pool::PoolConfig;
pub use embedding_pool::PoolStats;
pub use embedding_pool::SemanticEmbeddingPool;
pub use document_graph::cosine_sim as doc_graph_cosine_sim;
pub use document_graph::DocGraphEdge;
pub use document_graph::DocGraphNode;
pub use document_graph::DocumentGraphStats;
pub use document_graph::EdgeKind as DocEdgeKind;
pub use document_graph::SemanticDocumentGraph;
pub use document_ranker::DocumentIndex;
pub use document_ranker::DocumentRanker;
pub use document_ranker::RankedDocument;
pub use document_ranker::RankerStats as DrRankerStats;
pub use document_ranker::RankingConfig;
pub use vocab_index::SemanticVocabIndex;
pub use vocab_index::VocabConfig;
pub use vocab_index::VocabEntry;
pub use vocab_index::VocabIndexStats;
pub use summary_extractor::ExtractionResult;
pub use summary_extractor::ExtractorScoredSentence;
pub use summary_extractor::ExtractorSummaryConfig;
pub use summary_extractor::SemanticSummaryExtractor;
pub use summary_extractor::SummaryExtractorStats;
pub use term_weighter::DocumentProfile;
pub use term_weighter::SemanticTermWeighter;
pub use term_weighter::TermWeight;
pub use term_weighter::TermWeighterStats;
pub use term_weighter::WeighterConfig;
pub use term_weighter::WeightingScheme;
pub use dimension_reducer::ReducerConfig;
pub use dimension_reducer::ReducerStats;
pub use dimension_reducer::ReductionMethod;
pub use dimension_reducer::ReductionResult;
pub use dimension_reducer::SemanticDimensionReducer;
pub use tokenizer::SemanticTokenizer;
pub use tokenizer::Token as SemanticToken;
pub use tokenizer::TokenizerConfig;
pub use tokenizer::TokenizerMode;
pub use tokenizer::TokenizerStats;
pub use feedback_loop::FeedbackEntry;
pub use feedback_loop::FeedbackLoopStats;
pub use feedback_loop::FeedbackType;
pub use feedback_loop::QueryFeedbackSummary;
pub use embedding_cache::CachedEmbedding;
pub use embedding_cache::EmbeddingCacheConfig;
pub use embedding_cache::EmbeddingCacheStats;
pub use embedding_cache::SemanticEmbeddingCache;
pub use cross_encoder::CandidateDoc;
pub use cross_encoder::CrossEncoder;
pub use cross_encoder::CrossEncoderConfig;
pub use cross_encoder::CrossEncoderStats;
pub use cross_encoder::RerankedDoc;
pub use cross_encoder::ScoringModel;
pub use semantic_clusterer::ClusterAlgorithm;
pub use semantic_clusterer::ClusterError;
pub use semantic_clusterer::Linkage;
pub use semantic_clusterer::ScCluster;
pub use semantic_clusterer::ScClusterPoint;
pub use semantic_clusterer::ScClustererStats;
pub use semantic_clusterer::ScClusteringResult;
pub use semantic_clusterer::SemanticClusterer;
pub use sentiment_analyzer::AspectSentiment;
pub use sentiment_analyzer::LexiconEntry;
pub use sentiment_analyzer::SentimentAnalyzer;
pub use sentiment_analyzer::SentimentAnalyzerStats;
pub use sentiment_analyzer::SentimentConfig;
pub use sentiment_analyzer::SentimentPolarity;
pub use sentiment_analyzer::SentimentResult;
pub use sentiment_analyzer::SentimentScore;
pub use text_summarizer::SentenceScore;
pub use text_summarizer::SummarizationMethod;
pub use text_summarizer::SummarizerConfig;
pub use text_summarizer::SummarizerError;
pub use text_summarizer::TextSummarizer;
pub use text_summarizer::TextSummarizerStats as TsSummarizerStats;
pub use text_summarizer::TextSummaryResult as TsSummaryResult;
pub use search_pipeline::FusionMethod;
pub use search_pipeline::SearchDocument;
pub use search_pipeline::SearchHit;
pub use search_pipeline::SearchPipelineResult;
pub use search_pipeline::SemanticSearchPipeline;
pub use search_pipeline::SpPipelineConfig;
pub use search_pipeline::SpPipelineStats;
pub use search_pipeline::SpSearchQuery;
pub use knowledge_base_builder::KbBuilderEntity;
pub use knowledge_base_builder::KbConceptNode;
pub use knowledge_base_builder::KbDocument;
pub use knowledge_base_builder::KbError;
pub use knowledge_base_builder::KbRelation as KbBuilderRelation;
pub use knowledge_base_builder::KbStats as KbBuilderStats;
pub use knowledge_base_builder::KbTriple;
pub use knowledge_base_builder::KnowledgeBaseBuilder;
pub use multilingual_normalizer::LanguageHint;
pub use multilingual_normalizer::MultilingualNormalizer;
pub use multilingual_normalizer::NormalizationOptions;
pub use multilingual_normalizer::NormalizedText;
pub use multilingual_normalizer::NormalizerStats as MlnNormalizerStats;
pub use multilingual_normalizer::Script;
pub use multilingual_normalizer::TokenizationStrategy;
pub use corpus_indexer::CorpusIndexer;
pub use corpus_indexer::FacetFilter;
pub use corpus_indexer::IndexError;
pub use corpus_indexer::IndexQuery;
pub use corpus_indexer::IndexStats as CiIndexStats;
pub use corpus_indexer::IndexedDocument;
pub use corpus_indexer::InvertedIndex;
pub use corpus_indexer::PostingEntry;
pub use corpus_indexer::SearchResult as CiSearchResult;
pub use embedding_pipeline_manager::l2_normalize as epm_l2_normalize;
pub use embedding_pipeline_manager::mean_pool as epm_mean_pool;
pub use embedding_pipeline_manager::random_projection as epm_random_projection;
pub use embedding_pipeline_manager::EmbeddingBatch;
pub use embedding_pipeline_manager::EmbeddingPipelineManager;
pub use embedding_pipeline_manager::EpmPipelineConfig;
pub use embedding_pipeline_manager::EpmPipelineError;
pub use embedding_pipeline_manager::EpmPipelineStage;
pub use embedding_pipeline_manager::EpmPipelineStats;
pub use embedding_pipeline_manager::EpmReductionMethod;
pub use embedding_pipeline_manager::StageTiming;
pub use semantic_versioning::BumpType;
pub use semantic_versioning::ChangeRecord;
pub use semantic_versioning::ChangeType;
pub use semantic_versioning::CompatibilityLevel;
pub use semantic_versioning::CompatibilityMatrix;
pub use semantic_versioning::SemVer;
pub use semantic_versioning::SemVerError;
pub use semantic_versioning::SemanticVersioningEngine;
pub use semantic_versioning::VersionedArtifact;
pub use semantic_versioning::VersioningStats;
pub use similarity_graph::GraphConfig;
pub use similarity_graph::SemanticSimilarityGraph;
pub use similarity_graph::SgCommunity;
pub use similarity_graph::SgEdge;
pub use similarity_graph::SgNode;
pub use similarity_graph::SgStats;
pub use embedding_aggregator::AggregationInput;
pub use embedding_aggregator::AggregationMethod;
pub use embedding_aggregator::AggregationResult as EaAggregationResult;
pub use embedding_aggregator::AggregatorError;
pub use embedding_aggregator::EaAggregatorStats;
pub use embedding_aggregator::EmbeddingAggregator;
pub use embedding_aggregator::EmbeddingAggregatorConfig;
pub use semantic_reranker::RerankCandidate;
pub use semantic_reranker::RerankConfig;
pub use semantic_reranker::RerankFeature;
pub use semantic_reranker::RerankQuery;
pub use semantic_reranker::RerankResult;
pub use semantic_reranker::RerankStats;
pub use semantic_reranker::SemanticReranker;
pub use document_chunker::ChunkStats;
pub use document_chunker::ChunkStrategy;
pub use document_chunker::DocumentChunker;
pub use document_chunker::DocumentChunkerConfig;
pub use document_chunker::TextChunk;
pub use multimodal_index::CrossModalQuery;
pub use multimodal_index::CrossModalResult;
pub use multimodal_index::FusionStrategy as MmiFusionStrategy;
pub use multimodal_index::MmiError;
pub use multimodal_index::MmiStats;
pub use multimodal_index::Modality as MmiModality;
pub use multimodal_index::ModalityEmbedding;
pub use multimodal_index::MultiModalDocument;
pub use multimodal_index::MultiModalIndex as MmiMultiModalIndex;
pub use multimodal_index::MultiModalIndexConfig;
pub use semantic_cache::CacheConfig;
pub use semantic_cache::CacheEntry;
pub use semantic_cache::CacheEvictionPolicy;
pub use semantic_cache::CacheKey;
pub use semantic_cache::CacheLookupResult;
pub use semantic_cache::ScCacheStats;
pub use semantic_cache::SemanticCacheLayer;
pub use query_expansion::ExpansionConfig;
pub use query_expansion::ExpansionSource;
pub use query_expansion::ExpansionStats;
pub use query_expansion::QeExpandedQuery;
pub use query_expansion::QeExpansionTerm;
pub use query_expansion::QueryExpansionEngine;
pub use query_expansion::SynonymEntry;
pub use embedding_finetuner::cosine_similarity as ef_cosine_similarity;
pub use embedding_finetuner::l2_distance_sq as ef_l2_distance_sq;
pub use embedding_finetuner::EmbeddingFinetuner;
pub use embedding_finetuner::FinetunerConfig;
pub use embedding_finetuner::FinetunerError;
pub use embedding_finetuner::ProjectionLayer;
pub use embedding_finetuner::TrainingPair;
pub use embedding_finetuner::TrainingStats;
pub use embedding_finetuner::TripletLoss;
pub use dense_retriever::BM25Index;
pub use dense_retriever::DenseRetriever;
pub use dense_retriever::Document as RetrieverDocument;
pub use dense_retriever::RetrievalQuery;
pub use dense_retriever::RetrievalResult;
pub use dense_retriever::RetrieverConfig;
pub use dense_retriever::RetrieverError;
pub use dense_retriever::RetrieverStats;
pub use concept_graph::cosine_similarity as cg_cosine_similarity;
pub use concept_graph::tokenize as cg_tokenize;
pub use concept_graph::CgConcept;
pub use concept_graph::CgConceptEdge;
pub use concept_graph::CgConceptRelation;
pub use concept_graph::CgGraphConfig;
pub use concept_graph::ConceptGraphBuilder;
pub use concept_graph::ConceptGraphStats;
pub use concept_graph::ConceptId;
pub use semantic_router_v2::FallbackStrategy;
pub use semantic_router_v2::RouteDefinition;
pub use semantic_router_v2::RouteHandlerId;
pub use semantic_router_v2::RouteStats as Srv2RouteStats;
pub use semantic_router_v2::RouterV2Config;
pub use semantic_router_v2::RouterV2Error;
pub use semantic_router_v2::RouterV2Stats;
pub use semantic_router_v2::SemanticRouterV2;
pub use semantic_router_v2::V2RoutingDecision;
pub use text_similarity_scorer::ScorerConfig;
pub use text_similarity_scorer::SimilarityMetric;
pub use text_similarity_scorer::SimilarityScore;
pub use text_similarity_scorer::TextPair;
pub use text_similarity_scorer::TextSimilarityResult;
pub use text_similarity_scorer::TextSimilarityScorer;
pub use embedding_cluster_analyzer::ClusterDescriptor;
pub use embedding_cluster_analyzer::ClusterId;
pub use embedding_cluster_analyzer::ClusterQuality;
pub use embedding_cluster_analyzer::EcaAnalyzerConfig;
pub use embedding_cluster_analyzer::EcaAnalyzerStats;
pub use embedding_cluster_analyzer::EcaClusterPoint;
pub use embedding_cluster_analyzer::EmbeddingClusterAnalyzer;
pub use embedding_cluster_analyzer::OutlierReason;
pub use embedding_cluster_analyzer::OutlierScore;
pub use semantic_federated_search::FederatedQuery;
pub use semantic_federated_search::FederatedResult;
pub use semantic_federated_search::FederatedStats;
pub use semantic_federated_search::MergeStrategy;
pub use semantic_federated_search::NodeResponse;
pub use semantic_federated_search::RemoteNode;
pub use semantic_federated_search::RemoteResult;
pub use semantic_federated_search::SemanticFederatedSearch;
pub use topic_model_extractor::ExtractorConfig;
pub use topic_model_extractor::ExtractorDocumentTopics;
pub use topic_model_extractor::ExtractorError;
pub use topic_model_extractor::ExtractorTopic;
pub use topic_model_extractor::ExtractorTopicWord;
pub use topic_model_extractor::ModelStats as TopicModelStats;
pub use topic_model_extractor::TmeDocumentTopics;
pub use topic_model_extractor::TmeError;
pub use topic_model_extractor::TmeTopic;
pub use topic_model_extractor::TmeTopicWord;
pub use topic_model_extractor::TopicModelExtractor;
pub use cross_modal_reranker::CmrFusionStrategy;
pub use cross_modal_reranker::CrossModalReranker;
pub use cross_modal_reranker::ModalityScore;
pub use cross_modal_reranker::RerankerCandidate;
pub use cross_modal_reranker::RerankerConfig;
pub use cross_modal_reranker::RerankerError;
pub use cross_modal_reranker::RerankerStats;
pub use cross_modal_reranker::TextFeatures;
pub use cross_modal_reranker::VectorFeatures;
pub use semantic_graph_builder::BuilderConfig;
pub use semantic_graph_builder::BuilderError;
pub use semantic_graph_builder::EdgeRelation;
pub use semantic_graph_builder::GraphStats;
pub use semantic_graph_builder::NodeType;
pub use semantic_graph_builder::SemanticGraphBuilder;
pub use semantic_graph_builder::SgbGraphEdge;
pub use semantic_graph_builder::SgbGraphNode;
pub use semantic_graph_builder::SgbGraphQuery;
pub use embedding_drift_detector::DetectionMethod;
pub use embedding_drift_detector::DetectorConfig as EddDetectorConfig;
pub use embedding_drift_detector::DetectorError;
pub use embedding_drift_detector::DriftSignal as EddDriftSignal;
pub use embedding_drift_detector::DriftSnapshot;
pub use embedding_drift_detector::DriftStats as EddDriftStats;
pub use embedding_drift_detector::DriftType;
pub use embedding_drift_detector::EmbeddingDriftDetector as EddEmbeddingDriftDetector;
pub use multi_modal_indexer::cosine_similarity as mmi_cosine_similarity;
pub use multi_modal_indexer::IndexedDocument as MmiIndexedDocument;
pub use multi_modal_indexer::MmiIndexConfig;
pub use multi_modal_indexer::MmiIndexConfigAlias;
pub use multi_modal_indexer::MmiIndexError;
pub use multi_modal_indexer::MmiIndexErrorAlias;
pub use multi_modal_indexer::MmiIndexStats;
pub use multi_modal_indexer::MmiIndexStatsAlias;
pub use multi_modal_indexer::MmiSearchQuery;
pub use multi_modal_indexer::MmiSearchQueryAlias;
pub use multi_modal_indexer::MmiSearchResult;
pub use multi_modal_indexer::MmiSearchResultAlias;
pub use multi_modal_indexer::ModalityData;
pub use multi_modal_indexer::MultiModalIndexer;
pub use contextual_embedding_search::cosine_similarity as ces_cosine_similarity;
pub use contextual_embedding_search::weighted_sum as ces_weighted_sum;
pub use contextual_embedding_search::CesExpandedQuery;
pub use contextual_embedding_search::ContextualEmbeddingSearch;
pub use contextual_embedding_search::ContextualResult;
pub use contextual_embedding_search::DiversityStrategy;
pub use contextual_embedding_search::SearchConfig as CesSearchConfig;
pub use contextual_embedding_search::SearchContext;
pub use contextual_embedding_search::SearchDoc;
pub use contextual_embedding_search::SearchError as CesSearchError;
pub use contextual_embedding_search::SearchStats as CesSearchStats;
pub use semantic_cache_manager::ScmCacheConfig;
pub use semantic_cache_manager::ScmCacheEntry;
pub use semantic_cache_manager::ScmCacheError;
pub use semantic_cache_manager::ScmCacheHit;
pub use semantic_cache_manager::ScmCacheKey;
pub use semantic_cache_manager::ScmCacheStats;
pub use semantic_cache_manager::ScmEntryAlias;
pub use semantic_cache_manager::ScmErrorAlias;
pub use semantic_cache_manager::ScmEvictionStrategy;
pub use semantic_cache_manager::ScmHitAlias;
pub use semantic_cache_manager::ScmKeyAlias;
pub use semantic_cache_manager::ScmStatsAlias;
pub use semantic_cache_manager::SemanticCacheManager;
pub use semantic_query_optimizer::ExecutionStep;
pub use semantic_query_optimizer::FilterOp as SqoFilterOp;
pub use semantic_query_optimizer::IndexHints;
pub use semantic_query_optimizer::JoinType;
pub use semantic_query_optimizer::OptimizationRule;
pub use semantic_query_optimizer::OptimizerConfig;
pub use semantic_query_optimizer::OptimizerError;
pub use semantic_query_optimizer::OptimizerStats;
pub use semantic_query_optimizer::QueryNode as SqoQueryNode;
pub use semantic_query_optimizer::QueryPlan as SqoQueryPlan;
pub use semantic_query_optimizer::SemanticQueryOptimizer;
pub use semantic_query_optimizer::StepType;
pub use vector_index_optimizer::IndexRecommendation;
pub use vector_index_optimizer::IndexStats as VioIndexStats;
pub use vector_index_optimizer::IndexStructure;
pub use vector_index_optimizer::MaintenanceAction;
pub use vector_index_optimizer::OptimizationCriterion;
pub use vector_index_optimizer::OptimizerConfig as VioOptimizerConfig;
pub use vector_index_optimizer::OptimizerError as VioOptimizerError;
pub use vector_index_optimizer::OptimizerStats as VioOptimizerStats;
pub use vector_index_optimizer::VectorIndexOptimizer;
pub use vector_index_optimizer::WorkloadProfile;
pub use semantic_anomaly_detector::cosine_similarity as sad_cosine_similarity;
pub use semantic_anomaly_detector::AnomalyRecord as SadAnomalyRecord;
pub use semantic_anomaly_detector::ReferencePoint as SadReferencePoint;
pub use semantic_anomaly_detector::SadAnomalyScore;
pub use semantic_anomaly_detector::SadDetectionMethod;
pub use semantic_anomaly_detector::SadDetectorConfig;
pub use semantic_anomaly_detector::SadDetectorStats;
pub use semantic_anomaly_detector::SadDriftReport;
pub use semantic_anomaly_detector::SemanticAnomalyDetector as SadSemanticAnomalyDetector;
pub use hierarchical_topic_model::HierarchicalTopicModel;
pub use hierarchical_topic_model::HtmDocument;
pub use hierarchical_topic_model::HtmModelConfig;
pub use hierarchical_topic_model::HtmModelStats;
pub use hierarchical_topic_model::HtmTopic;
pub use hierarchical_topic_model::HtmTopicNode;
pub use multilingual_embedding_aligner::MeaAlignerConfig;
pub use multilingual_embedding_aligner::MeaAlignerStats;
pub use multilingual_embedding_aligner::MeaAlignmentMatrix;
pub use multilingual_embedding_aligner::MeaAlignmentMethod;
pub use multilingual_embedding_aligner::MeaLanguageSpace;
pub use multilingual_embedding_aligner::MultilingualEmbeddingAligner;
pub use embedding_compression_codec::EccCodecConfig;
pub use embedding_compression_codec::EccCodecStats;
pub use embedding_compression_codec::EccCompressed;
pub use embedding_compression_codec::EccError;
pub use embedding_compression_codec::EccMethod;
pub use embedding_compression_codec::EmbeddingCompressionCodec;
pub use semantic_cluster_labeler::SclCluster;
pub use semantic_cluster_labeler::SclError;
pub use semantic_cluster_labeler::SclLabelCandidate;
pub use semantic_cluster_labeler::SclLabelerConfig;
pub use semantic_cluster_labeler::SclLabelerStats;
pub use semantic_cluster_labeler::SclLabelingMethod;
pub use semantic_cluster_labeler::SemanticClusterLabeler;
pub use semantic_versioning_tracker::SemanticVersioningTracker;
pub use semantic_versioning_tracker::SvtDriftEvent;
pub use semantic_versioning_tracker::SvtDriftReport;
pub use semantic_versioning_tracker::SvtError;
pub use semantic_versioning_tracker::SvtSemanticVersioningTracker;
pub use semantic_versioning_tracker::SvtTrackerConfig;
pub use semantic_versioning_tracker::SvtTrackerStats;
pub use semantic_versioning_tracker::SvtVersion;
pub use semantic_versioning_tracker::SvtVersionId;
pub use semantic_search_pipeline::SemanticSearchPipeline as SspSemanticSearchPipelineExport;
pub use semantic_search_pipeline::SspDocId;
pub use semantic_search_pipeline::SspDocument;
pub use semantic_search_pipeline::SspPipelineConfig;
pub use semantic_search_pipeline::SspPipelineStats;
pub use semantic_search_pipeline::SspQueryRecord;
pub use semantic_search_pipeline::SspRerankMethod;
pub use semantic_search_pipeline::SspSearchResult;
pub use semantic_search_pipeline::SspSemanticSearchPipeline;
pub use semantic_search_pipeline::SspStage;

Modules§

adapters: Vector database adapters for external integration.
analytics: Query analytics and performance tracking
anomaly_detector: Vector Anomaly Detector
attribution_tracker: Semantic Attribution Tracker
auto_scaling: Auto-scaling advisor for production deployments
benchmark_comparison: Benchmark comparison utilities for evaluating different configurations
cache: Advanced caching for vector embeddings
cluster_analyzer: Semantic Cluster Analyzer — k-means++ style cluster analysis over embedding vectors.
cluster_manager: Semantic Cluster Manager — online k-means-style document clustering over embeddings.
concept_extractor: Concept and Keyword Extraction
concept_graph: Concept Graph Builder
concept_hierarchy: Semantic Concept Hierarchy
content_router: Semantic Content Router
context_window: Semantic Context Window
contextual_embedding_search: Contextual Embedding Search — context-aware vector search with query expansion, negative example suppression, diversity-aware re-ranking, and rich result explanations.
corpus_indexer: Inverted-index corpus indexer with BM25 scoring and faceted filtering.
cross_encoder: Cross-encoder reranking for semantic search results.
cross_modal_reranker: Cross-Modal Reranker — fuses text (BM25) and vector similarity signals to produce a single ranked list from multi-modal retrieval candidates.
dense_retriever: Dense Retriever — hybrid dense vector + BM25 sparse retrieval system.
dht: Distributed Semantic DHT
dht_node: Distributed Semantic DHT Node
diagnostics: Index diagnostics and health monitoring
dimension_reducer: Semantic Dimension Reducer
diskann: DiskANN: Disk-based Approximate Nearest Neighbor Search
diversifier: Maximal Marginal Relevance (MMR) diversification for semantic search results.
document_chunker: Document Chunker
document_graph: Semantic Document Graph
document_ranker: Multi-factor document ranking combining BM25 lexical scoring with semantic similarity.
document_summarizer: Full-featured extractive and abstractive-style document summarization.
drift_detector: Embedding Drift Detector
drift_monitor: Embedding Drift Monitor
dynamic: Dynamic embedding updates for evolving embedding spaces
embedding_aggregator: Embedding aggregation strategies for combining multiple vector representations.
embedding_cache: Semantic Embedding Cache
embedding_cluster_analyzer: Embedding Cluster Analyzer — comprehensive cluster analysis for embedding spaces.
embedding_composer: Embedding Composer — compose multiple embeddings into a single representation using various late-fusion strategies.
embedding_compression_codec: Embedding Compression Codec
embedding_drift_detector: EmbeddingDriftDetector
embedding_finetuner: Embedding Fine-Tuner
embedding_normalizer: Vector normalization and transformation for embeddings.
embedding_pipeline: Embedding Pipeline — preprocess raw content into normalized vectors for HNSW insertion.
embedding_pipeline_manager: Embedding Pipeline Manager — multi-stage text-to-vector transformation engine.
embedding_pool: Managed pool of pre-allocated embedding buffers for zero-copy semantic search operations.
entity_linker: Semantic Entity Linker
entity_resolution: Entity Disambiguation and Resolution
federated: Federated Query Support for Multi-Index Search
federated_search: Federated Search Coordinator — Cross-Node Vector Similarity Search
feedback_loop: Semantic Feedback Loop — relevance feedback collection and query re-ranking.
graph_linker: Semantic Graph Linker — builds a semantic graph by linking embeddings above a similarity threshold, enabling graph-based search and community detection.
hierarchical_topic_model: Hierarchical Topic Model (HTM) — LDA-style topic inference over a tree-structured topic hierarchy.
hnsw: HNSW vector index for semantic search
hotspot_detector: Semantic Hotspot Detector
hybrid: Hybrid search combining vector similarity with metadata filtering
index_compactor: Index Compactor
index_merger: Index Merger
index_optimizer: Embedding Index Optimizer
index_partitioner: Adaptive Index Partitioner
index_rebalancer: Embedding Index Rebalancer
intent_classifier: Semantic Intent Classifier
kb_query: Knowledge Base Query Language
knowledge_base_builder: Knowledge Base Builder
knowledge_graph: Semantic Knowledge Graph
learned: Learned index structures using ML models for data indexing.
metadata: Metadata storage and filtering for hybrid search
migration: Index migration utilities
multi_modal_indexer: Multi-Modal Content Indexer — unified index for text, vector, and structured data.
multilingual_embedding_aligner: Multilingual Embedding Aligner
multilingual_index
multilingual_normalizer: Multilingual Text Normalizer
multimodal: Multi-modal embedding support for unified semantic search across text, image, and audio.
multimodal_index: Unified multimodal index for cross-modal similarity search.
multimodal_search: Multi-Modal Search Coordinator — cross-modality result fusion and deduplication.
near_dup_detector: Semantic Near-Duplicate Detector
optimization: Index optimization utilities
partial_sync: Partial HNSW sync with dirty region tracking.
persistence: HNSW index persistence
personalizer: Semantic Personalizer — per-user interest profile management
privacy: Differential privacy for embeddings
prod_tests: Production readiness testing utilities
provenance: Provenance Tracking for Embeddings
quantization: Vector quantization for memory-efficient storage
quantization_error: Quantization error tracking for INT8/binary quantization.
query_cache: Semantic query cache with TTL expiry, LRU eviction, and hit/miss statistics.
query_expander: Semantic Query Expander
query_expansion: Query Expansion Engine
query_pipeline: Semantic Query Pipeline — composable multi-stage query processing.
query_planner: NearestNeighborQueryPlanner
query_rewriter: Semantic query rewriting and expansion system.
regression: Performance regression detection and tracking
relevance_feedback: Rocchio-style semantic relevance feedback for iterative query refinement.
reranking: Query result re-ranking
result_aggregator: Multi-source search result aggregation and ranking.
router: Semantic router for content discovery
search_explainer: Search Result Explainer
search_pipeline: Semantic Search Pipeline
search_quality: Search quality evaluation for HNSW-based retrieval systems.
search_ranker: Vector Search Re-Ranker
semantic_anomaly_detector: Semantic Anomaly Detector — production-grade anomaly detection for embedding corpora.
semantic_cache: Semantic Cache Layer
semantic_cache_manager: Semantic Cache Manager
semantic_cluster_labeler: Automatic human-readable label assignment for embedding clusters.
semantic_clusterer: SemanticClusterer — Multi-algorithm semantic vector clustering engine.
semantic_federated_search: Semantic Federated Search Coordinator
semantic_graph_builder: Semantic Knowledge Graph Builder
semantic_query_optimizer: Semantic query optimizer: parse → rewrite rules → cost estimation → execution plan.
semantic_reranker: Semantic Reranker — cross-encoder-style query-document pair scoring.
semantic_router_v2: SemanticRouterV2
semantic_search_pipeline: Semantic Search Pipeline (Ssp*)
semantic_versioning: Semantic document/embedding versioning with change detection, compatibility analysis, and migration paths.
semantic_versioning_tracker: Semantic drift tracker across model/embedding versions.
sentiment_analyzer: Lexicon-based sentiment analysis engine with aspect-level sentiment detection.
shard_balancer: HNSW-on-DHT Shard Balancing
shard_coordinator: Shard Coordinator — Consistent-Hash Distribution of Vectors Across Nodes
simd: SIMD-optimized distance computation
similarity_cache: Two-level cache for cosine similarity scores between embedding pairs.
similarity_cache_v2: Pairwise cosine-similarity cache with LFU eviction and tick-based TTL.
similarity_graph: Semantic Similarity Graph
solver: Logic solver for reasoning queries with semantic integration
stats: Index statistics and monitoring
summary_extractor: Extractive summarization based on sentence embedding similarity.
synonym_expander: Semantic Synonym Expander
tag_extractor: Semantic Tag Extractor
term_weighter: Semantic Term Weighter
text_similarity_scorer: Text Similarity Scorer
text_summarizer: Extractive text summarization using TF-IDF sentence scoring and TextRank graph-based ranking.
tokenizer: Semantic Tokenizer — text tokenization for semantic search indexing.
topic_model_extractor: Topic Model Extractor — production-quality collapsed Gibbs sampling LDA.
topic_modeler: Semantic Topic Modeller — online clustering approach for latent topic modelling.
utils: Utility functions and helpers for common semantic search workflows
vector_index_optimizer: Vector Index Optimizer
vector_quality: Vector quality analysis and validation utilities
vector_quantizer: Vector Quantizer
vocab_index: Semantic Vocabulary Index — maps tokens to numeric IDs with frequency and document-frequency tracking, TF-IDF helpers, and automatic pruning.

Type Aliases§

EddDetectorConfigAlias: Type alias: EddDetectorConfig is the config for EddEmbeddingDriftDetector.
EddDriftSignalAlias: Type alias: EddDriftSignal is the production drift signal from embedding_drift_detector.