⭐️ ModelEngine Models Interrogation

Author: Phinease

backend/agents/create_agent_info.py

@@ -43,7 +43,8 @@ async def create_model_config_list(tenant_id):
                                 model_repo=record["model_repo"],
                                 model_name=record["model_name"],
                             ),
-                        url=record["base_url"]))
+                        url=record["base_url"],
+                        ssl_verify=record.get("ssl_verify", True)))
     # fit for old version, main_model and sub_model use default model
     main_model_config = tenant_config_manager.get_model_config(
         key=MODEL_CONFIG_MAPPING["llm"], tenant_id=tenant_id)
@@ -52,13 +53,15 @@ async def create_model_config_list(tenant_id):
                     api_key=main_model_config.get("api_key", ""),
                     model_name=get_model_name_from_config(main_model_config) if main_model_config.get(
                         "model_name") else "",
-                    url=main_model_config.get("base_url", "")))
+                    url=main_model_config.get("base_url", ""),
+                    ssl_verify=main_model_config.get("ssl_verify", True)))
     model_list.append(
         ModelConfig(cite_name="sub_model",
                     api_key=main_model_config.get("api_key", ""),
                     model_name=get_model_name_from_config(main_model_config) if main_model_config.get(
                         "model_name") else "",
-                    url=main_model_config.get("base_url", "")))
+                    url=main_model_config.get("base_url", ""),
+                    ssl_verify=main_model_config.get("ssl_verify", True)))
 
     return model_list
 

backend/apps/me_model_managment_app.py

@@ -4,81 +4,44 @@
 from fastapi import APIRouter, Query, HTTPException
 from fastapi.responses import JSONResponse
 
-from consts.exceptions import TimeoutException, NotFoundException, MEConnectionException
-from services.me_model_management_service import get_me_models_impl, check_me_variable_set
-from services.model_health_service import check_me_connectivity_impl
+from consts.exceptions import MEConnectionException, TimeoutException
+from services.me_model_management_service import check_me_variable_set, check_me_connectivity
 
 router = APIRouter(prefix="/me")
 
 
-@router.get("/model/list")
-async def get_me_models(
-        type: str = Query(
-            default="", description="Model type: embed/chat/rerank"),
-        timeout: int = Query(
-            default=2, description="Request timeout in seconds")
-):
-    """
-    Get list of models from model engine API
-    """
-    try:
-        # Pre-check ME environment variables; return empty list if not configured
-        if not await check_me_variable_set():
-            return JSONResponse(
-                status_code=HTTPStatus.OK,
-                content={
-                    "message": "Retrieve skipped",
-                    "data": []
-                }
-            )
-        filtered_result = await get_me_models_impl(timeout=timeout, type=type)
-        return JSONResponse(
-            status_code=HTTPStatus.OK,
-            content={
-                "message": "Successfully retrieved",
-                "data": filtered_result
-            }
-        )
-    except TimeoutException as e:
-        logging.error(f"Request me model timeout: {str(e)}")
-        raise HTTPException(status_code=HTTPStatus.REQUEST_TIMEOUT, detail="Failed to get ModelEngine model list: timeout")
-    except NotFoundException as e:
-        logging.error(f"Request me model not found: {str(e)}")
-        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="ModelEngine model not found")
-    except Exception as e:
-        logging.error(f"Failed to get me model list: {str(e)}")
-        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Failed to get ModelEngine model list")
-
-
 @router.get("/healthcheck")
-async def check_me_connectivity(timeout: int = Query(default=2, description="Timeout in seconds")):
+async def check_me_health(timeout: int = Query(default=30, description="Timeout in seconds")):
     """
-    Health check from model engine API
+    Health check for ModelEngine platform by actually calling the API.
+    Returns connectivity status based on actual API response.
     """
     try:
-        # Pre-check ME environment variables; return not connected if not configured
+        # First check if environment variables are configured
         if not await check_me_variable_set():
             return JSONResponse(
                 status_code=HTTPStatus.OK,
                 content={
                     "connectivity": False,
-                    "message": "ModelEngine platform necessary environment variables not configured. Healthcheck skipped.",
+                    "message": "ModelEngine platform environment variables not configured. Healthcheck skipped.",
                 }
             )
