Crate oxirs_vec 

OxiRS Vector Search

Status: Production Release (v0.1.0) - Production-Ready with Complete Documentation Stability: Public APIs are stable. Production-ready with comprehensive testing and 100 KB of documentation.

Vector index abstractions for semantic similarity and AI-augmented SPARQL querying.

This crate provides comprehensive vector search capabilities for knowledge graphs, enabling semantic similarity searches, AI-augmented SPARQL queries, and hybrid symbolic-vector operations.

Features

• Multi-algorithm embeddings: TF-IDF, sentence transformers, custom models
• Advanced indexing: HNSW, flat, quantized, and multi-index support
• Rich similarity metrics: Cosine, Euclidean, Pearson, Jaccard, and more
• SPARQL integration: vec:similar service functions and hybrid queries
• Performance optimization: Caching, batching, and parallel processing

Quick Start

use oxirs_vec::{VectorStore, embeddings::EmbeddingStrategy};

// Create vector store with sentence transformer embeddings
let mut store = VectorStore::with_embedding_strategy(
    EmbeddingStrategy::SentenceTransformer
).unwrap();

// Index some content
store
    .index_resource(
        "http://example.org/doc1".to_string(),
        "This is a document about AI",
    )
    .unwrap();
store
    .index_resource(
        "http://example.org/doc2".to_string(),
        "Machine learning tutorial",
    )
    .unwrap();

// Search for similar content
let results = store
    .similarity_search("artificial intelligence", 5)
    .unwrap();

println!("Found {} matching resources", results.len());

Re-exports

pub use adaptive_compression::AdaptiveCompressor;

pub use adaptive_compression::CompressionMetrics;

pub use adaptive_compression::CompressionPriorities;

pub use adaptive_compression::MultiLevelCompression;

pub use adaptive_compression::VectorStats;

pub use adaptive_intelligent_caching::AccessPatternAnalyzer;

pub use adaptive_intelligent_caching::AdaptiveIntelligentCache;

pub use adaptive_intelligent_caching::CacheConfiguration;

pub use adaptive_intelligent_caching::CacheOptimizer;

pub use adaptive_intelligent_caching::CachePerformanceMetrics;

pub use adaptive_intelligent_caching::CacheTier;

pub use adaptive_intelligent_caching::MLModels;

pub use adaptive_intelligent_caching::PredictivePrefetcher;

pub use advanced_analytics::AnomalyDetection;

pub use advanced_analytics::AnomalyDetector;

pub use advanced_analytics::AnomalyType;

pub use advanced_analytics::ImplementationEffort;

pub use advanced_analytics::OptimizationRecommendation;

pub use advanced_analytics::PerformanceTrends;

pub use advanced_analytics::Priority;

pub use advanced_analytics::QualityAspect;

pub use advanced_analytics::QualityRecommendation;

pub use advanced_analytics::QueryAnalytics;

pub use advanced_analytics::QueryAnomaly;

pub use advanced_analytics::RecommendationType;

pub use advanced_analytics::VectorAnalyticsEngine;

pub use advanced_analytics::VectorDistributionAnalysis;

pub use advanced_analytics::VectorQualityAssessment;

pub use advanced_benchmarking::AdvancedBenchmarkConfig;

pub use advanced_benchmarking::AdvancedBenchmarkResult;

pub use advanced_benchmarking::AdvancedBenchmarkSuite;

pub use advanced_benchmarking::AlgorithmParameters;

pub use advanced_benchmarking::BenchmarkAlgorithm;

pub use advanced_benchmarking::BuildTimeMetrics;

pub use advanced_benchmarking::CacheMetrics;

pub use advanced_benchmarking::DatasetQualityMetrics;

pub use advanced_benchmarking::DatasetStatistics;

pub use advanced_benchmarking::DistanceStatistics;

pub use advanced_benchmarking::EnhancedBenchmarkDataset;

pub use advanced_benchmarking::HyperparameterTuner;

pub use advanced_benchmarking::IndexSizeMetrics;

pub use advanced_benchmarking::LatencyMetrics;

pub use advanced_benchmarking::MemoryMetrics;

pub use advanced_benchmarking::ObjectiveFunction;

pub use advanced_benchmarking::OptimizationStrategy;

pub use advanced_benchmarking::ParallelBenchmarkConfig;

pub use advanced_benchmarking::ParameterSpace;

pub use advanced_benchmarking::ParameterType;

pub use advanced_benchmarking::ParameterValue;

pub use advanced_benchmarking::PerformanceMetrics;

pub use advanced_benchmarking::PerformanceProfiler;

pub use advanced_benchmarking::QualityDegradation;

pub use advanced_benchmarking::QualityMetrics;

pub use advanced_benchmarking::ScalabilityMetrics;

pub use advanced_benchmarking::StatisticalAnalyzer;

pub use advanced_benchmarking::StatisticalMetrics;

