Struct HashProvider 

pub struct HashProvider { /* private fields */ }

Hash-based embedding provider (fast, lightweight, no dependencies)

Implementations

impl HashProvider

pub fn new(dimension: usize) -> Self

Examples found in repository

examples/test_onnx_download.rs (line 118)

async fn test_hash_comparison() -> Result<()> {
    println!("Comparing with hash provider baseline...");

    let hash_provider = HashProvider::new(384);
    let test_text = "React hooks useState for state management";

    let start = std::time::Instant::now();
    let hash_embedding = hash_provider.embed_text(test_text).await?;
    let hash_time = start.elapsed();

    println!("📊 Hash Provider Results:");
    println!("   Dimension: {}", hash_embedding.len());
    println!("   Time: {:?}", hash_time);
    println!("   First 5 values: {:?}", &hash_embedding[..5]);
    println!("   Semantic quality: ~0.57 (deterministic but limited)");

    println!("\n🔬 Expected ONNX Results:");
    println!("   Dimension: 384 (same)");
    println!("   Time: ~0.4ms (slower but reasonable)");
    println!("   Values: Contextual semantic features");
    println!("   Semantic quality: ~0.87 (much better understanding)");

    Ok(())
}

examples/benchmark_hash.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔥 Manx Embedding Provider Benchmarks");
    println!("=====================================\n");

    // Test different hash dimensions
    let dimensions = vec![128, 256, 384, 512, 768];
    let test_data = BenchmarkTestData::new_default();
    let extended_data = BenchmarkTestData::extended();

    println!("📊 Testing Hash Provider with Different Dimensions");
    println!(
        "Test Data: {} texts with {} similarity pairs\n",
        test_data.texts.len(),
        test_data.semantic_pairs.len()
    );

    let mut results = Vec::new();

    for dim in &dimensions {
        let provider = HashProvider::new(*dim);
        let result = benchmark_provider(&provider, &test_data).await?;
        results.push(result);
    }

    print_benchmark_results(&results);

    println!("\n📈 Extended Dataset Benchmark (Hash-384)");
    println!(
        "Extended Data: {} texts with {} similarity pairs\n",
        extended_data.texts.len(),
        extended_data.semantic_pairs.len()
    );

    let provider_384 = HashProvider::new(384);
    let extended_result = benchmark_provider(&provider_384, &extended_data).await?;
    print_benchmark_results(&[extended_result]);

    println!("\n✅ Benchmark Complete!");
    println!("💡 Next: Compare with ONNX-based embeddings for quality improvements");

    Ok(())
}

examples/benchmark_onnx_vs_hash.rs (line 44)

async fn main() -> Result<()> {
    // Initialize logging to see what's happening
    env_logger::builder()
        .filter_level(log::LevelFilter::Info)
        .init();

    println!("🚀 Manx Embedding Provider Performance Comparison");
    println!("================================================");
    println!("Comparing Hash vs ONNX-based embeddings\n");

    // Test data for comparison
    let test_data = BenchmarkTestData::extended();
    println!("📊 Test Dataset:");
    println!(
        "   {} texts with {} semantic similarity pairs",
        test_data.texts.len(),
        test_data.semantic_pairs.len()
    );

    println!("\n📋 Sample texts:");
    for (i, text) in test_data.texts.iter().take(3).enumerate() {
        println!("   {}. {}", i + 1, text);
    }
    println!("   ... and {} more", test_data.texts.len() - 3);

    println!("\n{}", "=".repeat(60));

    // Benchmark 1: Hash Provider (current baseline)
    println!("\n🔧 PHASE 1: Hash-based Embeddings (Baseline)");
    println!("---------------------------------------------");

    let hash_provider = HashProvider::new(384);
    let hash_result = benchmark_provider(&hash_provider, &test_data).await?;

    print_benchmark_results(std::slice::from_ref(&hash_result));

    // Benchmark 2: ONNX Provider (if available)
    println!("\n🤖 PHASE 2: ONNX-based Embeddings (Testing)");
    println!("--------------------------------------------");

    // Check if we need to download the model
    let model_name = "sentence-transformers/all-MiniLM-L6-v2";
    println!("📦 Checking for ONNX model: {}", model_name);

    // Note: In a real implementation, we'd download the model here
    // For now, we'll create a simulation to show what the comparison would look like
    println!("⚠️  ONNX model download not implemented in this demo");
    println!("    In production, this would:");
    println!("    1. Download {} from HuggingFace", model_name);
    println!("    2. Convert to ONNX format if needed");
    println!("    3. Load tokenizer and model files");
    println!("    4. Initialize ONNX Runtime session");

    // Simulate what ONNX results would look like based on research
    simulate_onnx_comparison(&hash_result).await?;

    println!("\n{}", "=".repeat(60));
    println!("\n📈 SUMMARY & RECOMMENDATIONS");
    println!("============================");

    print_recommendations(&hash_result);

    println!("\n✅ Benchmark Complete!");
    println!("\n💡 To enable real ONNX testing:");
    println!("   1. Implement model download from HuggingFace");
    println!("   2. Add ONNX model file handling");
    println!(
        "   3. Test with: cargo run --example benchmark_onnx_vs_hash --features onnx-embeddings"
    );

    Ok(())
}

Trait Implementations

impl EmbeddingProvider for HashProvider

fn embed_text<'life0, 'life1, 'async_trait>( &'life0 self, text: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<f32>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Generate embeddings for a single text

fn get_dimension<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the dimension of embeddings produced by this provider

fn health_check<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Test if the provider is available and working

fn get_info(&self) -> ProviderInfo

Get provider-specific information