fix(semantic_search): Update conditional compilation flags for embedders

Update conditional compilation flags to match the new embedding model selection logic:
- Replace target_env="musl" conditions with target_os conditions
- Update TextEmbedder trait implementation to use macOS/Windows condition
- Ensure consistent conditions across all files

🤖 Assisted by [Amazon Q Developer](https://aws.amazon.com/q/developer)

Author: kennvene-aws

Cargo.lock

@@ -28,21 +28,27 @@ tokio.workspace = true
 # Vector search library
 hnsw_rs = "0.3.1"
 
-# Candle dependencies for text embeddings (used on all platforms)
+# BM25 implementation - works on all platforms including ARM
+bm25 = { version = "2.2.1", features = ["language_detection"] }
+
+# Common dependencies for all platforms
+anyhow = "1.0"
+
+# Candle dependencies - not used on arm64
+[target.'cfg(not(target_arch = "aarch64"))'.dependencies]
 candle-core = { version = "0.9.1", features = [] }
 candle-nn = "0.9.1"
 candle-transformers = "0.9.1"
 tokenizers = "0.21.1"
 hf-hub = { version = "0.4.2", default-features = false, features = ["rustls-tls", "tokio", "ureq"] }
-anyhow = "1.0"
 
 # Conditionally enable Metal on macOS
-[target.'cfg(target_os = "macos")'.dependencies.candle-core]
+[target.'cfg(all(target_os = "macos", not(target_arch = "aarch64")))'.dependencies.candle-core]
 version = "0.9.1"
 features = []
 
 # Conditionally enable CUDA on Linux and Windows
-[target.'cfg(any(target_os = "linux", target_os = "windows"))'.dependencies.candle-core]
+[target.'cfg(all(any(target_os = "linux", target_os = "windows"), not(target_arch = "aarch64")))'.dependencies.candle-core]
 version = "0.9.1"
 features = []
 

crates/semantic_search_client/Cargo.toml

@@ -16,6 +16,7 @@ Rust library for managing semantic memory contexts with vector embeddings, enabl
 - **Progress Tracking**: Detailed progress reporting for long-running operations
 - **Parallel Processing**: Efficiently process large directories with parallel execution
 - **Memory Efficient**: Stream large files and directories without excessive memory usage
+- **Cross-Platform Compatibility**: Fallback mechanisms for all platforms and architectures
 
 ## Installation
 
@@ -74,6 +75,9 @@ cargo test
 
 To run tests with real embedders (which will download models), set the `MEMORY_BANK_USE_REAL_EMBEDDERS` environment variable:
 
+```bash
+MEMORY_BANK_USE_REAL_EMBEDDERS=1 cargo test
+```
 
 ## Core Concepts
 
@@ -96,10 +100,25 @@ Each context contains data points, which are individual pieces of text with asso
 
 ### Embeddings
 
-Text is converted to vector embeddings using state-of-the-art embedding models:
+Text is converted to vector embeddings using different backends based on platform and architecture:
+
+- **macOS/Windows**: Uses ONNX Runtime with FastEmbed by default
+- **Linux (non-ARM)**: Uses Candle for embeddings
+- **Linux (ARM64)**: Uses BM25 keyword-based embeddings as a fallback
+
+## Embedding Backends
 
-- **macOS/Windows**: Uses both ONNX Runtime with FastEmbed and Candle
-- **Linux**: Uses Candle for embeddings
+The library supports multiple embedding backends with automatic selection based on platform compatibility:
+
+1. **ONNX**: Fastest option, available on macOS and Windows
+2. **Candle**: Good performance, used on Linux (non-ARM)
+3. **BM25**: Fallback option based on keyword matching, used on Linux ARM64
+
+The default selection logic prioritizes performance where possible:
+- macOS/Windows: ONNX is the default
+- Linux (non-ARM): Candle is the default
+- Linux ARM64: BM25 is the default
+- ARM64: BM25 is the default
 
 ## Detailed Usage
 
@@ -216,17 +235,25 @@ client.remove_context_by_path("/path/to/indexed/directory", true)?;
 The library supports different embedding backends:
 
 ```rust
-// Use Candle (works on all platforms)
+// Use ONNX (fastest, used on macOS and Windows)
+#[cfg(any(target_os = "macos", target_os = "windows"))]
+let client = SemanticSearchClient::with_embedding_type(
+    "/path/to/storage",
+    EmbeddingType::Onnx,
+)?;
+
+// Use Candle (used on Linux non-ARM)
+#[cfg(all(target_os = "linux", not(target_arch = "aarch64")))]
 let client = SemanticSearchClient::with_embedding_type(
     "/path/to/storage",
     EmbeddingType::Candle,
 )?;
 
-// Use ONNX (macOS and Windows only)
-#[cfg(any(target_os = "macos", target_os = "windows"))]
+// Use BM25 (used on Linux ARM64)
+#[cfg(all(target_os = "linux", target_arch = "aarch64"))]
 let client = SemanticSearchClient::with_embedding_type(
     "/path/to/storage",
-    EmbeddingType::Onnx,
+    EmbeddingType::BM25,
 )?;
 ```
 
@@ -253,12 +280,14 @@ let client = SemanticSearchClient::new_with_default_dir()?;
 - **Disk Space**: Persistent contexts store both the original text and vector embeddings
 - **Embedding Speed**: The first embedding operation may be slower as models are loaded
 - **Hardware Acceleration**: On macOS, Metal is used for faster embedding generation
+- **Platform Differences**: Performance may vary based on the selected embedding backend
 
 ## Platform-Specific Features
 
-- **macOS**: Uses Metal for hardware-accelerated embeddings via Candle and ONNX Runtime
+- **macOS**: Uses Metal for hardware-accelerated embeddings via ONNX Runtime and Candle
 - **Windows**: Uses optimized CPU execution via ONNX Runtime and Candle
-- **Linux**: Uses Candle for embeddings with CPU optimization
+- **Linux (non-ARM)**: Uses Candle for embeddings
+- **Linux ARM64**: Uses BM25 keyword-based embeddings as a fallback
 
 ## Error Handling
 

crates/semantic_search_client/README.md

@@ -1,9 +1,11 @@
+#[cfg(not(target_arch = "aarch64"))]
+use crate::embedding::CandleTextEmbedder;
 #[cfg(test)]
 use crate::embedding::MockTextEmbedder;
 #[cfg(any(target_os = "macos", target_os = "windows"))]
 use crate::embedding::TextEmbedder;
 use crate::embedding::{
-    CandleTextEmbedder,
+    BM25TextEmbedder,
     EmbeddingType,
     TextEmbedderTrait,
 };
@@ -21,8 +23,10 @@ use crate::error::Result;
 #[cfg(any(target_os = "macos", target_os = "windows"))]
 pub fn create_embedder(embedding_type: EmbeddingType) -> Result<Box<dyn TextEmbedderTrait>> {
     let embedder: Box<dyn TextEmbedderTrait> = match embedding_type {
+        #[cfg(not(target_arch = "aarch64"))]
         EmbeddingType::Candle => Box::new(CandleTextEmbedder::new()?),
         EmbeddingType::Onnx => Box::new(TextEmbedder::new()?),
+        EmbeddingType::BM25 => Box::new(BM25TextEmbedder::new()?),
         #[cfg(test)]
         EmbeddingType::Mock => Box::new(MockTextEmbedder::new(384)),
     };
@@ -43,7 +47,9 @@ pub fn create_embedder(embedding_type: EmbeddingType) -> Result<Box<dyn TextEmbe
 #[cfg(not(any(target_os = "macos", target_os = "windows")))]
 pub fn create_embedder(embedding_type: EmbeddingType) -> Result<Box<dyn TextEmbedderTrait>> {
     let embedder: Box<dyn TextEmbedderTrait> = match embedding_type {
+        #[cfg(not(target_arch = "aarch64"))]
         EmbeddingType::Candle => Box::new(CandleTextEmbedder::new()?),
+        EmbeddingType::BM25 => Box::new(BM25TextEmbedder::new()?),
         #[cfg(test)]
         EmbeddingType::Mock => Box::new(MockTextEmbedder::new(384)),
     };

crates/semantic_search_client/src/client/embedder_factory.rs

@@ -108,11 +108,6 @@ impl SemanticSearchClient {
             // Continue with default config if initialization fails
         }
 
-        // Create the embedder using the factory
-        #[cfg(any(target_os = "macos", target_os = "windows"))]
-        let embedder = embedder_factory::create_embedder(embedding_type)?;
-
-        #[cfg(not(any(target_os = "macos", target_os = "windows")))]
         let embedder = embedder_factory::create_embedder(embedding_type)?;
 
         // Load metadata for persistent contexts

crates/semantic_search_client/src/client/implementation.rs

@@ -5,15 +5,18 @@
 
 use std::env;
 
+#[cfg(any(target_os = "macos", target_os = "windows"))]
+use crate::embedding::TextEmbedder;
+#[cfg(any(target_os = "macos", target_os = "windows"))]
+use crate::embedding::onnx_models::OnnxModelType;
 use crate::embedding::{
-    CandleTextEmbedder,
-    ModelType,
+    BM25TextEmbedder,
     run_standard_benchmark,
 };
-#[cfg(any(target_os = "macos", target_os = "windows"))]
+#[cfg(not(target_arch = "aarch64"))]
 use crate::embedding::{
-    TextEmbedder,
-    onnx_models::OnnxModelType,
+    CandleTextEmbedder,
+    ModelType,
 };
 
 /// Helper function to check if real embedder tests should be skipped
@@ -34,6 +37,7 @@ fn should_skip_real_embedder_tests() -> bool {
 }
 
 /// Run benchmark for a Candle model
+#[cfg(not(target_arch = "aarch64"))]
 fn benchmark_candle_model(model_type: ModelType) {
     match CandleTextEmbedder::with_model_type(model_type) {
         Ok(embedder) => {
@@ -76,6 +80,27 @@ fn benchmark_onnx_model(model_type: OnnxModelType) {
     }
 }
 
+/// Run benchmark for BM25 model
+fn benchmark_bm25_model() {
+    match BM25TextEmbedder::new() {
+        Ok(embedder) => {
+            println!("Benchmarking BM25 model");
+            let results = run_standard_benchmark(&embedder);
+            println!(
+                "Model: {}, Embedding dim: {}, Single time: {:?}, Batch time: {:?}, Avg per text: {:?}",
+                results.model_name,
+                results.embedding_dim,
+                results.single_time,
+                results.batch_time,
+                results.avg_time_per_text()
+            );
+        },
+        Err(e) => {
+            println!("Failed to load BM25 model: {}", e);
+        },
+    }
+}
+
 /// Standardized benchmark test for all embedding models
 #[test]
 fn test_standard_benchmark() {
@@ -86,11 +111,17 @@ fn test_standard_benchmark() {
     println!("Running standardized benchmark tests for embedding models");
     println!("--------------------------------------------------------");
 
-    // Benchmark Candle models
-    benchmark_candle_model(ModelType::MiniLML6V2);
-    benchmark_candle_model(ModelType::MiniLML12V2);
+    // Benchmark BM25 model (available on all platforms)
+    benchmark_bm25_model();
+
+    // Benchmark Candle models (not available on arm64)
+    #[cfg(not(target_arch = "aarch64"))]
+    {
+        benchmark_candle_model(ModelType::MiniLML6V2);
+        benchmark_candle_model(ModelType::MiniLML12V2);
+    }
 
-    // Benchmark ONNX models
+    // Benchmark ONNX models (available on macOS and Windows)
     #[cfg(any(target_os = "macos", target_os = "windows"))]
     {
         benchmark_onnx_model(OnnxModelType::MiniLML6V2Q);