Enhance logging and error handling in EmbeddingIndexer

- Added detailed logging for cache hits and misses in `get_index_info` to improve traceability during index retrieval.
- Implemented error logging for failed attempts to read index metadata and handle missing indices more gracefully.
- Introduced model variation attempts in the embedding search process to enhance robustness against configuration discrepancies.
- Updated `Cargo.toml` to include a new `strip` setting for build configuration.

Author: shisoft

Cargo.toml

@@ -103,4 +103,5 @@ debug = 2  # Full debug symbols
 opt-level = 3
 debug = true
 lto = true
-panic = 'unwind'
+panic = 'unwind'
+strip = "none"

src/apps/embedding/mod.rs

@@ -400,18 +400,34 @@ impl EmbeddingIndexer {
 
         // Check cache first
         if let Some(ptr_ref) = self.index_cache.as_ref().get(&key) {
+            eprintln!("[get_index_info] Cache hit for schema={}, field={}, model={}", schema_id, field_id, model);
             return Ok(ptr_ref.clone());
         }
 
         // Load from storage
         let index_id = embedding_index_id(schema_id, field_id, model);
+        eprintln!(
+            "[get_index_info] Cache miss, loading from storage: schema={}, field={}, model={}, index_id={:?}",
+            schema_id, field_id, model, index_id
+        );
+
         let index_cell = self
             .morph
             .neb_client
             .read_cell(index_id)
             .await
-            .map_err(|e| format!("Failed to read index metadata: {:?}", e))?
-            .map_err(|e| format!("Index not found: {:?}", e))?;
+            .map_err(|e| {
+                let err = format!("Failed to read index metadata: {:?}", e);
+                eprintln!("[get_index_info] ERROR: {}", err);
+                err
+            })?
+            .map_err(|e| {
+                let err = format!("Index not found: {:?}", e);
+                eprintln!("[get_index_info] ERROR: {}", err);
+                err
+            })?;
+
+        eprintln!("[get_index_info] Successfully loaded index metadata from storage");
 
         let emb_schema_id = index_cell[EMB_SCHEMA_ID]
             .u32()
@@ -674,15 +690,23 @@ impl EmbeddingIndexerCore for EmbeddingIndexer {
     ) -> BoxFuture<'_, Result<Vec<EmbeddingHit>, IndexError>> {
         let query = query.to_string();
         async move {
+            eprintln!(
+                "[Embedding search] schema={}, field={}, default_provider={}, default_model={}",
+                schema_id, field_id, self.default_provider, self.default_model
+            );
+
             // Find the index for this (schema, field)
             // If multiple models exist, we need to pick one
             // For now, use the first one found or default
             let (model, emb_schema_id) = {
                 let models_key = (schema_id, field_id);
                 let model_name =
                     if let Some(models_list) = self.index_models.as_ref().get(&models_key) {
-                        models_list.read().first().cloned()
+                        let m = models_list.read().first().cloned();
+                        eprintln!("[Embedding search] Found in index_models: {:?}", m);
+                        m
                     } else {
+                        eprintln!("[Embedding search] NOT in index_models, will try default");
                         None
                     };
 
@@ -692,17 +716,61 @@ impl EmbeddingIndexerCore for EmbeddingIndexer {
                         if let Some(ptr_ref) = self.index_cache.as_ref().get(&key) {
                             (model, ptr_ref.clone().0)
                         } else {
-                            return Err(IndexError::Other(format!(
-                                "No embedding index found for schema {} field {}",
-                                schema_id, field_id
-                            )));
+                            // Model in index_models but not in cache - lazy load from storage
+                            match self.get_index_info(schema_id, field_id, &model).await {
+                                Ok((emb_schema_id, _)) => (model, emb_schema_id),
+                                Err(_) => {
+                                    return Err(IndexError::Other(format!(
+                                        "No embedding index found for schema {} field {} (model: {})",
+                                        schema_id, field_id, model
+                                    )));
+                                }
+                            }
                         }
                     }
                     None => {
-                        return Err(IndexError::Other(format!(
-                            "No embedding index found for schema {} field {}",
-                            schema_id, field_id
-                        )));
+                        // Cache miss - try to lazy-load from storage
+                        // Try multiple common model variations to handle recovery when
+                        // the server was started with different embedding config than during import
+                        let (provider_name, model_name) = (self.default_provider.clone(), self.default_model.clone());
+                        let default_full = Self::full_model_name(&provider_name, &model_name);
+
+                        // Common model variations to try (order matters - try default first)
+                        let model_variations = vec![
+                            default_full.clone(),                          // Current default (e.g., "gguf:nomic-embed-text-v1.5")
+                            "ollama:nomic-embed-text".to_string(),         // Ollama variant
+                            "gguf:multilingual-e5-base".to_string(),       // Old default GGUF
+                            "e5:multilingual-e5-base".to_string(),         // E5 variant
+                        ];
+
+                        eprintln!("[Embedding search] Trying model variations: {:?}", model_variations);
+
+                        let mut found_model = None;
+                        for model_to_try in &model_variations {
+                            eprintln!("[Embedding search] Attempting: {}", model_to_try);
+                            match self.get_index_info(schema_id, field_id, model_to_try).await {
+                                Ok((emb_schema_id, _)) => {
+                                    eprintln!("[Embedding search] SUCCESS with model: {}", model_to_try);
+                                    found_model = Some((model_to_try.clone(), emb_schema_id));
+                                    break;
+                                }
+                                Err(e) => {
+                                    eprintln!("[Embedding search] Failed with {}: {}", model_to_try, e);
+                                    continue;
+                                }
+                            }
+                        }
+
+                        // Return result or error
+                        match found_model {
+                            Some((model, emb_schema_id)) => (model, emb_schema_id),
+                            None => {
+                                return Err(IndexError::Other(format!(
+                                    "No embedding index found for schema {} field {} (tried: {:?})",
+                                    schema_id, field_id, model_variations
+                                )));
+                            }
+                        }
                     }
                 }
             };

src/apps/wikidata/schema.rs

@@ -93,7 +93,7 @@ pub fn create_entity_metadata_schema() -> Schema {
             Type::String,
             vec![IndexType::Fulltext, IndexType::Embedding(embedding_model)],
         ),
-        // Field::new_indexed("description", Type::String, vec![IndexType::Fulltext]),
+        //Field::new_indexed("description", Type::String, vec![IndexType::Fulltext]),
         Field::new_indexed_array("aliases", Type::String, vec![IndexType::Fulltext]),
         Field::new_unindexed_nullable("sitelinks", Type::String), // Optional: JSON string
         Field::new_unindexed_nullable("other_data", Type::String), // Optional: JSON string