pub use advanced_benchmarking::ThroughputMetrics;

pub use advanced_caching::BackgroundCacheWorker;

pub use advanced_caching::CacheAnalysisReport;

pub use advanced_caching::CacheAnalyzer;

pub use advanced_caching::CacheConfig;

pub use advanced_caching::CacheEntry;

pub use advanced_caching::CacheInvalidator;

pub use advanced_caching::CacheKey;

pub use advanced_caching::CacheStats;

pub use advanced_caching::CacheWarmer;

pub use advanced_caching::EvictionPolicy;

pub use advanced_caching::InvalidationStats;

pub use advanced_caching::MultiLevelCache;

pub use advanced_caching::MultiLevelCacheStats;

pub use advanced_result_merging::AdvancedResultMerger;

pub use advanced_result_merging::ConfidenceInterval;

pub use advanced_result_merging::DiversityConfig;

pub use advanced_result_merging::DiversityMetric;

pub use advanced_result_merging::FusionStatistics;

pub use advanced_result_merging::MergedResult;

pub use advanced_result_merging::RankFusionAlgorithm;

pub use advanced_result_merging::RankingFactor;

pub use advanced_result_merging::ResultExplanation;

pub use advanced_result_merging::ResultMergingConfig;

pub use advanced_result_merging::ResultMetadata;

pub use advanced_result_merging::ScoreCombinationStrategy;

pub use advanced_result_merging::ScoreNormalizationMethod;

pub use advanced_result_merging::ScoredResult;

pub use advanced_result_merging::SourceContribution;

pub use advanced_result_merging::SourceResult;

pub use advanced_result_merging::SourceType;

pub use automl_optimization::AutoMLConfig;

pub use automl_optimization::AutoMLOptimizer;

pub use automl_optimization::AutoMLResults;

pub use automl_optimization::AutoMLStatistics;

pub use automl_optimization::IndexConfiguration;

pub use automl_optimization::IndexParameterSpace;

pub use automl_optimization::OptimizationMetric;

pub use automl_optimization::OptimizationTrial;

pub use automl_optimization::ResourceConstraints;

pub use automl_optimization::SearchSpace;

pub use automl_optimization::TrialResult;

pub use benchmarking::BenchmarkConfig;

pub use benchmarking::BenchmarkDataset;

pub use benchmarking::BenchmarkOutputFormat;

pub use benchmarking::BenchmarkResult;

pub use benchmarking::BenchmarkRunner;

pub use benchmarking::BenchmarkSuite;

pub use benchmarking::BenchmarkTestCase;

pub use benchmarking::MemoryMetrics as BenchmarkMemoryMetrics;

pub use benchmarking::PerformanceMetrics as BenchmarkPerformanceMetrics;

pub use benchmarking::QualityMetrics as BenchmarkQualityMetrics;

pub use benchmarking::ScalabilityMetrics as BenchmarkScalabilityMetrics;

pub use benchmarking::SystemInfo;

pub use cache_friendly_index::CacheFriendlyVectorIndex;

pub use cache_friendly_index::IndexConfig as CacheFriendlyIndexConfig;

pub use compaction::CompactionConfig;

pub use compaction::CompactionManager;

pub use compaction::CompactionMetrics;

pub use compaction::CompactionResult;

pub use compaction::CompactionState;

pub use compaction::CompactionStatistics;

pub use compaction::CompactionStrategy;

pub use compression::create_compressor;

pub use compression::CompressionMethod;

pub use compression::VectorCompressor;

pub use content_processing::ChunkType;

pub use content_processing::ChunkingStrategy;

pub use content_processing::ContentChunk;

pub use content_processing::ContentExtractionConfig;

pub use content_processing::ContentLocation;

pub use content_processing::ContentProcessor;

pub use content_processing::DocumentFormat;

pub use content_processing::DocumentStructure;

pub use content_processing::ExtractedContent;

pub use content_processing::ExtractedImage;

pub use content_processing::ExtractedLink;

pub use content_processing::ExtractedTable;

pub use content_processing::FormatHandler;

pub use content_processing::Heading;

pub use content_processing::ProcessingStats;

pub use content_processing::TocEntry;

pub use crash_recovery::CrashRecoveryManager;

pub use crash_recovery::RecoveryConfig;

pub use crash_recovery::RecoveryPolicy;

pub use crash_recovery::RecoveryStats;

pub use cross_modal_embeddings::AttentionMechanism;

pub use cross_modal_embeddings::AudioData;

pub use cross_modal_embeddings::AudioEncoder;

pub use cross_modal_embeddings::CrossModalConfig;

pub use cross_modal_embeddings::CrossModalEncoder;

pub use cross_modal_embeddings::FusionLayer;

pub use cross_modal_embeddings::FusionStrategy;

pub use cross_modal_embeddings::GraphData;

pub use cross_modal_embeddings::GraphEncoder;

