ModelEngine-Group
diff --git a/‎backend/agents/create_agent_info.py‎
Lines changed: 1 addition & 1 deletion b/‎backend/agents/create_agent_info.py‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎backend/apps/config_app.py‎
Lines changed: 2 additions & 0 deletions b/‎backend/apps/config_app.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎backend/apps/ragflow_app.py‎
Lines changed: 45 additions & 0 deletions b/‎backend/apps/ragflow_app.py‎
Lines changed: 45 additions & 0 deletions
diff --git a/‎backend/consts/error_code.py‎
Lines changed: 14 additions & 0 deletions b/‎backend/consts/error_code.py‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎backend/consts/tool_labels.py‎
Lines changed: 1 addition & 0 deletions b/‎backend/consts/tool_labels.py‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎backend/services/ragflow_service.py‎
Lines changed: 124 additions & 0 deletions b/‎backend/services/ragflow_service.py‎
Lines changed: 124 additions & 0 deletions
diff --git a/‎backend/services/tool_configuration_service.py‎
Lines changed: 11 additions & 1 deletion b/‎backend/services/tool_configuration_service.py‎
Lines changed: 11 additions & 1 deletion
diff --git a/‎deploy/sql/migrations/v2.3.0_0624_add_labels_to_ag_tool_info.sql‎
Lines changed: 1 addition & 0 deletions b/‎deploy/sql/migrations/v2.3.0_0624_add_labels_to_ag_tool_info.sql‎
Lines changed: 1 addition & 0 deletions
@@ -1092,7 +1092,7 @@ async def create_tool_config_list(
                     f"No embedding model found for index '{index_names[0]}'. "
                     f"Please configure an embedding model for this knowledge base.")
             tool_config.metadata["embedding_model"] = embedding_model
-        elif tool_config.class_name in ["DifySearchTool", "DataMateSearchTool"]:
+        elif tool_config.class_name in ["DifySearchTool", "DataMateSearchTool", "RAGFlowSearchTool"]:
             rerank = tool_config.params.get("rerank", False)
             rerank_model_name = tool_config.params.get("rerank_model_name", "")
             rerank_model = None
 
@@ -8,6 +8,7 @@
 from apps.vectordatabase_app import router as vectordatabase_router
 from apps.dify_app import router as dify_router
 from apps.idata_app import router as idata_router
+from apps.ragflow_app import router as ragflow_router
 from apps.file_management_app import (
     file_management_config_router as file_manager_router,
 )
@@ -68,6 +69,7 @@ async def sync_default_prompt_template_on_startup():
 app.include_router(tool_config_router)
 app.include_router(dify_router)
 app.include_router(idata_router)
+app.include_router(ragflow_router)
 app.include_router(monitoring_router)
 
 # Choose user management router based on IS_SPEED_MODE
 
@@ -0,0 +1,45 @@
+"""
+RAGFlow App Layer
+FastAPI endpoints for RAGFlow knowledge base operations.
+"""
+import logging
+from http import HTTPStatus
+from typing import Annotated, Optional
+
+from fastapi import APIRouter, Header, HTTPException, Query
+from fastapi.responses import JSONResponse
+
+from consts.error_code import ErrorCode
+from consts.exceptions import AppException
+from services.ragflow_service import fetch_ragflow_datasets_impl
+
+router = APIRouter(prefix="/ragflow")
+logger = logging.getLogger("ragflow_app")
+
+
+@router.get("/datasets")
+async def fetch_ragflow_datasets_api(
+    ragflow_api_base: Annotated[str, Query(description="RAGFlow API base URL")],
+    api_key: Annotated[str, Query(description="RAGFlow API key")],
+    authorization: Annotated[Optional[str], Header()] = None
+):
+    """
+    Fetch datasets (knowledge bases) from RAGFlow API.
+    """
+    ragflow_api_base = ragflow_api_base.rstrip('/')
+
+    try:
+        result = fetch_ragflow_datasets_impl(
+            ragflow_api_base=ragflow_api_base,
+            api_key=api_key,
+        )
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content=result
+        )
+    except AppException:
+        raise
+    except Exception as e:
+        logger.exception("Failed to fetch RAGFlow datasets")
+        raise AppException(ErrorCode.RAGFLOW_SERVICE_ERROR,
+                           f"Failed to fetch RAGFlow datasets: {str(e)}")
@@ -195,6 +195,14 @@ class ErrorCode(Enum):
     AIDP_CONNECTION_ERROR = "130503"  # AIDP connection error
     AIDP_AUTH_ERROR = "130504"  # AIDP auth error
 
