feat: add compound embedding search coverage

Use a compound aliases+description embedding index for Wikidata semantic search, add a compound embedding test and large-scale HNSW quality test, and tighten recovery script result expectations.

Author: shisoft

scripts/test_wikidata_import_recovery.sh

@@ -424,7 +424,6 @@ EOF
             # Extract the result count
             local result_line
             result_line=$(echo "$output" | grep "Semantic search results" | head -1)
-            echo -e "${GREEN}  ✓ Query: '$query'${NC}"
             echo "    $result_line"
 
             # Show debug info if available
@@ -468,8 +467,13 @@ EOF
                 echo "    ... and $((result_count - 3)) more results"
             fi
             echo ""
-            
-            successful_queries=$((successful_queries + 1))
+
+            if [[ $result_count -ge 6 ]]; then
+                echo -e "${GREEN}  ✓ Query: '$query' (>= 6 results)${NC}"
+                successful_queries=$((successful_queries + 1))
+            else
+                echo -e "${YELLOW}  ~ Query: '$query' - Only $result_count results (expected >= 6)${NC}"
+            fi
 
         elif echo "$output" | grep -qi "embedding.*not.*initialized\|index.*not.*found"; then
             echo -e "${RED}  ✗ Query: '$query' - Embedding index not available${NC}"

src/apps/embedding/tests.rs

@@ -1295,6 +1295,234 @@ mod schema_based_tests {
         println!("=== Multi-Index Schema Test PASSED ===");
     }
 