pub use cross_modal_embeddings::ImageData;

pub use cross_modal_embeddings::ImageEncoder;

pub use cross_modal_embeddings::Modality;

pub use cross_modal_embeddings::ModalityData;

pub use cross_modal_embeddings::MultiModalContent;

pub use cross_modal_embeddings::TextEncoder;

pub use cross_modal_embeddings::VideoData;

pub use cross_modal_embeddings::VideoEncoder;

pub use diskann::DiskAnnBuildStats;

pub use diskann::DiskAnnBuilder;

pub use diskann::DiskAnnConfig;

pub use diskann::DiskAnnError;

pub use diskann::DiskAnnIndex;

pub use diskann::DiskAnnResult;

pub use diskann::DiskStorage;

pub use diskann::IndexMetadata as DiskAnnIndexMetadata;

pub use diskann::MemoryMappedStorage;

pub use diskann::NodeId;

pub use diskann::PruningStrategy;

pub use diskann::SearchMode as DiskAnnSearchMode;

pub use diskann::SearchStats as DiskAnnSearchStats;

pub use diskann::StorageBackend;

pub use diskann::VamanaGraph;

pub use diskann::VamanaNode;

pub use diskann::VectorId as DiskAnnVectorId;

pub use distributed_vector_search::ConsistencyLevel;

pub use distributed_vector_search::DistributedClusterStats;

pub use distributed_vector_search::DistributedNodeConfig;

pub use distributed_vector_search::DistributedQuery;

pub use distributed_vector_search::DistributedSearchResponse;

pub use distributed_vector_search::DistributedVectorSearch;

pub use distributed_vector_search::LoadBalancingAlgorithm;

pub use distributed_vector_search::NodeHealthStatus;

pub use distributed_vector_search::PartitioningStrategy;

pub use distributed_vector_search::QueryExecutionStrategy;

pub use dynamic_index_selector::DynamicIndexSelector;

pub use dynamic_index_selector::IndexSelectorConfig;

pub use embedding_pipeline::DimensionalityReduction;

pub use embedding_pipeline::EmbeddingPipeline;

pub use embedding_pipeline::NormalizationConfig;

pub use embedding_pipeline::PostprocessingPipeline;

pub use embedding_pipeline::PreprocessingPipeline;

pub use embedding_pipeline::TokenizerConfig;

pub use embedding_pipeline::VectorNormalization;

pub use embeddings::EmbeddableContent;

pub use embeddings::EmbeddingConfig;

pub use embeddings::EmbeddingManager;

pub use embeddings::EmbeddingStrategy;

pub use embeddings::ModelDetails;

pub use embeddings::OpenAIConfig;

pub use embeddings::OpenAIEmbeddingGenerator;

pub use embeddings::SentenceTransformerGenerator;

pub use embeddings::TransformerModelType;

pub use enhanced_performance_monitoring::Alert;

pub use enhanced_performance_monitoring::AlertManager;

pub use enhanced_performance_monitoring::AlertSeverity;

pub use enhanced_performance_monitoring::AlertThresholds;

pub use enhanced_performance_monitoring::AlertType;

pub use enhanced_performance_monitoring::AnalyticsEngine;

pub use enhanced_performance_monitoring::AnalyticsReport;

pub use enhanced_performance_monitoring::DashboardData;

pub use enhanced_performance_monitoring::EnhancedPerformanceMonitor;

pub use enhanced_performance_monitoring::ExportConfig;

pub use enhanced_performance_monitoring::ExportDestination;

pub use enhanced_performance_monitoring::ExportFormat;

pub use enhanced_performance_monitoring::LatencyDistribution;

pub use enhanced_performance_monitoring::MonitoringConfig as EnhancedMonitoringConfig;

pub use enhanced_performance_monitoring::QualityMetrics as EnhancedQualityMetrics;

pub use enhanced_performance_monitoring::QualityMetricsCollector;

pub use enhanced_performance_monitoring::QualityStatistics;

pub use enhanced_performance_monitoring::QueryInfo;

pub use enhanced_performance_monitoring::QueryMetricsCollector;

pub use enhanced_performance_monitoring::QueryStatistics;

pub use enhanced_performance_monitoring::QueryType;

pub use enhanced_performance_monitoring::Recommendation;

pub use enhanced_performance_monitoring::RecommendationCategory;

pub use enhanced_performance_monitoring::RecommendationPriority;

pub use enhanced_performance_monitoring::SystemMetrics;

pub use enhanced_performance_monitoring::SystemMetricsCollector;

pub use enhanced_performance_monitoring::SystemStatistics;

pub use enhanced_performance_monitoring::TrendData;

pub use enhanced_performance_monitoring::TrendDirection;

pub use faiss_compatibility::CompressionLevel;

pub use faiss_compatibility::ConversionMetrics;

pub use faiss_compatibility::ConversionResult;