-        await check_me_connectivity_impl(timeout)
+        
+        # Then check actual connectivity
+        await check_me_connectivity(timeout)
         return JSONResponse(
             status_code=HTTPStatus.OK,
             content={
                 "connectivity": True,
-                "message": "ModelEngine platform connect successfully.",
+                "message": "ModelEngine platform connected successfully.",
             }
         )
     except MEConnectionException as e:
-        logging.error(f"ModelEngine model healthcheck failed: {str(e)}")
-        raise HTTPException(status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail="ModelEngine model connect failed.")
+        logging.error(f"ModelEngine healthcheck failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail=f"ModelEngine connection failed: {str(e)}")
     except TimeoutException as e:
-        logging.error(f"ModelEngine model healthcheck timeout: {str(e)}")
-        raise HTTPException(status_code=HTTPStatus.REQUEST_TIMEOUT, detail="ModelEngine model connect timeout.")
+        logging.error(f"ModelEngine healthcheck timeout: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.REQUEST_TIMEOUT, detail="ModelEngine connection timeout.")
     except Exception as e:
-        logging.error(f"ModelEngine model healthcheck failed with unknown error: {str(e)}.")
-        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="ModelEngine model connect failed.")
+        logging.error(f"ModelEngine healthcheck failed with unknown error: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=f"ModelEngine healthcheck failed: {str(e)}")

backend/consts/provider.py

@@ -5,8 +5,12 @@ class ProviderEnum(str, Enum):
     """Supported model providers"""
     SILICON = "silicon"
     OPENAI = "openai"
+    MODELENGINE = "modelengine"
 
 
 # Silicon Flow
 SILICON_BASE_URL = "https://api.siliconflow.cn/v1/"
 SILICON_GET_URL = "https://api.siliconflow.cn/v1/models"
+
+# ModelEngine
+# Base URL and API key are loaded from environment variables at runtime

backend/database/db_models.py

@@ -160,6 +160,8 @@ class ModelRecord(TableBase):
         Integer, doc="Expected chunk size for embedding models, used during document chunking")
     maximum_chunk_size = Column(
         Integer, doc="Maximum chunk size for embedding models, used during document chunking")
+    ssl_verify = Column(
+        Boolean, default=True, doc="Whether to verify SSL certificates when connecting to this model API. Default is true. Set to false for local services without SSL support.")
 
 
 class ToolInfo(TableBase):

backend/database/model_management_db.py

@@ -252,3 +252,25 @@ def get_models_by_tenant_factory_type(tenant_id: str, model_factory: str, model_
         "model_type": model_type
     }
     return get_model_records(filters, tenant_id)
+
+
+def get_model_by_name_factory(model_name: str, model_factory: str, tenant_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Get a model record by model_name and model_factory for deduplication.
+    
+    Args:
+        model_name: Model name (e.g., "deepseek-r1-distill-qwen-14b")
+        model_factory: Model factory (e.g., "ModelEngine")
+        tenant_id: Tenant ID
+        
+    Returns:
+        Optional[Dict[str, Any]]: Model record if found, None otherwise
+    """
+    filters = {
+        'model_name': model_name,
+        'model_factory': model_factory
+    }
+    records = get_model_records(filters, tenant_id)
+    return records[0] if records else None
+
+

backend/services/conversation_management_service.py

@@ -263,8 +263,13 @@ def call_llm_for_title(content: str, tenant_id: str, language: str = LANGUAGE["Z
         key=MODEL_CONFIG_MAPPING["llm"], tenant_id=tenant_id)
 
     # Create OpenAIServerModel instance
-    llm = OpenAIServerModel(model_id=get_model_name_from_config(model_config) if model_config.get("model_name") else "", api_base=model_config.get("base_url", ""),
-                            api_key=model_config.get("api_key", ""), temperature=0.7, top_p=0.95)
+    llm = OpenAIServerModel(
+        model_id=get_model_name_from_config(model_config) if model_config.get("model_name") else "",
+        api_base=model_config.get("base_url", ""),
+        api_key=model_config.get("api_key", ""),
+        temperature=0.7,
+        top_p=0.95
+    )
 
     # Build messages
     user_prompt = Template(prompt_template["USER_PROMPT"], undefined=StrictUndefined).render({

backend/services/me_model_management_service.py

@@ -1,61 +1,55 @@
-import asyncio
-from typing import List
-
 import aiohttp
+import asyncio
 
 from consts.const import MODEL_ENGINE_APIKEY, MODEL_ENGINE_HOST
-from consts.exceptions import TimeoutException, NotFoundException
+from consts.exceptions import MEConnectionException, TimeoutException
+
+
+async def check_me_variable_set() -> bool:
+    """
+    Check if the ME environment variables are correctly set.
+    Returns:
+        bool: True if both MODEL_ENGINE_APIKEY and MODEL_ENGINE_HOST are set and non-empty, False otherwise.
+    """
+    return bool(MODEL_ENGINE_APIKEY and MODEL_ENGINE_HOST)
 
 
-async def get_me_models_impl(timeout: int = 2, type: str = "") -> List:
+async def check_me_connectivity(timeout: int = 30) -> bool:
     """
-    Fetches a list of models from the model engine API with response formatting.
-    Parameters:
-        timeout (int): The total timeout for the request in seconds.
-        type (str): The type of model to filter for. If empty, returns all models.
+    Check ModelEngine connectivity by actually calling the API.
+    
+    Args:
+        timeout: Request timeout in seconds
+        
     Returns:
-        - filtered_result: List of model data dictionaries
+        bool: True if connection successful, False otherwise
+        
+    Raises:
+        MEConnectionException: If connection failed with specific error
+        TimeoutException: If request timed out
     """
+    if not await check_me_variable_set():
+        return False
+    
     try:
-        headers = {
-            'Authorization': f'Bearer {MODEL_ENGINE_APIKEY}',
-        }
+        headers = {"Authorization": f"Bearer {MODEL_ENGINE_APIKEY}"}
+
         async with aiohttp.ClientSession(
-                timeout=aiohttp.ClientTimeout(total=timeout),
-                connector=aiohttp.TCPConnector(ssl=False)
+            timeout=aiohttp.ClientTimeout(total=timeout),
+            connector=aiohttp.TCPConnector(ssl=False)
         ) as session:
             async with session.get(
-                    f"{MODEL_ENGINE_HOST}/open/router/v1/models",
-                    headers=headers
+                f"{MODEL_ENGINE_HOST}/open/router/v1/models",
+                headers=headers
             ) as response:
-                response.raise_for_status()
-                result_data = await response.json()
-                result: list = result_data['data']
-
-        # Type filtering
-        filtered_result = []
-        if type:
-            for data in result:
-                if data['type'] == type:
-                    filtered_result.append(data)
-            if not filtered_result:
-                result_types = set(data['type'] for data in result)
-                raise NotFoundException(
-                    f"No models found with type '{type}'. Available types: {result_types}.")
-        else:
-            filtered_result = result
-
-        return filtered_result
+                if response.status == 200:
+                    return True
+                else:
+                    raise MEConnectionException(
+                        f"Connection failed, error code: {response.status}")
     except asyncio.TimeoutError:
-        raise TimeoutException("Request timeout.")
+        raise TimeoutException("Connection timed out")
+    except MEConnectionException:
+        raise
     except Exception as e:
-        raise Exception(f"Failed to get model list: {str(e)}.")
-
-
-async def check_me_variable_set() -> bool:
-    """
-    Check if the ME environment variables are correctly set.
-    Returns:
-        bool: True if both MODEL_ENGINE_APIKEY and MODEL_ENGINE_HOST are set and non-empty, False otherwise.
-    """
-    return bool(MODEL_ENGINE_APIKEY and MODEL_ENGINE_HOST)
+        raise Exception(f"Unknown error occurred: {str(e)}")

backend/services/model_health_service.py

@@ -1,15 +1,11 @@
-import asyncio
 import logging
-import aiohttp
-from http import HTTPStatus
 
 from nexent.core import MessageObserver
 from nexent.core.models import OpenAIModel, OpenAIVLModel
 from nexent.core.models.embedding_model import JinaEmbedding, OpenAICompatibleEmbedding
 
 from services.voice_service import get_voice_service
-from consts.const import MODEL_ENGINE_APIKEY, MODEL_ENGINE_HOST, LOCALHOST_IP, LOCALHOST_NAME, DOCKER_INTERNAL_HOST
-from consts.exceptions import MEConnectionException, TimeoutException
+from consts.const import LOCALHOST_IP, LOCALHOST_NAME, DOCKER_INTERNAL_HOST
 from consts.model import ModelConnectStatusEnum
 from database.model_management_db import get_model_by_display_name, update_model_record
 from utils.config_utils import get_model_name_from_config
@@ -57,6 +53,7 @@ async def _perform_connectivity_check(
     model_type: str,
     model_base_url: str,
     model_api_key: str,
+    ssl_verify: bool = True,
 ) -> bool:
     """
     Perform specific model connectivity check
@@ -65,6 +62,7 @@ async def _perform_connectivity_check(
         model_type: Model type
         model_base_url: Model base URL
         model_api_key: API key
+        ssl_verify: Whether to verify SSL certificates (default: True)
     Returns:
         bool: Connectivity check result
     """
@@ -95,7 +93,8 @@ async def _perform_connectivity_check(
             observer,
             model_id=model_name,
             api_base=model_base_url,
-            api_key=model_api_key
+            api_key=model_api_key,
+            ssl_verify=ssl_verify
         ).check_connectivity()
     elif model_type == "rerank":
         connectivity = False
@@ -135,11 +134,12 @@ async def check_model_connectivity(display_name: str, tenant_id: str) -> dict:
         model_type = model["model_type"]
         model_base_url = model["base_url"]
         model_api_key = model["api_key"]
+        ssl_verify = model.get("ssl_verify", True)  # Default to True if not present
 
         try:
             # Use the common connectivity check function
             connectivity = await _perform_connectivity_check(
-                model_name, model_type, model_base_url, model_api_key
+                model_name, model_type, model_base_url, model_api_key, ssl_verify
             )
         except Exception as e:
             update_data = {"connect_status": ModelConnectStatusEnum.UNAVAILABLE.value}
@@ -167,32 +167,6 @@ async def check_model_connectivity(display_name: str, tenant_id: str) -> dict:
         raise e
 
 
-async def check_me_connectivity_impl(timeout: int):
-    """
-    Check ME connectivity and return structured response data
-    Args:
-        timeout: Request timeout in seconds
-    """
-    try:
-        headers = {'Authorization': f'Bearer {MODEL_ENGINE_APIKEY}'}
-
-        async with aiohttp.ClientSession(
-                timeout=aiohttp.ClientTimeout(total=timeout),
-                connector=aiohttp.TCPConnector(ssl=False)
-        ) as session:
-            async with session.get(
-                    f"{MODEL_ENGINE_HOST}/open/router/v1/models",
-                    headers=headers
-            ) as response:
-                if response.status == HTTPStatus.OK:
-                    return
-                else:
-                    raise MEConnectionException(
-                        f"Connection failed, error code: {response.status}")
-    except asyncio.TimeoutError:
-        raise TimeoutException("Connection timed out")
-    except Exception as e:
-        raise Exception(f"Unknown error occurred: {str(e)}")
 
 
 async def verify_model_config_connectivity(model_config: dict):
@@ -208,11 +182,12 @@ async def verify_model_config_connectivity(model_config: dict):
         model_type = model_config["model_type"]
         model_base_url = model_config["base_url"]
         model_api_key = model_config["api_key"]
+        ssl_verify = model_config.get("ssl_verify", True)  # Default to True if not present
 
         try:
             # Use the common connectivity check function
             connectivity = await _perform_connectivity_check(
-                model_name, model_type, model_base_url, model_api_key
+                model_name, model_type, model_base_url, model_api_key, ssl_verify
             )
 
             if not connectivity: