✨config ModelEngine Service

Author: Zhi-a

backend/consts/const.py

@@ -18,8 +18,7 @@ class VectorDatabaseType(str, Enum):
 MODEL_ENGINE_HOST = ""
 # ModelEngine Configuration
 MODEL_ENGINE_ENABLED = os.getenv("MODEL_ENGINE_ENABLED", "false").lower() == "true"
-if MODEL_ENGINE_ENABLED:
-    MODEL_ENGINE_HOST = os.getenv('MODEL_ENGINE_HOST')
+MODEL_ENGINE_HOST = os.getenv('MODEL_ENGINE_HOST') or ""
 MODEL_ENGINE_API_KEY = os.getenv("MODEL_ENGINE_API_KEY") or ""
 
 

doc/docs/zh/opensource-memorial-wall.md

@@ -632,6 +632,19 @@ Nexent开发者加油
 开放原子大赛接触到了Nexent平台，祝越来越好！
 :::
 
-::: hongmuxiangxun - 2025-12-19
+::: info hongmuxiangxun - 2025-12-19
 开放原子大赛接触到了Nexent平台，祝越来越好，越来越容易上手。
 :::
+
+::: info jinmo - 2025-12-25
+无意中接触了Nexent平台，喜欢它的风格，祝它能被更多人知晓。
+:::
+
+::: tip 开源新手 - 2025-12-25
+感谢 Nexent 让我踏上了开源之旅！这个项目的文档真的很棒，帮助我快速上手，希望 Nexent 越来越好！
+:::
+
+::: info 1-xiaozheng-1 - 2025-12-25
+从modelengine中看到Nexent，发现这个平台创建智能体简直一绝，希望越来越好。
+:::
+

docker/.env.example

@@ -70,8 +70,9 @@ REDIS_URL=redis://redis:6379/0
 REDIS_BACKEND_URL=redis://redis:6379/1
 
 # Model Engine Config
-MODEL_ENGINE_HOST=https://localhost:30555
-MODEL_ENGINE_APIKEY=
+MODEL_ENGINE_ENABLED=true
+MODEL_ENGINE_HOST=""
+MODEL_ENGINE_API_KEY=""
 
 # Supabase Config
 DASHBOARD_USERNAME=supabase

frontend/services/modelSyncService.ts

@@ -0,0 +1,77 @@
+import { modelService } from "./modelService";
+import { ModelType } from "@/types/modelConfig";
+
+const TYPES_TO_SYNC: ModelType[] = [
+  ("llm" as unknown) as ModelType,
+  ("embedding" as unknown) as ModelType,
+  ("multi_embedding" as unknown) as ModelType,
+  ("vlm" as unknown) as ModelType,
+  ("tts" as unknown) as ModelType,
+  ("stt" as unknown) as ModelType,
+];
+
+/**
+ * Sync models from ModelEngine and verify connectivity.
+ * Returns an object with overall success and per-model verification results.
+ */
+export async function syncModelEngine(apiKey: string) {
+  let syncFailed = false;
+  try {
+    for (const type of TYPES_TO_SYNC) {
+      try {
+        const providerModels = await modelService.addProviderModel({
+          provider: "modelengine",
+          type: type as any,
+          apiKey,
+        });
+        if (providerModels && providerModels.length > 0) {
+          await modelService.addBatchCustomModel({
+            api_key: apiKey,
+            provider: "modelengine",
+            type,
+            models: providerModels,
+          });
+        }
+      } catch (err) {
+        // mark that at least one provider fetch failed
+        syncFailed = true;
+      }
+    }
+
+    // reload all models from backend
+    const allModelsAfter = await modelService.getAllModels();
+    const modelEngineModels = allModelsAfter.filter((m) => m.source === "modelengine");
+
+    // update persisted api keys for modelengine models if needed
+    if (modelEngineModels.length > 0 && apiKey) {
+      const updates = modelEngineModels.map((m) => ({
+        model_id: String(m.id || m.name || m.displayName),
+        apiKey: apiKey,
+      }));
+      try {
+        await modelService.updateBatchModel(updates);
+      } catch (err) {
+        // non-fatal; continue to verification but flag sync failure
+        syncFailed = true;
+      }
+    }
+
+    // verify each persistent model and collect results
+    const verificationResults: Array<{ displayName: string; type: string; connected: boolean }> = [];
+    for (const m of modelEngineModels) {
+      if (!m.displayName) continue;
+      try {
+        const connected = await modelService.verifyCustomModel(m.displayName);
+        verificationResults.push({ displayName: m.displayName, type: m.type, connected });
+      } catch (err) {
+        verificationResults.push({ displayName: m.displayName, type: m.type, connected: false });
+      }
+    }
+
+    const anyUnavailable = verificationResults.some((r) => !r.connected);
+    const success = !syncFailed && !anyUnavailable;
+    return { success, verificationResults, error: syncFailed ? "provider_fetch_failed" : undefined };
+  } catch (err: any) {
+    return { success: false, verificationResults: [], error: err?.message || String(err) };
+  }
+}