pub use faiss_compatibility::FaissCompatibility;

pub use faiss_compatibility::FaissExportConfig;

pub use faiss_compatibility::FaissImportConfig;

pub use faiss_compatibility::FaissIndexMetadata;

pub use faiss_compatibility::FaissIndexType;

pub use faiss_compatibility::FaissMetricType;

pub use faiss_compatibility::FaissParameter;

pub use faiss_compatibility::SimpleVectorIndex;

pub use federated_search::AuthenticationConfig;

pub use federated_search::FederatedSearchConfig;

pub use federated_search::FederatedVectorSearch;

pub use federated_search::FederationEndpoint;

pub use federated_search::PrivacyEngine;

pub use federated_search::PrivacyMode;

pub use federated_search::SchemaCompatibility;

pub use federated_search::TrustManager;

pub use gnn_embeddings::AggregatorType;

pub use gnn_embeddings::GraphSAGE;

pub use gnn_embeddings::GCN;

pub use gpu::create_default_accelerator;

pub use gpu::create_memory_optimized_accelerator;

pub use gpu::create_performance_accelerator;

pub use gpu::is_gpu_available;

pub use gpu::GpuAccelerator;

pub use gpu::GpuBuffer;

pub use gpu::GpuConfig;

pub use gpu::GpuDevice;

pub use gpu::GpuExecutionConfig;

pub use gpu_benchmarks::BenchmarkResult as GpuBenchmarkResult;

pub use gpu_benchmarks::GpuBenchmarkConfig;

pub use gpu_benchmarks::GpuBenchmarkSuite;

pub use graph_indices::DelaunayGraph;

pub use graph_indices::GraphIndex;

pub use graph_indices::GraphIndexConfig;

pub use graph_indices::GraphType;

pub use graph_indices::NSWGraph;

pub use graph_indices::ONNGGraph;

pub use graph_indices::PANNGGraph;

pub use graph_indices::RNGGraph;

pub use hierarchical_similarity::ConceptHierarchy;

pub use hierarchical_similarity::HierarchicalSimilarity;

pub use hierarchical_similarity::HierarchicalSimilarityConfig;

pub use hierarchical_similarity::HierarchicalSimilarityResult;

pub use hierarchical_similarity::HierarchicalSimilarityStats;

pub use hierarchical_similarity::SimilarityContext;

pub use hierarchical_similarity::SimilarityExplanation;

pub use hierarchical_similarity::SimilarityTaskType;

pub use hnsw::HnswConfig;

pub use hnsw::HnswIndex;

pub use hybrid_fusion::FusedResult;

pub use hybrid_fusion::HybridFusion;

pub use hybrid_fusion::HybridFusionConfig;

pub use hybrid_fusion::HybridFusionStatistics;

pub use hybrid_fusion::HybridFusionStrategy;

pub use hybrid_fusion::NormalizationMethod;

pub use hybrid_search::Bm25Scorer;

pub use hybrid_search::DocumentScore;

pub use hybrid_search::HybridQuery;

pub use hybrid_search::HybridResult;

pub use hybrid_search::HybridSearchConfig;

pub use hybrid_search::HybridSearchManager;

pub use hybrid_search::KeywordAlgorithm;

pub use hybrid_search::KeywordMatch;

pub use hybrid_search::KeywordSearcher;

pub use hybrid_search::QueryExpander;

pub use hybrid_search::RankFusion;

pub use hybrid_search::RankFusionStrategy;

pub use hybrid_search::SearchMode;

pub use hybrid_search::SearchWeights;

pub use hybrid_search::TfidfScorer;

pub use index::AdvancedVectorIndex;

pub use index::DistanceMetric;

pub use index::IndexConfig;

pub use index::IndexType;

pub use index::SearchResult;

pub use ivf::IvfConfig;

pub use ivf::IvfIndex;

pub use ivf::IvfStats;

pub use ivf::QuantizationStrategy;

pub use joint_embedding_spaces::ActivationFunction;

pub use joint_embedding_spaces::AlignmentPair;

pub use joint_embedding_spaces::CLIPAligner;

pub use joint_embedding_spaces::ContrastiveOptimizer;

pub use joint_embedding_spaces::CrossModalAttention;

pub use joint_embedding_spaces::CurriculumLearning;

pub use joint_embedding_spaces::DataAugmentation;

pub use joint_embedding_spaces::DifficultySchedule;

pub use joint_embedding_spaces::DomainAdapter;

pub use joint_embedding_spaces::DomainStatistics;

pub use joint_embedding_spaces::JointEmbeddingConfig;

pub use joint_embedding_spaces::JointEmbeddingSpace;

pub use joint_embedding_spaces::LearningRateSchedule;

pub use joint_embedding_spaces::LinearProjector;

pub use joint_embedding_spaces::PacingFunction;

pub use joint_embedding_spaces::ScheduleType;

pub use joint_embedding_spaces::TemperatureScheduler;