+    # 06 - RAGFlow Service
+    RAGFLOW_SERVICE_ERROR = "130507"  # RAGFlow service error
+    RAGFLOW_CONFIG_INVALID = "130508"  # Invalid RAGFlow configuration
+    RAGFLOW_CONNECTION_ERROR = "130509"  # RAGFlow connection error
+    RAGFLOW_AUTH_ERROR = "130510"  # RAGFlow auth error
+    RAGFLOW_RATE_LIMIT = "130511"  # RAGFlow rate limit
+    RAGFLOW_RESPONSE_ERROR = "130512"  # RAGFlow response error
+
     # ==================== 14 Northbound / 北向接口 ====================
     # 01 - Request
     NORTHBOUND_REQUEST_FAILED = "140101"  # Northbound request failed
@@ -263,6 +271,12 @@ class ErrorCode(Enum):
     ErrorCode.IDATA_CONNECTION_ERROR: 502,
     ErrorCode.IDATA_RESPONSE_ERROR: 502,
     ErrorCode.IDATA_RATE_LIMIT: 429,
+    # RAGFlow (module 13)
+    ErrorCode.RAGFLOW_CONFIG_INVALID: 400,
+    ErrorCode.RAGFLOW_AUTH_ERROR: 502,
+    ErrorCode.RAGFLOW_CONNECTION_ERROR: 502,
+    ErrorCode.RAGFLOW_RESPONSE_ERROR: 502,
+    ErrorCode.RAGFLOW_RATE_LIMIT: 429,
     # AIDP (module 13)
     ErrorCode.AIDP_CONFIG_INVALID: 400,
     ErrorCode.AIDP_AUTH_ERROR: 502,
 
