✨ Model services that connect to ModelEngine model enablement

Author: Phinease

backend/agents/create_agent_info.py

@@ -44,7 +44,8 @@ async def create_model_config_list(tenant_id):
                                 model_name=record["model_name"],
                             ),
                         url=record["base_url"],
-                        ssl_verify=record.get("ssl_verify", True)))
+                        ssl_verify=record.get("ssl_verify", True),
+                        model_factory=record.get("model_factory")))
     # 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)
@@ -54,14 +55,16 @@ async def create_model_config_list(tenant_id):
                     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", ""),
-                    ssl_verify=main_model_config.get("ssl_verify", True)))
+                    ssl_verify=main_model_config.get("ssl_verify", True),
+                    model_factory=main_model_config.get("model_factory")))
     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", ""),
-                    ssl_verify=main_model_config.get("ssl_verify", True)))
+                    ssl_verify=main_model_config.get("ssl_verify", True),
+                    model_factory=main_model_config.get("model_factory")))
 
     return model_list
 

backend/services/conversation_management_service.py

@@ -268,7 +268,9 @@ def call_llm_for_title(content: str, tenant_id: str, language: str = LANGUAGE["Z
         api_base=model_config.get("base_url", ""),
         api_key=model_config.get("api_key", ""),
         temperature=0.7,
-        top_p=0.95
+        top_p=0.95,
+        model_factory=model_config.get("model_factory", None),
+        ssl_verify=model_config.get("ssl_verify", True)
     )
 
     # Build messages
@@ -280,6 +282,10 @@ def call_llm_for_title(content: str, tenant_id: str, language: str = LANGUAGE["Z
                 {"role": MESSAGE_ROLE["USER"],
                  "content": user_prompt}]
 
+    # ModelEngine 只接受 role/content 的简单结构，确保提前扁平化
+    if model_config.get("model_factory", "").lower() == "modelengine":
+        messages = [{"role": msg["role"], "content": str(msg.get("content", ""))} for msg in messages]
+
     # Call the model
     response = llm.generate(messages)
     if not response or not response.content or not response.content.strip():

backend/services/file_management_service.py

@@ -192,6 +192,7 @@ def get_llm_model(tenant_id: str):
         model_id=get_model_name_from_config(main_model_config),
         api_base=main_model_config.get("base_url"),
         api_key=main_model_config.get("api_key"),
-        max_context_tokens=main_model_config.get("max_tokens")
+        max_context_tokens=main_model_config.get("max_tokens"),
+        ssl_verify=main_model_config.get("ssl_verify", True),
     )
     return long_text_to_text_model

backend/services/image_service.py

@@ -42,5 +42,6 @@ def get_vlm_model(tenant_id: str):
                 temperature=0.7,
                 top_p=0.7,
                 frequency_penalty=0.5,
-                max_tokens=512
+                max_tokens=512,
+                ssl_verify=vlm_model_config.get("ssl_verify", True),
             )

backend/services/model_health_service.py

@@ -17,15 +17,17 @@ async def _embedding_dimension_check(
     model_name: str,
     model_type: str,
     model_base_url: str,
-    model_api_key: str
+    model_api_key: str,
+    ssl_verify: bool = True,
 ):
     # Test connectivity based on different model types
     if model_type == "embedding":
         embedding = await OpenAICompatibleEmbedding(
             model_name=model_name,
             base_url=model_base_url,
             api_key=model_api_key,
-            embedding_dim=0
+            embedding_dim=0,
+            ssl_verify=ssl_verify,
         ).dimension_check()
         if len(embedding) > 0:
             return len(embedding[0])
@@ -37,7 +39,8 @@ async def _embedding_dimension_check(
             model_name=model_name,
             base_url=model_base_url,
             api_key=model_api_key,
-            embedding_dim=0
+            embedding_dim=0,
+            ssl_verify=ssl_verify,
         ).dimension_check()
         if len(embedding) > 0:
             return len(embedding[0])