pub use joint_embedding_spaces::TrainingStatistics;

pub use kg_embeddings::ComplEx;

pub use kg_embeddings::KGEmbedding;

pub use kg_embeddings::KGEmbeddingConfig;

pub use kg_embeddings::KGEmbeddingModel as KGModel;

pub use kg_embeddings::KGEmbeddingModelType;

pub use kg_embeddings::RotatE;

pub use kg_embeddings::TransE;

pub use kg_embeddings::Triple;

pub use lsh::LshConfig;

pub use lsh::LshFamily;

pub use lsh::LshIndex;

pub use lsh::LshStats;

pub use mmap_index::MemoryMappedIndexStats;

pub use mmap_index::MemoryMappedVectorIndex;

pub use multi_tenancy::AccessControl;

pub use multi_tenancy::AccessPolicy;

pub use multi_tenancy::BillingEngine;

pub use multi_tenancy::BillingMetrics;

pub use multi_tenancy::BillingPeriod;

pub use multi_tenancy::IsolationLevel;

pub use multi_tenancy::IsolationStrategy;

pub use multi_tenancy::MultiTenancyError;

pub use multi_tenancy::MultiTenancyResult;

pub use multi_tenancy::MultiTenantManager;

pub use multi_tenancy::NamespaceManager;

pub use multi_tenancy::Permission;

pub use multi_tenancy::PricingModel;

pub use multi_tenancy::QuotaEnforcer;

pub use multi_tenancy::QuotaLimits;

pub use multi_tenancy::QuotaUsage;

pub use multi_tenancy::RateLimiter;

pub use multi_tenancy::ResourceQuota;

pub use multi_tenancy::ResourceType;

pub use multi_tenancy::Role;

pub use multi_tenancy::Tenant;

pub use multi_tenancy::TenantConfig;

pub use multi_tenancy::TenantContext;

pub use multi_tenancy::TenantId;

pub use multi_tenancy::TenantManagerConfig;

pub use multi_tenancy::TenantMetadata;

pub use multi_tenancy::TenantOperation;

pub use multi_tenancy::TenantStatistics;

pub use multi_tenancy::TenantStatus;

pub use multi_tenancy::UsageRecord;

pub use nsg::DistanceMetric as NsgDistanceMetric;

pub use nsg::NsgConfig;

pub use nsg::NsgIndex;

pub use nsg::NsgStats;

pub use performance_insights::AlertingSystem;

pub use performance_insights::OptimizationRecommendations;

pub use performance_insights::PerformanceInsightsAnalyzer;

pub use performance_insights::PerformanceTrends as InsightsPerformanceTrends;

pub use performance_insights::QueryComplexity;

pub use performance_insights::QueryStatistics as InsightsQueryStatistics;

pub use performance_insights::ReportFormat;

pub use performance_insights::VectorStatistics;

pub use pq::PQConfig;

pub use pq::PQIndex;

pub use pq::PQStats;

pub use pytorch::ArchitectureType;

pub use pytorch::CompileMode;

pub use pytorch::DeviceManager;

pub use pytorch::PyTorchConfig;

pub use pytorch::PyTorchDevice;

pub use pytorch::PyTorchEmbedder;

pub use pytorch::PyTorchModelManager;

pub use pytorch::PyTorchModelMetadata;

pub use pytorch::PyTorchTokenizer;

pub use quantum_search::QuantumSearchConfig;

pub use quantum_search::QuantumSearchResult;

pub use quantum_search::QuantumSearchStatistics;

pub use quantum_search::QuantumState;

pub use quantum_search::QuantumVectorSearch;

pub use query_planning::CostModel;

pub use query_planning::IndexStatistics;

pub use query_planning::QueryCharacteristics;

pub use query_planning::QueryPlan;

pub use query_planning::QueryPlanner;

pub use query_planning::QueryStrategy;

pub use query_planning::VectorQueryType;

pub use query_rewriter::QueryRewriter;

pub use query_rewriter::QueryRewriterConfig;

pub use query_rewriter::QueryVectorStatistics;

pub use query_rewriter::RewriteRule;

pub use query_rewriter::RewrittenQuery;

pub use rdf_content_enhancement::ComponentWeights;

pub use rdf_content_enhancement::MultiLanguageProcessor;

pub use rdf_content_enhancement::PathConstraint;

pub use rdf_content_enhancement::PathDirection;

pub use rdf_content_enhancement::PropertyAggregator;

pub use rdf_content_enhancement::PropertyPath;

pub use rdf_content_enhancement::RdfContentConfig;

pub use rdf_content_enhancement::RdfContentProcessor;

pub use rdf_content_enhancement::RdfContext;

pub use rdf_content_enhancement::RdfEntity;

pub use rdf_content_enhancement::RdfValue;

pub use rdf_content_enhancement::TemporalInfo;

pub use rdf_integration::RdfIntegrationStats;

