🐛 Bugfix: Batch add dashscope embedding model failed to calculate embedding dimension (#3172)

* ✨ Support preview epub, html, json and xml files
✨ Now support add multimodal embedding models from qwen dashscope

* 🐛 Bugfix: Batch add dashscope embedding model failed to calculate embedding dimension

* 🧪 Add test files

Author: Jasonxia007

backend/services/model_health_service.py

@@ -3,7 +3,7 @@
 
 from nexent.core import MessageObserver
 from nexent.core.models import OpenAIModel, OpenAIVLModel
-from nexent.core.models.embedding_model import JinaEmbedding, OpenAICompatibleEmbedding
+from nexent.core.models.embedding_model import JinaEmbedding, OpenAICompatibleEmbedding, DashScopeMultimodalEmbedding
 from nexent.monitor import set_monitoring_context, set_monitoring_operation
 from nexent.core.models.rerank_model import OpenAICompatibleRerank
 
@@ -20,12 +20,33 @@
 PROVIDER_CATALOG_HEALTHCHECK_FACTORIES = {DASHSCOPE_MODEL_FACTORY, TOKENPONY_MODEL_FACTORY}
 PROVIDER_CATALOG_HEALTHCHECK_TYPES = {"vlm", "vlm2", "vlm3"}
 
+EMBEDDING_TYPES = {"embedding", "multi_embedding"}
 
-def _mask_secret(value: Optional[str]) -> str:
-    """Mask a secret value, showing only first and last 4 characters."""
-    if not value or len(value) <= 8:
-        return "***"
-    return value[:4] + "****" + value[-4:]
+
+def _normalize_embedding_url(base_url: str) -> str:
+    """Append /embeddings suffix to base_url if not already present.
+
+    For embedding and multimodal embedding models, the base_url should contain /embeddings.
+    If the user provides a base URL without the endpoint (e.g., https://api.jina.ai/v1),
+    this function normalizes it to include /embeddings (e.g., https://api.jina.ai/v1/embeddings).
+    """
+    if not base_url or "/embeddings" in base_url:
+        return base_url
+    return f"{base_url.rstrip('/')}/embeddings"
+
+
+def _infer_model_factory(model_type: str, base_url: str, current_factory: Optional[str] = None) -> Optional[str]:
+    """Infer model_factory from base_url if not already set or is generic.
+
+    Currently handles:
+    - multi_embedding with dashscope URL -> "dashscope"
+    - embedding with dashscope URL -> "dashscope" (uses OpenAI-compatible endpoint)
+    """
+    base_url_lower = base_url.lower()
+    if "dashscope" in base_url_lower:
+        return DASHSCOPE_MODEL_FACTORY
+
+    return current_factory
 
 
 async def _embedding_dimension_check(
@@ -34,36 +55,51 @@ async def _embedding_dimension_check(
     model_base_url: str,
     model_api_key: str,
     ssl_verify: bool = True,
+    model_factory: Optional[str] = None,
     timeout_seconds: Optional[float] = None,
 ):
-    # Test connectivity based on different model types
+    if model_type in EMBEDDING_TYPES:
+        model_base_url = _normalize_embedding_url(model_base_url)
+
+    effective_timeout = timeout_seconds if timeout_seconds else 5.0
+
     if model_type == "embedding":
+        # DashScope text embedding models use OpenAI-compatible endpoint, same as generic
         embedding = await OpenAICompatibleEmbedding(
             model_name=model_name,
             base_url=model_base_url,
             api_key=model_api_key,
             embedding_dim=0,
             ssl_verify=ssl_verify,
-            timeout_seconds=timeout_seconds,
-        ).dimension_check()
+        ).dimension_check(timeout=effective_timeout)
         if len(embedding) > 0:
             return len(embedding[0])
         logging.warning(
             f"Embedding dimension check for {model_name} gets empty response")
         return 0
     elif model_type == "multi_embedding":
-        embedding = await JinaEmbedding(
-            model_name=model_name,
-            base_url=model_base_url,
-            api_key=model_api_key,
-            embedding_dim=0,
-            ssl_verify=ssl_verify,
-            timeout_seconds=timeout_seconds,
-        ).dimension_check()
-        if len(embedding) > 0:
+        model_factory_lower = (model_factory or "").lower()
+        if model_factory_lower == "dashscope":
+            embedding_instance = DashScopeMultimodalEmbedding(
+                api_key=model_api_key,
+                base_url=model_base_url,
+                model_name=model_name,
+                embedding_dim=0,
+                ssl_verify=ssl_verify,
+            )
+        else:
+            embedding_instance = JinaEmbedding(
+                api_key=model_api_key,
+                base_url=model_base_url,
+                model_name=model_name,
+                embedding_dim=0,
+                ssl_verify=ssl_verify,
+            )
+        embedding = await embedding_instance.dimension_check(timeout=effective_timeout)
+        if isinstance(embedding, list) and len(embedding) > 0 and isinstance(embedding[0], list):
             return len(embedding[0])
         logging.warning(
-            f"Embedding dimension check for {model_name} gets empty response")
+            f"Embedding dimension check for {model_name} gets unexpected response: {type(embedding)}, value: {embedding}")
         return 0
     else:
         raise ValueError(f"Unsupported model type: {model_type}")