+    /// Test compound embedding index (e.g., aliases + description in Wikidata)
+    #[tokio::test]
+    #[ignore]
+    async fn test_compound_embedding_index() {
+        let _ = env_logger::try_init();
+
+        println!("=== Compound Embedding Index Test ===\n");
+
+        const SCIENTIST_SCHEMA_ID: u32 = 10004;
+        const ID_FIELD: &str = "id";
+        const NAME_FIELD: &str = "name";
+        const ALIASES_FIELD: &str = "aliases";
+        const DESCRIPTION_FIELD: &str = "description";
+        const COMPOUND_NAME: &str = "aliases_description";
+        let compound_field_id = bifrost_hasher::hash_str(COMPOUND_NAME);
+
+        fn scientist_schema() -> Schema {
+            let embedding_model = EmbeddingModel::new("gguf:nomic-embed-text-v1.5");
+            let fields = vec![
+                Field::new_unindexed(ID_FIELD, Type::String),
+                Field::new_unindexed(NAME_FIELD, Type::String),
+                Field::new_unindexed_array(ALIASES_FIELD, Type::String),
+                Field::new_unindexed(DESCRIPTION_FIELD, Type::String),
+            ];
+            let mut schema = Schema::new_with_id(
+                SCIENTIST_SCHEMA_ID,
+                "test_scientist",
+                None,
+                Field::new_schema(fields),
+                false,
+                false,
+            );
+            schema.add_compound_index(
+                COMPOUND_NAME,
+                vec![ALIASES_FIELD.to_string(), DESCRIPTION_FIELD.to_string()],
+                vec![IndexType::Embedding(embedding_model)],
+            );
+            schema
+        }
+
+        let server = start_server(6014, "compound_embedding_test")
+            .await
+            .unwrap();
+        let _partition = server.init_hnsw_index_partition_service().await.unwrap();
+        let _hnsw = server.init_hnsw_index_service().await.unwrap();
+        crate::server::MorpheusServer::init_embedding_service(&server)
+            .await
+            .unwrap();
+
+        let embedding_client = &server
+            .neb_server
+            .indexer
+            .as_ref()
+            .unwrap()
+            .clients
+            .embedding_client;
+
+        if !embedding_client.is_embedding_index_core_set() {
+            eprintln!("✗ Embedding core not set, skipping test");
+            return;
+        }
+
+        server
+            .neb_client
+            .new_schema_with_id(scientist_schema())
+            .await
+            .unwrap()
+            .unwrap();
+        println!("✓ Scientist schema with compound embedding registered (index auto-created)");
+
+        let scientists = vec![
+            (
+                "Albert Einstein",
+                vec!["Einstein", "Albert", "theoretical physicist"],
+                "developed the theory of relativity and contributed to quantum mechanics",
+            ),
+            (
+                "Isaac Newton",
+                vec!["Newton", "Isaac", "mathematician", "physicist"],
+                "formulated laws of motion and universal gravitation",
+            ),
+            (
+                "Marie Curie",
+                vec!["Curie", "Marie", "Skłodowska", "physicist", "chemist"],
+                "pioneering research on radioactivity and discovered polonium and radium",
+            ),
+        ];
+
+        let mut scientist_ids: Vec<(Id, &str)> = Vec::new();
+
+        println!("\nWriting scientists...");
+        for (name, aliases, description) in &scientists {
+            let id = Id::rand();
+            let mut map = OwnedMap::new();
+            map.insert(ID_FIELD, OwnedValue::String(name.to_string()));
+            map.insert(NAME_FIELD, OwnedValue::String(name.to_string()));
+            map.insert(
+                ALIASES_FIELD,
+                OwnedValue::PrimArray(dovahkiin::types::OwnedPrimArray::String(
+                    aliases.iter().map(|s| s.to_string()).collect(),
+                )),
+            );
+            map.insert(
+                DESCRIPTION_FIELD,
+                OwnedValue::String(description.to_string()),
+            );
+
+            let cell = OwnedCell::new_with_id(SCIENTIST_SCHEMA_ID, &id, OwnedValue::Map(map));
+            server.neb_client.write_cell(cell).await.unwrap().unwrap();
+
+            println!("  ✓ {} written", name);
+            scientist_ids.push((id, name));
+        }
+
+        tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
+
+        println!("\n=== Testing Compound Index Search ===\n");
+
+        let query1 = "physicist relativity";
+        println!("Query: \"{}\"", query1);
+        let results1 = embedding_client
+            .search(SCIENTIST_SCHEMA_ID, compound_field_id, query1, 3)
+            .await
+            .unwrap();
+
+        println!("Results:");
+        for (i, hit) in results1.iter().enumerate() {
+            let name = scientist_ids
+                .iter()
+                .find(|(id, _)| *id == hit.id)
+                .map(|(_, n)| *n)
+                .unwrap_or("unknown");
+            println!("  {}. {} (score: {:.4})", i + 1, name, hit.score);
+        }
+
+        let einstein_id = scientist_ids
+            .iter()
+            .find(|(_, n)| n.contains("Einstein"))
+            .unwrap()
+            .0;
+        assert_eq!(
+            results1[0].id, einstein_id,
+            "Einstein should be top for relativity query"
+        );
+        println!("✓ Correct: Einstein is top result\n");
+
+        let query2 = "mathematician gravity";
+        println!("Query: \"{}\"", query2);
+        let results2 = embedding_client
+            .search(SCIENTIST_SCHEMA_ID, compound_field_id, query2, 3)
+            .await
+            .unwrap();
+
+        println!("Results:");
+        for (i, hit) in results2.iter().enumerate() {
+            let name = scientist_ids
+                .iter()
+                .find(|(id, _)| *id == hit.id)
+                .map(|(_, n)| *n)
+                .unwrap_or("unknown");
+            println!("  {}. {} (score: {:.4})", i + 1, name, hit.score);
+        }
+
+        let newton_id = scientist_ids
+            .iter()
+            .find(|(_, n)| n.contains("Newton"))
+            .unwrap()
+            .0;
+        assert_eq!(
+            results2[0].id, newton_id,
+            "Newton should be top for gravity query"
+        );
+        println!("✓ Correct: Newton is top result\n");
+
+        let query3 = "chemist radioactivity";
+        println!("Query: \"{}\"", query3);
+        let results3 = embedding_client
+            .search(SCIENTIST_SCHEMA_ID, compound_field_id, query3, 3)
+            .await
+            .unwrap();
+
+        println!("Results:");
+        for (i, hit) in results3.iter().enumerate() {
+            let name = scientist_ids
+                .iter()
+                .find(|(id, _)| *id == hit.id)
+                .map(|(_, n)| *n)
+                .unwrap_or("unknown");
+            println!("  {}. {} (score: {:.4})", i + 1, name, hit.score);
+        }
+
+        let curie_id = scientist_ids
+            .iter()
+            .find(|(_, n)| n.contains("Curie"))
+            .unwrap()
+            .0;
+        assert_eq!(
+            results3[0].id, curie_id,
+            "Curie should be top for radioactivity query"
+        );
+        println!("✓ Correct: Curie is top result\n");
+
+        println!("=== Testing Alias Contribution ===");
+        let query_alias = "Skłodowska";
+        println!("Query (alias only): \"{}\"", query_alias);
+        let results_alias = embedding_client
+            .search(SCIENTIST_SCHEMA_ID, compound_field_id, query_alias, 3)
+            .await
+            .unwrap();
+
+        println!("Results:");
+        for (i, hit) in results_alias.iter().enumerate() {
+            let name = scientist_ids
+                .iter()
+                .find(|(id, _)| *id == hit.id)
+                .map(|(_, n)| *n)
+                .unwrap_or("unknown");
+            println!("  {}. {} (score: {:.4})", i + 1, name, hit.score);
+        }
+        assert_eq!(
+            results_alias[0].id, curie_id,
+            "Curie should match her maiden name Skłodowska"
+        );
+        println!("✓ Correct: Alias contributes to matching\n");
+
+        println!("=== Compound Embedding Index Test PASSED ===");
+    }
+
     /// Test embedding on array fields (like the aliases field in Wikidata)
     #[tokio::test]
     #[ignore]