pub use rdf_integration::RdfTermMapping;

pub use rdf_integration::RdfTermMetadata;

pub use rdf_integration::RdfTermType;

pub use rdf_integration::RdfVectorConfig;

pub use rdf_integration::RdfVectorIntegration;

pub use rdf_integration::RdfVectorSearchResult;

pub use rdf_integration::SearchMetadata;

pub use real_time_analytics::AlertSeverity as AnalyticsAlertSeverity;

pub use real_time_analytics::AlertType as AnalyticsAlertType;

pub use real_time_analytics::AnalyticsConfig;

pub use real_time_analytics::AnalyticsEvent;

pub use real_time_analytics::AnalyticsReport as RealTimeAnalyticsReport;

pub use real_time_analytics::DashboardData as RealTimeDashboardData;

pub use real_time_analytics::ExportFormat as AnalyticsExportFormat;

pub use real_time_analytics::MetricsCollector;

pub use real_time_analytics::PerformanceMonitor;

pub use real_time_analytics::QueryMetrics;

pub use real_time_analytics::SystemMetrics as AnalyticsSystemMetrics;

pub use real_time_analytics::VectorAnalyticsEngine as RealTimeVectorAnalyticsEngine;

pub use real_time_embedding_pipeline::AlertThresholds as PipelineAlertThresholds;

pub use real_time_embedding_pipeline::AutoScalingConfig;

pub use real_time_embedding_pipeline::CompressionConfig;

pub use real_time_embedding_pipeline::ContentItem;

pub use real_time_embedding_pipeline::MonitoringConfig as PipelineMonitoringConfig;

pub use real_time_embedding_pipeline::PipelineConfig as RealTimeEmbeddingConfig;

pub use real_time_embedding_pipeline::PipelineStatistics as PipelineStats;

pub use real_time_embedding_pipeline::ProcessingPriority;

pub use real_time_embedding_pipeline::ProcessingResult;

pub use real_time_embedding_pipeline::ProcessingStatus;

pub use real_time_embedding_pipeline::RealTimeEmbeddingPipeline;

pub use real_time_embedding_pipeline::VersioningStrategy;

pub use real_time_updates::BatchProcessor;

pub use real_time_updates::RealTimeConfig;

pub use real_time_updates::RealTimeVectorSearch;

pub use real_time_updates::RealTimeVectorUpdater;

pub use real_time_updates::UpdateBatch;

pub use real_time_updates::UpdateOperation;

pub use real_time_updates::UpdatePriority;

pub use real_time_updates::UpdateStats;

pub use reranking::CrossEncoder;

pub use reranking::CrossEncoderBackend;

pub use reranking::CrossEncoderModel;

pub use reranking::CrossEncoderReranker;

pub use reranking::DiversityReranker;

pub use reranking::DiversityStrategy;

pub use reranking::FusionStrategy as RerankingFusionStrategy;

pub use reranking::ModelBackend;

pub use reranking::ModelConfig;

pub use reranking::RerankingCache;

pub use reranking::RerankingCacheConfig;

pub use reranking::RerankingConfig;

pub use reranking::RerankingError;

pub use reranking::RerankingMode;

pub use reranking::RerankingOutput;

pub use reranking::RerankingStats;

pub use reranking::Result as RerankingResult;

pub use reranking::ScoreFusion;

pub use reranking::ScoreFusionConfig;

pub use reranking::ScoredCandidate;

pub use result_fusion::FusedResults;

pub use result_fusion::FusionAlgorithm;

pub use result_fusion::FusionConfig;

pub use result_fusion::FusionQualityMetrics;

pub use result_fusion::FusionStats;

pub use result_fusion::ResultFusionEngine;

pub use result_fusion::ScoreNormalizationStrategy;

pub use result_fusion::SourceResults;

pub use result_fusion::VectorSearchResult;

pub use similarity::AdaptiveSimilarity;

pub use similarity::SemanticSimilarity;

pub use similarity::SimilarityConfig;

pub use similarity::SimilarityMetric;

pub use sparql_integration::CrossLanguageProcessor;

pub use sparql_integration::FederatedQueryResult;

pub use sparql_integration::QueryExecutor;

pub use sparql_integration::SparqlVectorFunctions;

pub use sparql_integration::SparqlVectorService;

pub use sparql_integration::VectorOperation;

pub use sparql_integration::VectorQuery;

pub use sparql_integration::VectorQueryResult;

pub use sparql_integration::VectorServiceArg;

pub use sparql_integration::VectorServiceConfig;

pub use sparql_integration::VectorServiceResult;

pub use sparql_service_endpoint::AuthenticationInfo;

pub use sparql_service_endpoint::AuthenticationType;

pub use sparql_service_endpoint::CustomFunctionRegistry;

pub use sparql_service_endpoint::FederatedOperation;

pub use sparql_service_endpoint::FederatedSearchResult;