@@ -78,14 +81,16 @@ async def _perform_connectivity_check(
             model_name=model_name,
             base_url=model_base_url,
             api_key=model_api_key,
-            embedding_dim=0
+            embedding_dim=0,
+            ssl_verify=ssl_verify
         ).dimension_check()) > 0
     elif model_type == "multi_embedding":
         connectivity = len(await JinaEmbedding(
             model_name=model_name,
             base_url=model_base_url,
             api_key=model_api_key,
-            embedding_dim=0
+            embedding_dim=0,
+            ssl_verify=ssl_verify
         ).dimension_check()) > 0
     elif model_type == "llm":
         observer = MessageObserver()
@@ -104,7 +109,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 in ["tts", "stt"]:
         voice_service = get_voice_service()
@@ -227,8 +233,9 @@ async def embedding_dimension_check(model_config: dict):
     model_api_key = model_config["api_key"]
 
     try:
+        ssl_verify = model_config.get("ssl_verify", True)
         dimension = await _embedding_dimension_check(
-            model_name, model_type, model_base_url, model_api_key
+            model_name, model_type, model_base_url, model_api_key, ssl_verify
         )
         return dimension
     except ValueError as e:

backend/services/model_provider_service.py

@@ -77,10 +77,10 @@ class ModelEngineProvider(AbstractModelProvider):
     async def get_models(self, provider_config: Dict) -> List[Dict]:
         """
         Fetch models from ModelEngine API.
-        
+
         Args:
             provider_config: Configuration dict containing model_type
-            
+
         Returns:
             List of models with canonical fields
         """
@@ -111,19 +111,19 @@ async def get_models(self, provider_config: Dict) -> List[Dict]:
                 "asr": "stt",
                 "tts": "tts",
                 "rerank": "rerank",
-                "vlm": "vlm",
+                "multimodal": "vlm",
             }
 
             # Filter models by type if specified
             filtered_models = []
             for model in all_models:
                 me_type = model.get("type", "")
                 internal_type = type_map.get(me_type)
-                
+
                 # If model_type filter is provided, only include matching models
                 if model_type and internal_type != model_type:
                     continue
