fix: use float32 RmsNorm for Metal GPU compatibility in Gemma embedding

Replace candle_transformers::quantized_nn::RmsNorm (which lacks a Metal
kernel) with candle_nn::RmsNorm throughout the Gemma embedding code.
QTensor weights are dequantized to f32 Tensor at load time so the
standard RmsNorm forward pass runs on Metal without error.

Also restores embeddinggemma as the default model (256-dim), replaces
eprint indexing progress with an indicatif progress bar, and fixes
store tests to match the new default dimension.

Author: devwhodevs

src/indexer.rs

@@ -5,6 +5,7 @@ use std::time::{Duration, Instant};
 use anyhow::{Context, Result, anyhow};
 use ignore::WalkBuilder;
 use sha2::{Digest, Sha256};
+use indicatif::{ProgressBar, ProgressStyle};
 use tracing::info;
 
 use crate::chunker::{chunk_markdown, split_oversized_chunks};
@@ -561,15 +562,22 @@ fn run_index_inner(
     let mut total_chunks = 0usize;
     let mut indexed_rel_paths: Vec<String> = Vec::new();
 
-    let total_files = file_contents.len();
+    let pb = ProgressBar::new(file_contents.len() as u64);
+    pb.set_style(
+        ProgressStyle::with_template("  [{bar:40.cyan/blue}] {pos}/{len} {msg} ({eta})")
+            .unwrap()
+            .progress_chars("=>-"),
+    );
+
     store.conn().execute_batch("BEGIN DEFERRED")?;
-    for (i, (rel_str, content, hash)) in file_contents.iter().enumerate() {
-        eprint!("\r  [{}/{}] {}", i + 1, total_files, rel_str);
+    for (rel_str, content, hash) in &file_contents {
+        pb.set_message(rel_str.clone());
         let result = index_file(rel_str, content, hash, store, embedder, vault_path, config)?;
         total_chunks += result.total_chunks;
         indexed_rel_paths.push(rel_str.clone());
+        pb.inc(1);
     }
-    eprintln!("\r  [{}/{}] done{}", total_files, total_files, " ".repeat(60));
+    pb.finish_with_message("done");
     store.commit()?;
 
     // Step 9: Build vault graph edges.

src/llm.rs

@@ -595,8 +595,8 @@ pub struct ModelDefaults {
 impl Default for ModelDefaults {
     fn default() -> Self {
         Self {
-            embed_uri: "hf:leliuga/all-MiniLM-L6-v2-GGUF/all-MiniLM-L6-v2.Q8_0.gguf".into(),
-            embed_dim: 384,
+            embed_uri: "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf".into(),
+            embed_dim: 256,
             rerank_uri: "hf:ggml-org/Qwen3-Reranker-0.6B-Q8_0-GGUF/qwen3-reranker-0.6b-q8_0.gguf"
                 .into(),
             expand_uri: "hf:Qwen/Qwen3-0.6B-GGUF/Qwen3-0.6B-Q8_0.gguf".into(),
@@ -630,12 +630,12 @@ struct EmbedLayer {
     attention_wk: CandleQMatMul,
     attention_wv: CandleQMatMul,
     attention_wo: CandleQMatMul,
-    attention_q_norm: candle_transformers::quantized_nn::RmsNorm,
-    attention_k_norm: candle_transformers::quantized_nn::RmsNorm,
-    attention_norm: candle_transformers::quantized_nn::RmsNorm,
-    post_attention_norm: candle_transformers::quantized_nn::RmsNorm,
-    ffn_norm: candle_transformers::quantized_nn::RmsNorm,
-    post_ffn_norm: candle_transformers::quantized_nn::RmsNorm,
+    attention_q_norm: candle_nn::RmsNorm,
+    attention_k_norm: candle_nn::RmsNorm,
+    attention_norm: candle_nn::RmsNorm,
+    post_attention_norm: candle_nn::RmsNorm,
+    ffn_norm: candle_nn::RmsNorm,
+    post_ffn_norm: candle_nn::RmsNorm,
     ffn_gate: CandleQMatMul,
     ffn_up: CandleQMatMul,
     ffn_down: CandleQMatMul,
@@ -804,7 +804,7 @@ enum EmbedModelVariant {
     Gemma {
         layers: Vec<EmbedLayer>,
         tok_embeddings: Embedding,
-        norm: candle_transformers::quantized_nn::RmsNorm,
+        norm: candle_nn::RmsNorm,
         embedding_length: usize,
     },
     Bert {
@@ -962,7 +962,7 @@ impl CandleEmbed {
     ) -> Result<(
         Vec<EmbedLayer>,
         Embedding,
-        candle_transformers::quantized_nn::RmsNorm,
+        candle_nn::RmsNorm,
         usize,
     )> {
         use candle_core::quantized::gguf_file;
@@ -1027,12 +1027,14 @@ impl CandleEmbed {
             .map_err(|e| anyhow::anyhow!("dequantizing token_embd: {e}"))?;
         let tok_embeddings = Embedding::new(tok_embd_deq, embedding_length);
 
-        // Final norm.
+        // Final norm (dequantize to f32 for Metal compatibility).
         let norm_qt = ct
             .tensor(&mut file, "output_norm.weight", device)
             .map_err(|e| anyhow::anyhow!("loading output_norm.weight: {e}"))?;
-        let norm = candle_transformers::quantized_nn::RmsNorm::from_qtensor(norm_qt, rms_norm_eps)
-            .map_err(|e| anyhow::anyhow!("creating RmsNorm: {e}"))?;
+        let norm_weight = norm_qt
+            .dequantize(device)
+            .map_err(|e| anyhow::anyhow!("dequantizing output_norm.weight: {e}"))?;
+        let norm = candle_nn::RmsNorm::new(norm_weight, rms_norm_eps);
 
         // Load transformer layers.
         let mut layers = Vec::with_capacity(block_count);
@@ -1051,15 +1053,17 @@ impl CandleEmbed {
                 }};
             }
 
-            // Helper: load a norm weight tensor as RmsNorm.
+            // Helper: load a norm weight tensor as RmsNorm (dequantize for Metal).
             macro_rules! load_norm {
                 ($name:expr) => {{
                     let full = format!("{}.{}", p, $name);
                     let qt = ct
                         .tensor(&mut file, &full, device)
                         .map_err(|e| anyhow::anyhow!("loading {full}: {e}"))?;
-                    candle_transformers::quantized_nn::RmsNorm::from_qtensor(qt, rms_norm_eps)
-                        .map_err(|e| anyhow::anyhow!("RmsNorm for {full}: {e}"))?
+                    let weight = qt
+                        .dequantize(device)
+                        .map_err(|e| anyhow::anyhow!("dequantizing {full}: {e}"))?;
+                    candle_nn::RmsNorm::new(weight, rms_norm_eps)
                 }};
             }
 
@@ -1991,10 +1995,10 @@ mod tests {
     fn test_model_defaults() {
         let defaults = ModelDefaults::default();
         assert!(defaults.embed_uri.starts_with("hf:"));
-        assert_eq!(defaults.embed_dim, 384);
+        assert_eq!(defaults.embed_dim, 256);
         assert!(
-            defaults.embed_uri.contains("all-MiniLM-L6-v2"),
-            "default embed model should be all-MiniLM-L6-v2-GGUF"
+            defaults.embed_uri.contains("embeddinggemma"),
+            "default embed model should be embeddinggemma"
         );
     }
 

src/store.rs

@@ -145,7 +145,7 @@ impl Store {
         let dim = self
             .get_meta("embedding_dim")?
             .and_then(|s| s.parse::<usize>().ok())
-            .unwrap_or(384);
+            .unwrap_or(256);
         crate::vecstore::init_vec_table(&self.conn, dim)?;
         self.migrate_vectors_to_vec0()?;
         Ok(())
@@ -2264,7 +2264,7 @@ mod tests {
     #[test]
     fn test_store_vec_roundtrip() {
         let store = Store::open_memory().unwrap();
-        let vector: Vec<f32> = (0..384).map(|i| (i as f32) / 384.0).collect();
+        let vector: Vec<f32> = (0..256).map(|i| (i as f32) / 256.0).collect();
         store.insert_vec(0, &vector).unwrap();
 
         let results = store
@@ -2282,7 +2282,7 @@ mod tests {
         let file_id = store
             .insert_file("test.md", "hash123", 0, &[], "abc123", None)
             .unwrap();
-        let vector: Vec<f32> = (0..384).map(|i| (i as f32) / 384.0).collect();
+        let vector: Vec<f32> = (0..256).map(|i| (i as f32) / 256.0).collect();
         store
             .insert_chunk_with_vector(file_id, "heading", "snippet", 0, 100, &vector)
             .unwrap();