pub use sparql_service_endpoint::FederatedServiceEndpoint;

pub use sparql_service_endpoint::FederatedVectorQuery;

pub use sparql_service_endpoint::FunctionMetadata;

pub use sparql_service_endpoint::LoadBalancer;

pub use sparql_service_endpoint::ParameterInfo;

pub use sparql_service_endpoint::ParameterType as ServiceParameterType;

pub use sparql_service_endpoint::PartialSearchResult;

pub use sparql_service_endpoint::QueryScope;

pub use sparql_service_endpoint::ReturnType;

pub use sparql_service_endpoint::ServiceCapability;

pub use sparql_service_endpoint::ServiceEndpointManager;

pub use sparql_service_endpoint::ServiceType;

pub use sparse::COOMatrix;

pub use sparse::CSRMatrix;

pub use sparse::SparseVector;

pub use sq::QuantizationMode;

pub use sq::QuantizationParams;

pub use sq::SqConfig;

pub use sq::SqIndex;

pub use sq::SqStats;

pub use storage_optimizations::CompressionType;

pub use storage_optimizations::MmapVectorFile;

pub use storage_optimizations::StorageConfig;

pub use storage_optimizations::StorageUtils;

pub use storage_optimizations::VectorBlock;

pub use storage_optimizations::VectorFileHeader;

pub use storage_optimizations::VectorReader;

pub use storage_optimizations::VectorWriter;

pub use structured_vectors::ConfidenceScoredVector;

pub use structured_vectors::HierarchicalVector;

pub use structured_vectors::NamedDimensionVector;

pub use structured_vectors::TemporalVector;

pub use structured_vectors::WeightedDimensionVector;

pub use tensorflow::OptimizationLevel;

pub use tensorflow::PreprocessingPipeline as TensorFlowPreprocessingPipeline;

pub use tensorflow::ServerConfig;

pub use tensorflow::SessionConfig;

pub use tensorflow::TensorDataType;

pub use tensorflow::TensorFlowConfig;

pub use tensorflow::TensorFlowDevice;

pub use tensorflow::TensorFlowEmbedder;

pub use tensorflow::TensorFlowModelInfo;

pub use tensorflow::TensorFlowModelServer;

pub use tensorflow::TensorSpec;

pub use tiering::IndexMetadata;

pub use tiering::StorageTier;

pub use tiering::TierMetrics;

pub use tiering::TierStatistics;

pub use tiering::TierTransitionReason;

pub use tiering::TieringConfig;

pub use tiering::TieringManager;

pub use tiering::TieringPolicy;

pub use tree_indices::BallTree;

pub use tree_indices::CoverTree;

pub use tree_indices::KdTree;

pub use tree_indices::RandomProjectionTree;

pub use tree_indices::TreeIndex;

pub use tree_indices::TreeIndexConfig;

pub use tree_indices::TreeType;

pub use tree_indices::VpTree;

pub use wal::WalConfig;

pub use wal::WalEntry;

pub use wal::WalManager;

pub use word2vec::AggregationMethod;

pub use word2vec::OovStrategy;

pub use word2vec::Word2VecConfig;

pub use word2vec::Word2VecEmbeddingGenerator;

pub use word2vec::Word2VecFormat;

Modules

adaptive_compression

Adaptive compression techniques for vector data

adaptive_intelligent_caching

Adaptive Intelligent Caching System for OxiRS Vector Search

advanced_analytics

Advanced Analytics and Insights for Vector Search

advanced_benchmarking

Advanced Benchmarking Framework for Vector Search Systems

advanced_caching

Advanced multi-level caching system for vector embeddings and search results

advanced_metrics

Advanced distance and similarity metrics for vectors.

advanced_result_merging

Advanced Result Merging and Score Combination System

automl_optimization

AutoML for Embedding Optimization - Version 1.2 Feature

benchmarking

Comprehensive benchmarking framework for vector search systems

cache_friendly_index

Cache-friendly memory layouts for vector index

clustering

Advanced clustering algorithms for vector similarity and resource grouping

compaction

Online Index Compaction System

compression

content_processing

Advanced content processing for multiple document formats

crash_recovery

Crash recovery system with Write-Ahead Logging

cross_language_alignment

Cross-Language Vector Alignment - Version 1.2 Feature

cross_modal_embeddings

Cross-modal embeddings for multi-modal vector search

diskann

DiskANN - Disk-based Approximate Nearest Neighbor Search

distance_metrics

Extended distance metrics for vector similarity

distributed_vector_search

Distributed Vector Search - Version 1.1 Roadmap Feature

dynamic_index_selector

Dynamic index selection for optimal query performance

embedding_pipeline

embeddings

Embedding generation and management for RDF resources and text content

enhanced_performance_monitoring

Enhanced Performance Monitoring and Analytics System

faiss_compatibility

FAISS Compatibility Layer