@@ -123,27 +159,42 @@ async def _perform_connectivity_check(
         model_base_url = model_base_url.replace(
             LOCALHOST_NAME, DOCKER_INTERNAL_HOST).replace(LOCALHOST_IP, DOCKER_INTERNAL_HOST)
 
+    # Normalize embedding URLs by appending /embeddings if not present
+    if model_type in EMBEDDING_TYPES:
+        model_base_url = _normalize_embedding_url(model_base_url)
+
+    effective_timeout = timeout_seconds if timeout_seconds else 5.0
     connectivity: bool
 
-    # Test connectivity based on different model types
     if model_type == "embedding":
-        embedding = OpenAICompatibleEmbedding(
+        emb = await OpenAICompatibleEmbedding(
             model_name=model_name,
             base_url=model_base_url,
             api_key=model_api_key,
             embedding_dim=0,
             ssl_verify=ssl_verify,
-        )
-        connectivity = len(await embedding.dimension_check(timeout=timeout_seconds if timeout_seconds else 5.0)) > 0
+        ).dimension_check(timeout=effective_timeout)
+        connectivity = len(emb) > 0 and len(emb[0]) > 0
     elif model_type == "multi_embedding":
-        embedding = JinaEmbedding(
-            model_name=model_name,
-            base_url=model_base_url,
-            api_key=model_api_key,
-            embedding_dim=0,
-            ssl_verify=ssl_verify,
-        )
-        connectivity = len(await embedding.dimension_check(timeout=timeout_seconds if timeout_seconds else 5.0)) > 0
+        model_factory_lower = (model_factory or "").lower()
+        if model_factory_lower == "dashscope":
+            embedding = DashScopeMultimodalEmbedding(
+                api_key=model_api_key,
+                base_url=model_base_url,
+                model_name=model_name,
+                embedding_dim=0,
+                ssl_verify=ssl_verify,
+            )
+        else:
+            embedding = JinaEmbedding(
+                api_key=model_api_key,
+                base_url=model_base_url,
+                model_name=model_name,
+                embedding_dim=0,
+                ssl_verify=ssl_verify,
+            )
+        emb = await embedding.dimension_check(timeout=effective_timeout)
+        connectivity = len(emb) > 0 and len(emb[0]) > 0
     elif model_type == "llm":
         observer = MessageObserver()
         set_monitoring_operation("connectivity_check",
@@ -335,6 +386,9 @@ async def verify_model_config_connectivity(model_config: dict):
         # Get timeout from model config if present
         timeout_seconds = model_config.get("timeout_seconds")
 
+        # Infer model_factory from base_url when not provided
+        model_factory = _infer_model_factory(model_type, model_base_url, model_config.get("model_factory"))
+
         try:
             connectivity = await _perform_connectivity_check(
                 model_name, model_type, model_base_url, model_api_key, ssl_verify,
@@ -385,22 +439,26 @@ async def embedding_dimension_check(model_config: dict):
 
     try:
         ssl_verify = model_config.get("ssl_verify", True)
+        model_factory = _infer_model_factory(model_type, model_base_url, model_config.get("model_factory"))
         timeout_seconds = model_config.get("timeout_seconds")
         dimension = await _embedding_dimension_check(
             model_name, model_type, model_base_url, model_api_key, ssl_verify,
-            timeout_seconds=timeout_seconds
+            model_factory=model_factory, timeout_seconds=timeout_seconds
         )
         # Fallback to ssl_verify=False if initial check fails
         if dimension == 0 and ssl_verify:
             dimension = await _embedding_dimension_check(
                 model_name, model_type, model_base_url, model_api_key, False,
-                timeout_seconds=timeout_seconds
+                model_factory=model_factory, timeout_seconds=timeout_seconds
             )
+        if dimension == 0:
+            logger.error(f"Embedding dimension check returned 0 for model: {model_name}")
+            return None
         return dimension
     except ValueError as e:
-        logger.error(f"Error checking embedding dimension: {str(e)}")
-        return 0
+        logger.error(f"Error checking embedding dimension for {model_name}: {str(e)}")
+        return None
     except Exception as e:
         logger.error(
-            f"Error checking embedding dimension: {model_name};  Error: {str(e)}")
-        return 0
+            f"Error checking embedding dimension for {model_name}: {str(e)}")
+        return None

backend/services/model_management_service.py

@@ -19,7 +19,7 @@
     merge_existing_model_attributes,
     get_provider_models,
 )
-from services.model_health_service import embedding_dimension_check
+from services.model_health_service import embedding_dimension_check, _infer_model_factory
 from utils.model_name_utils import (
     add_repo_to_name,
     split_repo_name,
@@ -101,9 +101,23 @@ async def create_model_for_tenant(user_id: str, tenant_id: str, model_data: Dict
                 raise ValueError(
                     f"Name {model_data['display_name']} is already in use, please choose another display name")
 
-        # If embedding or multi_embedding, set max_tokens via embedding dimension check
+        # If embedding or multi_embedding, ensure base_url ends with /embeddings
         if model_data.get("model_type") in ("embedding", "multi_embedding"):
-            model_data["max_tokens"] = await embedding_dimension_check(model_data)
+            base_url = model_data.get("base_url", "")
+            if base_url and "/embeddings" not in base_url:
+                model_data["base_url"] = f"{base_url.rstrip('/')}/embeddings"
+            # Infer model_factory from base_url if not set
+            model_data["model_factory"] = _infer_model_factory(
+                model_data["model_type"], model_data["base_url"], model_data.get("model_factory")
+            )
+            # Get embedding dimension
+            dimension = await embedding_dimension_check(model_data)
+            if dimension is None:
+                raise ValueError(
+                    f"Failed to get embedding dimension for model '{model_data.get('display_name', model_data.get('model_name'))}'. "
+                    "Please verify the URL, API key, and network connection."
+                )
+            model_data["max_tokens"] = dimension
             # Set default chunk_batch if not provided
             if model_data.get("chunk_batch") is None:
                 model_data["chunk_batch"] = 10

backend/services/model_provider_service.py

@@ -127,13 +127,15 @@ async def prepare_model_dict(provider: str, model: dict, model_url: str, model_a
     # Determine the correct base_url and, for embeddings, update the actual
     # dimension by performing a real connectivity check.
     if model["model_type"] in ["embedding", "multi_embedding"]:
-        if provider != ProviderEnum.MODELENGINE.value:
-            # Ensure proper slash between base URL and endpoint
+        if provider == ProviderEnum.DASHSCOPE.value and model["model_type"] == "embedding":
             model_dict["base_url"] = f"{model_url.rstrip('/')}/embeddings"
-        else:
-            # For ModelEngine embedding models, append the embeddings path
+        elif provider == ProviderEnum.MODELENGINE.value:
             model_dict["base_url"] = f"{model_url.rstrip('/')}/{MODEL_ENGINE_NORTH_PREFIX}/embeddings"
-        # The embedding dimension might differ from the provided max_tokens.
+        elif "/embeddings" in model_url:
+            # URL already contains /embeddings endpoint, use as-is
+            model_dict["base_url"] = model_url.rstrip('/')
+        else:
+            model_dict["base_url"] = f"{model_url.rstrip('/')}/embeddings"
         model_dict["max_tokens"] = await embedding_dimension_check(model_dict)
     elif model["model_type"] == "rerank":
         if provider == ProviderEnum.DASHSCOPE.value:

backend/services/vectordatabase_service.py

@@ -20,7 +20,7 @@
 
 from fastapi import Body, Depends, Path, Query
 from fastapi.responses import StreamingResponse
-from nexent.core.models.embedding_model import OpenAICompatibleEmbedding, JinaEmbedding, BaseEmbedding
+from nexent.core.models.embedding_model import OpenAICompatibleEmbedding, JinaEmbedding, DashScopeMultimodalEmbedding, BaseEmbedding
 from nexent.core.models.rerank_model import OpenAICompatibleRerank, BaseRerank
 from nexent.vector_database.base import VectorDatabaseCore
 from nexent.vector_database.elasticsearch_core import ElasticSearchCore
@@ -335,6 +335,9 @@ def _create_embedding_model(model: dict) -> Any:
         "ssl_verify": model_config.get("ssl_verify", True),
     }
     if model.get("model_type", "embedding") == "multi_embedding":
+        model_factory = model.get("model_factory", "").lower()
+        if model_factory == "dashscope":
+            return DashScopeMultimodalEmbedding(**common_kwargs)
         return JinaEmbedding(**common_kwargs)
     return OpenAICompatibleEmbedding(**common_kwargs)