test/backend/services/test_config_sync_service.py

@@ -925,3 +925,85 @@ def side_effect(config_key, tenant_id=None):
         service_mocks['logger'].warning.assert_called_with(
             "Failed to get config for EMBEDDING_ID: Database timeout"
         )
+
+
+@pytest.mark.asyncio
+async def test_save_config_impl_persist_model_engine_key_failure(service_mocks):
+    """When persisting MODEL_ENGINE_API_KEY fails, a warning should be logged but function should continue."""
+    config = MagicMock()
+    # Provide a simple config dict that includes modelengine apiKey
+    config.model_dump.return_value = {"app": {}, "models": {}, "modelengine": {"apiKey": "me-key"}}
+
+    tenant_id = "test_tenant_id"
+    user_id = "test_user_id"
+
+    # tenant_config_manager.load_config should return something reasonable
+    service_mocks['tenant_config_manager'].load_config.return_value = {}
+
+    # Make set_single_config raise when persisting MODEL_ENGINE_API_KEY
+    service_mocks['tenant_config_manager'].set_single_config.side_effect = Exception("persist failed")
+
+    # Execute
+    result = await save_config_impl(config, tenant_id, user_id)
+
+    # Function should not raise; it should log a warning
+    assert result is None
+    service_mocks['logger'].warning.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_save_config_impl_modelengine_deletion_paths(service_mocks):
+    """When MODEL_ENGINE_API_KEY is empty, deletion logic should attempt to remove records and handle failures."""
+    config = MagicMock()
+    # modelengine apiKey empty -> triggers deletion flow
+    config.model_dump.return_value = {"app": {}, "models": {}, "modelengine": {"apiKey": ""}}
+
+    tenant_id = "test_tenant_id"
+    user_id = "test_user_id"
+
+    # tenant config load
+    service_mocks['tenant_config_manager'].load_config.return_value = {}
+
+    # Case A: get_model_records returns models where one has no id (should be skipped) and one has id which delete_model_record will raise on
+    from backend.services import config_sync_service
+
+    async def _run_case_a():
+        with patch('backend.services.config_sync_service.get_model_records', return_value=[{"model_id": None}, {"model_id": "7"}]), \
+             patch('backend.services.config_sync_service.delete_model_record', side_effect=Exception("delete failed")):
+            res = await save_config_impl(config, tenant_id, user_id)
+            assert res is None
+            # A warning should be logged for the failed delete
+            service_mocks['logger'].warning.assert_called()
+
+    await _run_case_a()
+
+    # Case B: get_model_records itself raises -> should be caught and logged
+    async def _run_case_b():
+        with patch('backend.services.config_sync_service.get_model_records', side_effect=Exception("query failed")):
+            res = await save_config_impl(config, tenant_id, user_id)
+            assert res is None
+            service_mocks['logger'].warning.assert_called()
+
+    await _run_case_b()
+
+
+def test_build_model_config_embedding_direct(service_mocks):
+    """Direct test of build_model_config to ensure embedding dimension is included when model_type contains 'embedding'."""
+    from backend.services.config_sync_service import build_model_config
+
+    model_config = {
+        "display_name": "Emb",
+        "model_type": "embedding",
+        "max_tokens": 2048,
+        "base_url": "http://test",
+        "api_key": "k"
+    }
+
+    # get_model_name_from_config is patched by service_mocks fixture; ensure it returns a value
+    service_mocks['get_model_name'].return_value = "emb-name"
+
+    result = build_model_config(model_config)
+    assert result["displayName"] == "Emb"
+    assert result["name"] == "emb-name"
+    # dimension should be set when 'embedding' in model_type
+    assert result.get("dimension") == 2048

test/backend/services/test_model_provider_service.py

@@ -770,6 +770,21 @@ async def test_modelengine_get_models_no_env_config():
         assert result == []
 
 
+@pytest.mark.asyncio
+async def test_modelengine_get_models_disabled_flag_logs_and_returns_empty():
+    """If MODEL_ENGINE_ENABLED is False, provider should log an info message and return empty list."""
+    from backend.services.model_provider_service import ModelEngineProvider
+
+    provider_config = {"model_type": "llm", "api_key": "test-key"}
+
+    with mock.patch("backend.services.model_provider_service.MODEL_ENGINE_ENABLED", False), \
+         mock.patch("backend.services.model_provider_service.logger") as mock_logger:
+
+        result = await ModelEngineProvider().get_models(provider_config)
+
+        assert result == []
+        mock_logger.info.assert_called_once_with("ModelEngine integration is disabled via environment configuration")
+
 @pytest.mark.asyncio
 async def test_modelengine_get_models_llm_success():
     """ModelEngine provider should return LLM models with correct type mapping."""