faiss_gpu_integration

FAISS GPU Integration for Massive Performance Acceleration

faiss_integration

FAISS Integration for Advanced Vector Search

faiss_migration_tools

FAISS Migration Tools for Seamless Data Transfer

faiss_native_integration

Native FAISS Integration with Real Bindings

federated_search

Federated Vector Search - Advanced Multi-Organization Search

filtered_search

Filtered search capabilities for vector indices

gnn_embeddings

Graph Neural Network (GNN) embeddings for knowledge graphs

gpu

GPU acceleration for vector operations using CUDA

gpu_benchmarks

Comprehensive GPU vs CPU benchmarking for vector operations

graph_aware_search

Graph-aware vector search for named graph filtering and contextual search

graph_indices

Graph-based indices for efficient nearest neighbor search

hierarchical_similarity

Hierarchical Similarity Computation for Knowledge Graphs

hnsw

HNSW (Hierarchical Navigable Small World) implementation

huggingface

HuggingFace Transformers integration for embedding generation

hybrid_fusion

Hybrid search with dense + sparse vector fusion

hybrid_search

Hybrid search combining keyword and semantic vector search

index

Advanced vector indexing with HNSW and other efficient algorithms

ivf

Inverted File (IVF) index implementation for approximate nearest neighbor search

joint_embedding_spaces

Joint Embedding Spaces for Cross-Modal Vector Search

kg_embeddings

Knowledge Graph Embeddings for RDF data

learned_index

Learned vector indexes using neural networks

lsh

Locality Sensitive Hashing (LSH) for approximate nearest neighbor search

mmap_advanced

Advanced memory mapping features for large datasets

mmap_index

Memory-mapped vector index for efficient disk-based storage

multi_modal_search

This module provides a unified interface for multi-modal similarity search, supporting queries across different modalities (text, image, audio, video) with automatic alignment and fusion in a joint embedding space.

multi_tenancy

Multi-tenancy support for OxiRS vector search

nsg

NSG (Navigable Small World Graph) index

opq

Optimized Product Quantization (OPQ) implementation

oxirs_arq_integration

OxiRS ARQ Integration for Vector-Aware Query Optimization

performance_insights

Advanced Performance Insights and Monitoring for OxiRS Vector Search

persistence

Index persistence with compression

personalized_search

Personalized vector search with user-specific embeddings and preferences

pq

Product Quantization (PQ) for memory-efficient vector compression and search

python_bindings

PyO3 Python Bindings for OxiRS Vector Search

pytorch

PyTorch integration for embedding generation and neural network models

quantum_search

Quantum-inspired algorithms for vector search optimization.

query_planning

Query planning and cost estimation for vector search operations

query_rewriter

Query rewriting and optimization for vector search

random_utils

Random utility functions

rdf_content_enhancement

Enhanced RDF Content Processing with Entity and Relationship Embeddings

rdf_integration

RDF term support integration with oxirs-core

real_time_analytics

Real-time analytics and monitoring for vector search operations

real_time_embedding_pipeline

Real-time embedding pipeline module

real_time_updates

Real-time Vector Index Updates

reranking

Re-ranking with cross-encoders for improved search quality

result_fusion

Result fusion and score combination algorithms for merging vector search results

similarity

Advanced similarity algorithms and semantic matching for vectors

sparql_integration

SPARQL integration for vector search and hybrid symbolic-vector queries

sparql_service_endpoint

Advanced SPARQL Service Endpoint for Vector Operations

sparse

sq

Scalar Quantization (SQ) for efficient vector compression

storage_optimizations

Storage optimizations for vector indices

store_integration

Advanced Store Integration for Vector Search

structured_vectors

Structured vector types for enhanced vector representations.

tensorflow

TensorFlow integration for embedding generation and model serving

tiering

Hot/Warm/Cold Tiering System for Vector Indices

tree_indices

Tree-based indices for efficient nearest neighbor search

utils

Utility functions for vector operations

validation

Comprehensive data validation for vector operations

wal

Write-Ahead Logging (WAL) for crash recovery

word2vec

Word2Vec embedding integration for text content

Structs

DocumentBatchProcessor

Document batch processing utilities

MemoryVectorIndex

In-memory vector index implementation

SearchOptions

Advanced search options

Vector

Multi-precision vector with enhanced functionality

VectorOperationResult

Vector operation results with enhanced metadata

VectorStore

Enhanced vector store with embedding management and advanced features

VectorStoreConfig

Configuration for vector store

Enums

SearchQuery

Search query types

SearchType

Search operation types

VectorData

Vector data storage supporting multiple precisions

VectorError

Error types specific to vector operations

VectorPrecision

Precision types for vectors

Traits

VectorIndex

Vector index trait for efficient similarity search

VectorStoreTrait

Trait for vector store implementations

Type Aliases

BatchSearchResult

Batch search result type

VectorId

Vector identifier type