-                
+
                 if internal_type:
                     filtered_models.append({
                         "id": model.get("id", ""),

backend/services/vectordatabase_service.py

@@ -204,9 +204,21 @@ def get_embedding_model(tenant_id: str):
 
     if model_type == "embedding":
         # Get the es core
-        return OpenAICompatibleEmbedding(api_key=model_config.get("api_key", ""), base_url=model_config.get("base_url", ""), model_name=get_model_name_from_config(model_config) or "", embedding_dim=model_config.get("max_tokens", 1024))
+        return OpenAICompatibleEmbedding(
+            api_key=model_config.get("api_key", ""),
+            base_url=model_config.get("base_url", ""),
+            model_name=get_model_name_from_config(model_config) or "",
+            embedding_dim=model_config.get("max_tokens", 1024),
+            ssl_verify=model_config.get("ssl_verify", True),
+        )
     elif model_type == "multi_embedding":
-        return JinaEmbedding(api_key=model_config.get("api_key", ""), base_url=model_config.get("base_url", ""), model_name=get_model_name_from_config(model_config) or "", embedding_dim=model_config.get("max_tokens", 1024))
+        return JinaEmbedding(
+            api_key=model_config.get("api_key", ""),
+            base_url=model_config.get("base_url", ""),
+            model_name=get_model_name_from_config(model_config) or "",
+            embedding_dim=model_config.get("max_tokens", 1024),
+            ssl_verify=model_config.get("ssl_verify", True),
+        )
     else:
         return None
 
@@ -997,7 +1009,7 @@ async def summary_index_name(self,
                                  ):
         """
         Generate a summary for the specified index using advanced Map-Reduce approach
-        
+
         New implementation:
         1. Get documents and cluster them by semantic similarity
         2. Map: Summarize each document individually
@@ -1019,17 +1031,17 @@ async def summary_index_name(self,
         try:
             if not tenant_id:
                 raise Exception("Tenant ID is required for summary generation.")
-            
+
             from utils.document_vector_utils import (
                 process_documents_for_clustering,
                 kmeans_cluster_documents,
                 summarize_clusters_map_reduce,
                 merge_cluster_summaries
             )
-            
+
             # Use new Map-Reduce approach
             sample_count = min(batch_size // 5, 200)  # Sample reasonable number of documents
-            
+
             # Define a helper function to run all blocking operations in a thread pool
             def _generate_summary_sync():
                 """Synchronous function that performs all blocking operations"""
@@ -1039,13 +1051,13 @@ def _generate_summary_sync():
                     vdb_core=vdb_core,
                     sample_doc_count=sample_count
                 )
-                
+
                 if not document_samples:
                     raise Exception("No documents found in index.")
-                
+
                 # Step 2: Cluster documents (CPU-intensive operation)
                 clusters = kmeans_cluster_documents(doc_embeddings, k=None)
-                
+
                 # Step 3: Map-Reduce summarization (contains blocking LLM calls)
                 cluster_summaries = summarize_clusters_map_reduce(
                     document_samples=document_samples,
@@ -1056,11 +1068,11 @@ def _generate_summary_sync():
                     model_id=model_id,
                     tenant_id=tenant_id
                 )
-                
+
                 # Step 4: Merge into final summary
                 final_summary = merge_cluster_summaries(cluster_summaries)
                 return final_summary
-            
+
             # Run blocking operations in a thread pool to avoid blocking the event loop
             # Use get_running_loop() for better compatibility with modern asyncio
             try:
@@ -1069,7 +1081,7 @@ def _generate_summary_sync():
                 # Fallback for edge cases
                 loop = asyncio.get_event_loop()
             final_summary = await loop.run_in_executor(None, _generate_summary_sync)
-            
+
             # Stream the result
             async def generate_summary():
                 try:
@@ -1080,12 +1092,12 @@ async def generate_summary():
                     yield "data: {\"status\": \"completed\"}\n\n"
                 except Exception as e:
                     yield f"data: {{\"status\": \"error\", \"message\": \"{e}\"}}\n\n"
-            
+
             return StreamingResponse(
                 generate_summary(),
                 media_type="text/event-stream"
             )
-            
+
         except Exception as e:
             logger.error(f"Knowledge base summary generation failed: {str(e)}", exc_info=True)
             raise Exception(f"Failed to generate summary: {str(e)}")

backend/utils/attachment_utils.py

@@ -34,7 +34,8 @@ def convert_image_to_text(query: str, image_input: Union[str, BinaryIO], tenant_
         temperature=0.7,
         top_p=0.7,
         frequency_penalty=0.5,
-        max_tokens=512
+        max_tokens=512,
+        ssl_verify=vlm_model_config.get("ssl_verify", True),
     )
 
     # Load prompts from yaml file
@@ -65,7 +66,8 @@ def convert_long_text_to_text(query: str, file_context: str, tenant_id: str, lan
         model_id=get_model_name_from_config(main_model_config),
         api_base=main_model_config.get("base_url"),
         api_key=main_model_config.get("api_key"),
-        max_context_tokens=main_model_config.get("max_tokens")
+        max_context_tokens=main_model_config.get("max_tokens"),
+        ssl_verify=main_model_config.get("ssl_verify", True),
     )
 
     # Load prompts from yaml file

backend/utils/llm_utils.py

@@ -71,6 +71,8 @@ def call_llm_for_system_prompt(
         api_key=llm_model_config.get("api_key", "") if llm_model_config else "",
         temperature=0.3,
         top_p=0.95,
+        model_factory=llm_model_config.get("model_factory") if llm_model_config else None,
+        ssl_verify=llm_model_config.get("ssl_verify", True) if llm_model_config else True,
     )
     messages = [
         {"role": MESSAGE_ROLE["SYSTEM"], "content": system_prompt},
@@ -108,15 +110,15 @@ def call_llm_for_system_prompt(
                     token_join,
                     callback,
                 )
-        
+
         result = "".join(token_join)
         if not result and content_tokens_seen > 0:
             logger.warning(
                 "Generated prompt is empty but %d content tokens were processed. "
                 "This suggests all content was filtered out.",
                 content_tokens_seen
             )
-        
+
         return result
     except Exception as exc:
         logger.error("Failed to generate prompt from LLM: %s", str(exc))

backend/utils/str_utils.py

@@ -5,4 +5,4 @@ def remove_think_blocks(text: str) -> str:
     """Remove <think>...</think> blocks including inner content."""
     if not text:
         return text
-    return re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL | re.IGNORECASE)
+    return re.sub(r"(?:<think>)?.*?</think>", "", text, flags=re.DOTALL | re.IGNORECASE)