@@ -33,6 +33,7 @@
 _category_kb = {
     "dify_search": ["knowledge-base"], "datamate_search": ["knowledge-base"],
     "idata_search": ["knowledge-base"], "haotian_search": ["knowledge-base"],
+    "ragflow_search": ["knowledge-base"],
     "aidp_search": ["knowledge-base"],
 }
 _category_multimodal = {
 
@@ -0,0 +1,124 @@
+import json
+import logging
+from typing import Any, Dict
+
+import httpx
+
+from consts.error_code import ErrorCode
+from consts.exceptions import AppException
+from nexent.utils.http_client_manager import http_client_manager
+
+logger = logging.getLogger("ragflow_service")
+
+
+def _validate_ragflow_config(ragflow_api_base: str, api_key: str) -> None:
+    """Validate RAGFlow API configuration parameters.
+
+    Raises AppException if any parameter is invalid.
+    """
+    if not ragflow_api_base or not isinstance(ragflow_api_base, str):
+        raise AppException(
+            ErrorCode.RAGFLOW_CONFIG_INVALID,
+            "RAGFlow API URL is required and must be a non-empty string"
+        )
+
+    if not api_key or not isinstance(api_key, str):
+        raise AppException(
+            ErrorCode.RAGFLOW_CONFIG_INVALID,
+            "RAGFlow API key is required and must be a non-empty string"
+        )
+
+
+def _format_dataset_item(ds: Dict[str, Any]) -> Dict[str, Any]:
+    """Format a single RAGFlow dataset into the standard response shape."""
+    return {
+        "id": str(ds.get("id", "")),
+        "name": ds.get("name", ""),
+        "description": ds.get("description", ""),
+        "doc_count": ds.get("doc_num", 0) or ds.get("document_count", 0),
+        "chunk_count": ds.get("chunk_num", 0) or ds.get("chunk_count", 0),
+        "create_time": str(ds.get("create_time", "")) or str(ds.get("create_date", "")),
+        "update_time": str(ds.get("update_time", "")) or str(ds.get("update_date", "")),
+    }
+
+
+def fetch_ragflow_datasets_impl(
+    ragflow_api_base: str,
+    api_key: str,
+) -> Dict[str, Any]:
+    """
+    Fetch datasets from RAGFlow API.
+
+    Args:
+        ragflow_api_base: RAGFlow API base URL (e.g., 'http://localhost:9380')
+        api_key: RAGFlow API key
+
+    Returns:
+        Dictionary containing datasets:
+        {
+            "data": [
+                {
+                    "id": "dataset_id",
+                    "name": "Dataset Name",
+                    "description": "...",
+                    "doc_count": 10,
+                    "chunk_count": 100,
+                    "create_time": "...",
+                    "update_time": "...",
+                }
+            ]
+        }
+    """
+    _validate_ragflow_config(ragflow_api_base, api_key)
+
+    api_base = ragflow_api_base.rstrip("/")
+    url = f"{api_base}/api/v1/datasets"
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+
+    logger.info(f"Fetching RAGFlow datasets from: {url}")
+
+    try:
+        client = http_client_manager.get_sync_client(
+            base_url=api_base,
+            timeout=10.0,
+            verify_ssl=True
+        )
+        response = client.get(url, headers=headers)
+        response.raise_for_status()
+
+        result = response.json()
+
+        if result.get("code") != 0:
+            raise AppException(
+                ErrorCode.RAGFLOW_SERVICE_ERROR,
+                f"RAGFlow API returned error code {result.get('code')}: "
+                f"{result.get('message', 'Unknown error')}"
+            )
+
+        datasets = result.get("data", [])
+        return {"data": [_format_dataset_item(ds) for ds in datasets]}
+
+    except httpx.RequestError as e:
+        logger.exception("RAGFlow API request failed")
+        raise AppException(ErrorCode.RAGFLOW_CONNECTION_ERROR,
+                           f"RAGFlow API request failed: {str(e)}")
+    except httpx.HTTPStatusError as e:
+        logger.exception(
+            f"RAGFlow API HTTP error: status_code={e.response.status_code}"
+        )
+        if e.response.status_code == 401:
+            raise AppException(ErrorCode.RAGFLOW_AUTH_ERROR,
+                               f"RAGFlow authentication failed: {str(e)}")
+        if e.response.status_code == 403:
+            raise AppException(ErrorCode.RAGFLOW_AUTH_ERROR,
+                               f"RAGFlow access forbidden: {str(e)}")
+        raise AppException(ErrorCode.RAGFLOW_SERVICE_ERROR,
+                           f"RAGFlow API HTTP error {e.response.status_code}: {str(e)}")
+    except json.JSONDecodeError as e:
+        logger.exception("Failed to parse RAGFlow API response")
+        raise AppException(ErrorCode.RAGFLOW_RESPONSE_ERROR,
+                           f"Failed to parse RAGFlow API response: {str(e)}")
@@ -483,7 +483,10 @@ async def update_tool_list(tenant_id: str, user_id: str):
         mcp_tools = await get_all_mcp_tools(tenant_id)
     except Exception as e:
         logger.error(f"failed to get all mcp tools, detail: {e}")
-        raise MCPConnectionError(f"failed to get all mcp tools, detail: {e}")
+        # Don't block local/langchain tool update when MCP is unavailable.
+        # MCP tools will be marked as is_available=False in the DB, which
+        # is the correct state when the MCP server is unreachable.
+        mcp_tools = []
 
     update_tool_table_from_scan_tool_list(tenant_id=tenant_id,
                                           user_id=user_id,
@@ -812,6 +815,7 @@ def _validate_local_tool(
             rerank = instantiation_params.get("rerank", False)
             rerank_model_name = instantiation_params.get("rerank_model_name", "")
             rerank_model = None
+
             if rerank and rerank_model_name:
                 rerank_model = get_rerank_model(tenant_id=tenant_id, model_name=rerank_model_name)
 
@@ -820,6 +824,12 @@ def _validate_local_tool(
                 'rerank_model': rerank_model,
             }
             tool_instance = tool_class(**params)
+        elif tool_name == "ragflow_search":
+            # RAGFlowSearchTool does not accept rerank/rerank_model_name params
+            # RAGFlow handles reranking internally via its API
+            filtered_params = {k: v for k, v in instantiation_params.items()
+                               if k not in ["rerank_model", "rerank", "rerank_model_name"]}
+            tool_instance = tool_class(**filtered_params)
         elif tool_name in ("haotian_search", "aidp_search"):
             # Haotian and AIDP share the same instantiation shape: drop the
             # backend-only rerank keys and explicitly set observer=None
 
@@ -18,6 +18,7 @@ WITH label_map AS (
         "search_memory": "search", "knowledge_base_search": "search",
         "dify_search": "knowledge-base", "datamate_search": "knowledge-base",
         "idata_search": "knowledge-base", "haotian_search": "knowledge-base",
+        "ragflow_search": "knowledge-base",
         "aidp_search": "knowledge-base",
         "analyze_image": "multimodal", "analyze_audio": "multimodal",
         "analyze_video": "multimodal", "analyze_text_file": "multimodal",
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@`
`33`	`33`	`_category_kb = {`
`34`	`34`	`"dify_search": ["knowledge-base"], "datamate_search": ["knowledge-base"],`
`35`	`35`	`"idata_search": ["knowledge-base"], "haotian_search": ["knowledge-base"],`
	`36`	`+ "ragflow_search": ["knowledge-base"],`
`36`	`37`	`"aidp_search": ["knowledge-base"],`
`37`	`38`	`}`
`38`	`39`	`_category_multimodal = {`