fix(parameter_extractor): use graph runtime state variable pool in prompt generation

refactor(parameter_extractor): implement custom error classes
- Introduced specific error classes for robust error handling. - Enhanced error clarity by replacing generic ValueErrors with custom exceptions. - Improved exception management in `ParameterExtractorNode` for better debugging and maintenance.
2025-12-07 03:45:27 +08:00 · 2024-11-04 20:33:47 +08:00 · 2024-11-04 20:24:09 +08:00 · 2024-11-04 18:46:39 +08:00 · 2024-11-04 18:34:55 +08:00 · 2024-11-04 17:48:10 +08:00
46 changed files with 1088 additions and 368 deletions
--- a/api/.env.example
+++ b/api/.env.example
@@ -120,7 +120,8 @@ SUPABASE_URL=your-server-url
 WEB_API_CORS_ALLOW_ORIGINS=http://127.0.0.1:3000,*
 CONSOLE_CORS_ALLOW_ORIGINS=http://127.0.0.1:3000,*

-# Vector database configuration, support: weaviate, qdrant, milvus, myscale, relyt, pgvecto_rs, pgvector, pgvector, chroma, opensearch, tidb_vector, couchbase, vikingdb, upstash
+
+# Vector database configuration, support: weaviate, qdrant, milvus, myscale, relyt, pgvecto_rs, pgvector, pgvector, chroma, opensearch, tidb_vector, couchbase, vikingdb, upstash, lindorm
 VECTOR_STORE=weaviate

 # Weaviate configuration
@@ -263,6 +264,11 @@ VIKINGDB_SCHEMA=http
 VIKINGDB_CONNECTION_TIMEOUT=30
 VIKINGDB_SOCKET_TIMEOUT=30

+# Lindorm configuration
+LINDORM_URL=http://ld-*******************-proxy-search-pub.lindorm.aliyuncs.com:30070
+LINDORM_USERNAME=admin
+LINDORM_PASSWORD=admin
+
 # OceanBase Vector configuration
 OCEANBASE_VECTOR_HOST=127.0.0.1
 OCEANBASE_VECTOR_PORT=2881
@@ -271,6 +277,7 @@ OCEANBASE_VECTOR_PASSWORD=
 OCEANBASE_VECTOR_DATABASE=test
 OCEANBASE_MEMORY_LIMIT=6G

+
 # Upload configuration
 UPLOAD_FILE_SIZE_LIMIT=15
 UPLOAD_FILE_BATCH_LIMIT=5
@@ -320,6 +327,9 @@ SSRF_DEFAULT_MAX_RETRIES=3
 BATCH_UPLOAD_LIMIT=10
 KEYWORD_DATA_SOURCE_TYPE=database

+# Workflow file upload limit
+WORKFLOW_FILE_UPLOAD_LIMIT=10
+
 # CODE EXECUTION CONFIGURATION
 CODE_EXECUTION_ENDPOINT=http://127.0.0.1:8194
 CODE_EXECUTION_API_KEY=dify-sandbox
--- a/api/Dockerfile
+++ b/api/Dockerfile
@@ -55,12 +55,7 @@ RUN apt-get update \
    && echo "deb http://deb.debian.org/debian testing main" > /etc/apt/sources.list \
    && apt-get update \
    # For Security
-    && apt-get install -y --no-install-recommends expat=2.6.3-2 libldap-2.5-0=2.5.18+dfsg-3+b1 perl=5.40.0-6 libsqlite3-0=3.46.1-1 \
-    && if [ "$(dpkg --print-architecture)" = "amd64" ]; then \
-        apt-get install -y --no-install-recommends zlib1g=1:1.3.dfsg+really1.3.1-1+b1; \
-    else \
-        apt-get install -y --no-install-recommends zlib1g=1:1.3.dfsg+really1.3.1-1; \
-    fi \
+    && apt-get install -y --no-install-recommends expat=2.6.3-2 libldap-2.5-0=2.5.18+dfsg-3+b1 perl=5.40.0-6 libsqlite3-0=3.46.1-1 zlib1g=1:1.3.dfsg+really1.3.1-1+b1 \
    # install a chinese font to support the use of tools like matplotlib
    && apt-get install -y fonts-noto-cjk \
    && apt-get autoremove -y \
--- a/api/configs/feature/init.py
+++ b/api/configs/feature/init.py
@@ -216,6 +216,11 @@ class FileUploadConfig(BaseSettings):
        default=20,
    )

+    WORKFLOW_FILE_UPLOAD_LIMIT: PositiveInt = Field(
+        description="Maximum number of files allowed in a workflow upload operation",
+        default=10,
+    )
+

 class HttpConfig(BaseSettings):
    """
--- a/api/configs/middleware/init.py
+++ b/api/configs/middleware/init.py
@@ -20,6 +20,7 @@ from configs.middleware.vdb.baidu_vector_config import BaiduVectorDBConfig
 from configs.middleware.vdb.chroma_config import ChromaConfig
 from configs.middleware.vdb.couchbase_config import CouchbaseConfig
 from configs.middleware.vdb.elasticsearch_config import ElasticsearchConfig
+from configs.middleware.vdb.lindorm_config import LindormConfig
 from configs.middleware.vdb.milvus_config import MilvusConfig
 from configs.middleware.vdb.myscale_config import MyScaleConfig
 from configs.middleware.vdb.oceanbase_config import OceanBaseVectorConfig
@@ -259,6 +260,7 @@ class MiddlewareConfig(
    VikingDBConfig,
    UpstashConfig,
    TidbOnQdrantConfig,
+    LindormConfig,
    OceanBaseVectorConfig,
    BaiduVectorDBConfig,
 ):
--- a/api/configs/middleware/vdb/lindorm_config.py
+++ b/api/configs/middleware/vdb/lindorm_config.py
@@ -0,0 +1,23 @@
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class LindormConfig(BaseSettings):
+    """
+    Lindorm configs
+    """
+
+    LINDORM_URL: Optional[str] = Field(
+        description="Lindorm url",
+        default=None,
+    )
+    LINDORM_USERNAME: Optional[str] = Field(
+        description="Lindorm user",
+        default=None,
+    )
+    LINDORM_PASSWORD: Optional[str] = Field(
+        description="Lindorm password",
+        default=None,
+    )
--- a/api/controllers/common/fields.py
+++ b/api/controllers/common/fields.py
@@ -0,0 +1,24 @@
+from flask_restful import fields
+
+parameters__system_parameters = {
+    "image_file_size_limit": fields.Integer,
+    "video_file_size_limit": fields.Integer,
+    "audio_file_size_limit": fields.Integer,
+    "file_size_limit": fields.Integer,
+    "workflow_file_upload_limit": fields.Integer,
+}
+
+parameters_fields = {
+    "opening_statement": fields.String,
+    "suggested_questions": fields.Raw,
+    "suggested_questions_after_answer": fields.Raw,
+    "speech_to_text": fields.Raw,
+    "text_to_speech": fields.Raw,
+    "retriever_resource": fields.Raw,
+    "annotation_reply": fields.Raw,
+    "more_like_this": fields.Raw,
+    "user_input_form": fields.Raw,
+    "sensitive_word_avoidance": fields.Raw,
+    "file_upload": fields.Raw,
+    "system_parameters": fields.Nested(parameters__system_parameters),
+}
--- a/api/controllers/common/helpers.py
+++ b/api/controllers/common/helpers.py
@@ -2,11 +2,15 @@ import mimetypes
 import os
 import re
 import urllib.parse
+from collections.abc import Mapping
+from typing import Any
 from uuid import uuid4

 import httpx
 from pydantic import BaseModel

+from configs import dify_config
+

 class FileInfo(BaseModel):
    filename: str
@@ -56,3 +60,38 @@ def guess_file_info_from_response(response: httpx.Response):
        mimetype=mimetype,
        size=int(response.headers.get("Content-Length", -1)),
    )
+
+
+def get_parameters_from_feature_dict(*, features_dict: Mapping[str, Any], user_input_form: list[dict[str, Any]]):
+    return {
+        "opening_statement": features_dict.get("opening_statement"),
+        "suggested_questions": features_dict.get("suggested_questions", []),
+        "suggested_questions_after_answer": features_dict.get("suggested_questions_after_answer", {"enabled": False}),
+        "speech_to_text": features_dict.get("speech_to_text", {"enabled": False}),
+        "text_to_speech": features_dict.get("text_to_speech", {"enabled": False}),
+        "retriever_resource": features_dict.get("retriever_resource", {"enabled": False}),
+        "annotation_reply": features_dict.get("annotation_reply", {"enabled": False}),
+        "more_like_this": features_dict.get("more_like_this", {"enabled": False}),
+        "user_input_form": user_input_form,
+        "sensitive_word_avoidance": features_dict.get(
+            "sensitive_word_avoidance", {"enabled": False, "type": "", "configs": []}
+        ),
+        "file_upload": features_dict.get(
+            "file_upload",
+            {
+                "image": {
+                    "enabled": False,
+                    "number_limits": 3,
+                    "detail": "high",
+                    "transfer_methods": ["remote_url", "local_file"],
+                }
+            },
+        ),
+        "system_parameters": {
+            "image_file_size_limit": dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMIT,
+            "video_file_size_limit": dify_config.UPLOAD_VIDEO_FILE_SIZE_LIMIT,
+            "audio_file_size_limit": dify_config.UPLOAD_AUDIO_FILE_SIZE_LIMIT,
+            "file_size_limit": dify_config.UPLOAD_FILE_SIZE_LIMIT,
+            "workflow_file_upload_limit": dify_config.WORKFLOW_FILE_UPLOAD_LIMIT,
+        },
+    }
--- a/api/controllers/console/datasets/datasets.py
+++ b/api/controllers/console/datasets/datasets.py
@@ -456,7 +456,7 @@ class DatasetIndexingEstimateApi(Resource):
            )
        except LLMBadRequestError:
            raise ProviderNotInitializeError(
-                "No Embedding Model available. Please configure a valid provider in the Settings -> Model Provider."
+                "No Embedding Model available. Please configure a valid provider " "in the Settings -> Model Provider."
            )
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description)
@@ -620,6 +620,7 @@ class DatasetRetrievalSettingApi(Resource):
            case (
                VectorType.MILVUS
                | VectorType.RELYT
+                | VectorType.PGVECTOR
                | VectorType.TIDB_VECTOR
                | VectorType.CHROMA
                | VectorType.TENCENT
@@ -640,6 +641,7 @@ class DatasetRetrievalSettingApi(Resource):
                | VectorType.ELASTICSEARCH
                | VectorType.PGVECTOR
                | VectorType.TIDB_ON_QDRANT
+                | VectorType.LINDORM
                | VectorType.COUCHBASE
            ):
                return {
@@ -682,6 +684,7 @@ class DatasetRetrievalSettingMockApi(Resource):
                | VectorType.ELASTICSEARCH
                | VectorType.COUCHBASE
                | VectorType.PGVECTOR
+                | VectorType.LINDORM
            ):
                return {
                    "retrieval_method": [
--- a/api/controllers/console/explore/parameter.py
+++ b/api/controllers/console/explore/parameter.py
@@ -1,6 +1,7 @@
-from flask_restful import fields, marshal_with
+from flask_restful import marshal_with

-from configs import dify_config
+from controllers.common import fields
+from controllers.common import helpers as controller_helpers
 from controllers.console import api
 from controllers.console.app.error import AppUnavailableError
 from controllers.console.explore.wraps import InstalledAppResource
@@ -11,43 +12,14 @@ from services.app_service import AppService
 class AppParameterApi(InstalledAppResource):
    """Resource for app variables."""

-    variable_fields = {
-        "key": fields.String,
-        "name": fields.String,
-        "description": fields.String,
-        "type": fields.String,
-        "default": fields.String,
-        "max_length": fields.Integer,
-        "options": fields.List(fields.String),
-    }
-
-    system_parameters_fields = {
-        "image_file_size_limit": fields.Integer,
-        "video_file_size_limit": fields.Integer,
-        "audio_file_size_limit": fields.Integer,
-        "file_size_limit": fields.Integer,
-    }
-
-    parameters_fields = {
-        "opening_statement": fields.String,
-        "suggested_questions": fields.Raw,
-        "suggested_questions_after_answer": fields.Raw,
-        "speech_to_text": fields.Raw,
-        "text_to_speech": fields.Raw,
-        "retriever_resource": fields.Raw,
-        "annotation_reply": fields.Raw,
-        "more_like_this": fields.Raw,
-        "user_input_form": fields.Raw,
-        "sensitive_word_avoidance": fields.Raw,
-        "file_upload": fields.Raw,
-        "system_parameters": fields.Nested(system_parameters_fields),
-    }
-
-    @marshal_with(parameters_fields)
+    @marshal_with(fields.parameters_fields)
    def get(self, installed_app: InstalledApp):
        """Retrieve app parameters."""
        app_model = installed_app.app

+        if app_model is None:
+            raise AppUnavailableError()
+
        if app_model.mode in {AppMode.ADVANCED_CHAT.value, AppMode.WORKFLOW.value}:
            workflow = app_model.workflow
            if workflow is None:
@@ -57,43 +29,16 @@ class AppParameterApi(InstalledAppResource):
            user_input_form = workflow.user_input_form(to_old_structure=True)
        else:
            app_model_config = app_model.app_model_config
+            if app_model_config is None:
+                raise AppUnavailableError()
+
            features_dict = app_model_config.to_dict()

            user_input_form = features_dict.get("user_input_form", [])

-        return {
-            "opening_statement": features_dict.get("opening_statement"),
-            "suggested_questions": features_dict.get("suggested_questions", []),
-            "suggested_questions_after_answer": features_dict.get(
-                "suggested_questions_after_answer", {"enabled": False}
-            ),
-            "speech_to_text": features_dict.get("speech_to_text", {"enabled": False}),
-            "text_to_speech": features_dict.get("text_to_speech", {"enabled": False}),
-            "retriever_resource": features_dict.get("retriever_resource", {"enabled": False}),
-            "annotation_reply": features_dict.get("annotation_reply", {"enabled": False}),
-            "more_like_this": features_dict.get("more_like_this", {"enabled": False}),
-            "user_input_form": user_input_form,
-            "sensitive_word_avoidance": features_dict.get(
-                "sensitive_word_avoidance", {"enabled": False, "type": "", "configs": []}
-            ),
-            "file_upload": features_dict.get(
-                "file_upload",
-                {
-                    "image": {
-                        "enabled": False,
-                        "number_limits": 3,
-                        "detail": "high",
-                        "transfer_methods": ["remote_url", "local_file"],
-                    }
-                },
-            ),
-            "system_parameters": {
-                "image_file_size_limit": dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMIT,
-                "video_file_size_limit": dify_config.UPLOAD_VIDEO_FILE_SIZE_LIMIT,
-                "audio_file_size_limit": dify_config.UPLOAD_AUDIO_FILE_SIZE_LIMIT,
-                "file_size_limit": dify_config.UPLOAD_FILE_SIZE_LIMIT,
-            },
-        }
+        return controller_helpers.get_parameters_from_feature_dict(
+            features_dict=features_dict, user_input_form=user_input_form
+        )


 class ExploreAppMetaApi(InstalledAppResource):
--- a/api/controllers/console/files/init.py
+++ b/api/controllers/console/files/init.py
@@ -37,6 +37,7 @@ class FileApi(Resource):
            "image_file_size_limit": dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMIT,
            "video_file_size_limit": dify_config.UPLOAD_VIDEO_FILE_SIZE_LIMIT,
            "audio_file_size_limit": dify_config.UPLOAD_AUDIO_FILE_SIZE_LIMIT,
+            "workflow_file_upload_limit": dify_config.WORKFLOW_FILE_UPLOAD_LIMIT,
        }, 200

    @setup_required
--- a/api/controllers/service_api/app/app.py
+++ b/api/controllers/service_api/app/app.py
@@ -1,6 +1,7 @@
-from flask_restful import Resource, fields, marshal_with
+from flask_restful import Resource, marshal_with

-from configs import dify_config
+from controllers.common import fields
+from controllers.common import helpers as controller_helpers
 from controllers.service_api import api
 from controllers.service_api.app.error import AppUnavailableError
 from controllers.service_api.wraps import validate_app_token
@@ -11,40 +12,8 @@ from services.app_service import AppService
 class AppParameterApi(Resource):
    """Resource for app variables."""

-    variable_fields = {
-        "key": fields.String,
-        "name": fields.String,
-        "description": fields.String,
-        "type": fields.String,
-        "default": fields.String,
-        "max_length": fields.Integer,
-        "options": fields.List(fields.String),
-    }
-
-    system_parameters_fields = {
-        "image_file_size_limit": fields.Integer,
-        "video_file_size_limit": fields.Integer,
-        "audio_file_size_limit": fields.Integer,
-        "file_size_limit": fields.Integer,
-    }
-
-    parameters_fields = {
-        "opening_statement": fields.String,
-        "suggested_questions": fields.Raw,
-        "suggested_questions_after_answer": fields.Raw,
-        "speech_to_text": fields.Raw,
-        "text_to_speech": fields.Raw,
-        "retriever_resource": fields.Raw,
-        "annotation_reply": fields.Raw,
-        "more_like_this": fields.Raw,
-        "user_input_form": fields.Raw,
-        "sensitive_word_avoidance": fields.Raw,
-        "file_upload": fields.Raw,
-        "system_parameters": fields.Nested(system_parameters_fields),
-    }
-
    @validate_app_token
-    @marshal_with(parameters_fields)
+    @marshal_with(fields.parameters_fields)
    def get(self, app_model: App):
        """Retrieve app parameters."""
        if app_model.mode in {AppMode.ADVANCED_CHAT.value, AppMode.WORKFLOW.value}:
@@ -56,43 +25,16 @@ class AppParameterApi(Resource):
            user_input_form = workflow.user_input_form(to_old_structure=True)
        else:
            app_model_config = app_model.app_model_config
+            if app_model_config is None:
+                raise AppUnavailableError()
+
            features_dict = app_model_config.to_dict()

            user_input_form = features_dict.get("user_input_form", [])

-        return {
-            "opening_statement": features_dict.get("opening_statement"),
-            "suggested_questions": features_dict.get("suggested_questions", []),
-            "suggested_questions_after_answer": features_dict.get(
-                "suggested_questions_after_answer", {"enabled": False}
-            ),
-            "speech_to_text": features_dict.get("speech_to_text", {"enabled": False}),
-            "text_to_speech": features_dict.get("text_to_speech", {"enabled": False}),
-            "retriever_resource": features_dict.get("retriever_resource", {"enabled": False}),
-            "annotation_reply": features_dict.get("annotation_reply", {"enabled": False}),
-            "more_like_this": features_dict.get("more_like_this", {"enabled": False}),
-            "user_input_form": user_input_form,
-            "sensitive_word_avoidance": features_dict.get(
-                "sensitive_word_avoidance", {"enabled": False, "type": "", "configs": []}
-            ),
-            "file_upload": features_dict.get(
-                "file_upload",
-                {
-                    "image": {
-                        "enabled": False,
-                        "number_limits": 3,
-                        "detail": "high",
-                        "transfer_methods": ["remote_url", "local_file"],
-                    }
-                },
-            ),
-            "system_parameters": {
-                "image_file_size_limit": dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMIT,
-                "video_file_size_limit": dify_config.UPLOAD_VIDEO_FILE_SIZE_LIMIT,
-                "audio_file_size_limit": dify_config.UPLOAD_AUDIO_FILE_SIZE_LIMIT,
-                "file_size_limit": dify_config.UPLOAD_FILE_SIZE_LIMIT,
-            },
-        }
+        return controller_helpers.get_parameters_from_feature_dict(
+            features_dict=features_dict, user_input_form=user_input_form
+        )


 class AppMetaApi(Resource):
--- a/api/controllers/web/app.py
+++ b/api/controllers/web/app.py
@@ -1,6 +1,7 @@
-from flask_restful import fields, marshal_with
+from flask_restful import marshal_with

-from configs import dify_config
+from controllers.common import fields
+from controllers.common import helpers as controller_helpers
 from controllers.web import api
 from controllers.web.error import AppUnavailableError
 from controllers.web.wraps import WebApiResource
@@ -11,39 +12,7 @@ from services.app_service import AppService
 class AppParameterApi(WebApiResource):
    """Resource for app variables."""

-    variable_fields = {
-        "key": fields.String,
-        "name": fields.String,
-        "description": fields.String,
-        "type": fields.String,
-        "default": fields.String,
-        "max_length": fields.Integer,
-        "options": fields.List(fields.String),
-    }
-
-    system_parameters_fields = {
-        "image_file_size_limit": fields.Integer,
-        "video_file_size_limit": fields.Integer,
-        "audio_file_size_limit": fields.Integer,
-        "file_size_limit": fields.Integer,
-    }
-
-    parameters_fields = {
-        "opening_statement": fields.String,
-        "suggested_questions": fields.Raw,
-        "suggested_questions_after_answer": fields.Raw,
-        "speech_to_text": fields.Raw,
-        "text_to_speech": fields.Raw,
-        "retriever_resource": fields.Raw,
-        "annotation_reply": fields.Raw,
-        "more_like_this": fields.Raw,
-        "user_input_form": fields.Raw,
-        "sensitive_word_avoidance": fields.Raw,
-        "file_upload": fields.Raw,
-        "system_parameters": fields.Nested(system_parameters_fields),
-    }
-
-    @marshal_with(parameters_fields)
+    @marshal_with(fields.parameters_fields)
    def get(self, app_model: App, end_user):
        """Retrieve app parameters."""
        if app_model.mode in {AppMode.ADVANCED_CHAT.value, AppMode.WORKFLOW.value}:
@@ -55,43 +24,16 @@ class AppParameterApi(WebApiResource):
            user_input_form = workflow.user_input_form(to_old_structure=True)
        else:
            app_model_config = app_model.app_model_config
+            if app_model_config is None:
+                raise AppUnavailableError()
+
            features_dict = app_model_config.to_dict()

            user_input_form = features_dict.get("user_input_form", [])

-        return {
-            "opening_statement": features_dict.get("opening_statement"),
-            "suggested_questions": features_dict.get("suggested_questions", []),
-            "suggested_questions_after_answer": features_dict.get(
-                "suggested_questions_after_answer", {"enabled": False}
-            ),
-            "speech_to_text": features_dict.get("speech_to_text", {"enabled": False}),
-            "text_to_speech": features_dict.get("text_to_speech", {"enabled": False}),
-            "retriever_resource": features_dict.get("retriever_resource", {"enabled": False}),
-            "annotation_reply": features_dict.get("annotation_reply", {"enabled": False}),
-            "more_like_this": features_dict.get("more_like_this", {"enabled": False}),
-            "user_input_form": user_input_form,
-            "sensitive_word_avoidance": features_dict.get(
-                "sensitive_word_avoidance", {"enabled": False, "type": "", "configs": []}
-            ),
-            "file_upload": features_dict.get(
-                "file_upload",
-                {
-                    "image": {
-                        "enabled": False,
-                        "number_limits": 3,
-                        "detail": "high",
-                        "transfer_methods": ["remote_url", "local_file"],
-                    }
-                },
-            ),
-            "system_parameters": {
-                "image_file_size_limit": dify_config.UPLOAD_IMAGE_FILE_SIZE_LIMIT,
-                "video_file_size_limit": dify_config.UPLOAD_VIDEO_FILE_SIZE_LIMIT,
-                "audio_file_size_limit": dify_config.UPLOAD_AUDIO_FILE_SIZE_LIMIT,
-                "file_size_limit": dify_config.UPLOAD_FILE_SIZE_LIMIT,
-            },
-        }
+        return controller_helpers.get_parameters_from_feature_dict(
+            features_dict=features_dict, user_input_form=user_input_form
+        )


 class AppMeta(WebApiResource):
--- a/api/core/app/app_config/features/file_upload/manager.py
+++ b/api/core/app/app_config/features/file_upload/manager.py
@@ -1,8 +1,7 @@
 from collections.abc import Mapping
 from typing import Any

-from core.file.models import FileExtraConfig
-from models import FileUploadConfig
+from core.file import FileExtraConfig


 class FileUploadConfigManager:
@@ -43,6 +42,6 @@ class FileUploadConfigManager:
        if not config.get("file_upload"):
            config["file_upload"] = {}
        else:
-            FileUploadConfig.model_validate(config["file_upload"])
+            FileExtraConfig.model_validate(config["file_upload"])

        return config, ["file_upload"]
--- a/api/core/app/apps/base_app_generator.py
+++ b/api/core/app/apps/base_app_generator.py
@@ -22,7 +22,10 @@ class BaseAppGenerator:
        user_inputs = user_inputs or {}
        # Filter input variables from form configuration, handle required fields, default values, and option values
        variables = app_config.variables
-        user_inputs = {var.variable: self._validate_input(inputs=user_inputs, var=var) for var in variables}
+        user_inputs = {
+            var.variable: self._validate_inputs(value=user_inputs.get(var.variable), variable_entity=var)
+            for var in variables
+        }
        user_inputs = {k: self._sanitize_value(v) for k, v in user_inputs.items()}
        # Convert files in inputs to File
        entity_dictionary = {item.variable: item for item in app_config.variables}
@@ -74,57 +77,66 @@ class BaseAppGenerator:

        return user_inputs

-    def _validate_input(self, *, inputs: Mapping[str, Any], var: "VariableEntity"):
-        user_input_value = inputs.get(var.variable)
+    def _validate_inputs(
+        self,
+        *,
+        variable_entity: "VariableEntity",
+        value: Any,
+    ):
+        if value is None:
+            if variable_entity.required:
+                raise ValueError(f"{variable_entity.variable} is required in input form")
+            return value

-        if not user_input_value:
-            if var.required:
-                raise ValueError(f"{var.variable} is required in input form")
-            else:
-                return None
-
-        if var.type in {
+        if variable_entity.type in {
            VariableEntityType.TEXT_INPUT,
            VariableEntityType.SELECT,
            VariableEntityType.PARAGRAPH,
-        } and not isinstance(user_input_value, str):
-            raise ValueError(f"(type '{var.type}') {var.variable} in input form must be a string")
+        } and not isinstance(value, str):
+            raise ValueError(
+                f"(type '{variable_entity.type}') {variable_entity.variable} in input form must be a string"
+            )

-        if var.type == VariableEntityType.NUMBER and isinstance(user_input_value, str):
+        if variable_entity.type == VariableEntityType.NUMBER and isinstance(value, str):
            # may raise ValueError if user_input_value is not a valid number
            try:
-                if "." in user_input_value:
-                    return float(user_input_value)
+                if "." in value:
+                    return float(value)
                else:
-                    return int(user_input_value)
+                    return int(value)
            except ValueError:
-                raise ValueError(f"{var.variable} in input form must be a valid number")
+                raise ValueError(f"{variable_entity.variable} in input form must be a valid number")

-        match var.type:
+        match variable_entity.type:
            case VariableEntityType.SELECT:
-                if user_input_value not in var.options:
-                    raise ValueError(f"{var.variable} in input form must be one of the following: {var.options}")
+                if value not in variable_entity.options:
+                    raise ValueError(
+                        f"{variable_entity.variable} in input form must be one of the following: "
+                        f"{variable_entity.options}"
+                    )
            case VariableEntityType.TEXT_INPUT | VariableEntityType.PARAGRAPH:
-                if var.max_length and len(user_input_value) > var.max_length:
-                    raise ValueError(f"{var.variable} in input form must be less than {var.max_length} characters")
+                if variable_entity.max_length and len(value) > variable_entity.max_length:
+                    raise ValueError(
+                        f"{variable_entity.variable} in input form must be less than {variable_entity.max_length} "
+                        "characters"
+                    )
            case VariableEntityType.FILE:
-                if not isinstance(user_input_value, dict) and not isinstance(user_input_value, File):
-                    raise ValueError(f"{var.variable} in input form must be a file")
+                if not isinstance(value, dict) and not isinstance(value, File):
+                    raise ValueError(f"{variable_entity.variable} in input form must be a file")
            case VariableEntityType.FILE_LIST:
                # if number of files exceeds the limit, raise ValueError
                if not (
-                    isinstance(user_input_value, list)
-                    and (
-                        all(isinstance(item, dict) for item in user_input_value)
-                        or all(isinstance(item, File) for item in user_input_value)
-                    )
+                    isinstance(value, list)
+                    and (all(isinstance(item, dict) for item in value) or all(isinstance(item, File) for item in value))
                ):
-                    raise ValueError(f"{var.variable} in input form must be a list of files")
+                    raise ValueError(f"{variable_entity.variable} in input form must be a list of files")

-                if var.max_length and len(user_input_value) > var.max_length:
-                    raise ValueError(f"{var.variable} in input form must be less than {var.max_length} files")
+                if variable_entity.max_length and len(value) > variable_entity.max_length:
+                    raise ValueError(
+                        f"{variable_entity.variable} in input form must be less than {variable_entity.max_length} files"
+                    )

-        return user_input_value
+        return value

    def _sanitize_value(self, value: Any) -> Any:
        if isinstance(value, str):
--- a/api/core/model_runtime/model_providers/gitee_ai/gitee_ai.py
+++ b/api/core/model_runtime/model_providers/gitee_ai/gitee_ai.py
@@ -1,6 +1,7 @@
 import logging

-from core.model_runtime.entities.model_entities import ModelType
+import requests
+
 from core.model_runtime.errors.validate import CredentialsValidateFailedError
 from core.model_runtime.model_providers.__base.model_provider import ModelProvider

@@ -16,8 +17,18 @@ class GiteeAIProvider(ModelProvider):
        :param credentials: provider credentials, credentials form defined in `provider_credential_schema`.
        """
        try:
-            model_instance = self.get_model_instance(ModelType.LLM)
-            model_instance.validate_credentials(model="Qwen2-7B-Instruct", credentials=credentials)
+            api_key = credentials.get("api_key")
+            if not api_key:
+                raise CredentialsValidateFailedError("Credentials validation failed: api_key not given")
+
+            # send a get request to validate the credentials
+            headers = {"Authorization": f"Bearer {api_key}"}
+            response = requests.get("https://ai.gitee.com/api/base/account/me", headers=headers, timeout=(10, 300))
+
+            if response.status_code != 200:
+                raise CredentialsValidateFailedError(
+                    f"Credentials validation failed with status code {response.status_code}"
+                )
        except CredentialsValidateFailedError as ex:
            raise ex
        except Exception as ex:
--- a/api/core/rag/datasource/vdb/lindorm/init.py
+++ b/api/core/rag/datasource/vdb/lindorm/init.py
--- a/api/core/rag/datasource/vdb/lindorm/lindorm_vector.py
+++ b/api/core/rag/datasource/vdb/lindorm/lindorm_vector.py
@@ -0,0 +1,498 @@
+import copy
+import json
+import logging
+from collections.abc import Iterable
+from typing import Any, Optional
+
+from opensearchpy import OpenSearch
+from opensearchpy.helpers import bulk
+from pydantic import BaseModel, model_validator
+from tenacity import retry, stop_after_attempt, wait_fixed
+
+from configs import dify_config
+from core.rag.datasource.vdb.field import Field
+from core.rag.datasource.vdb.vector_base import BaseVector
+from core.rag.datasource.vdb.vector_factory import AbstractVectorFactory
+from core.rag.datasource.vdb.vector_type import VectorType
+from core.rag.embedding.embedding_base import Embeddings
+from core.rag.models.document import Document
+from extensions.ext_redis import redis_client
+from models.dataset import Dataset
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logging.getLogger("lindorm").setLevel(logging.WARN)
+
+
+class LindormVectorStoreConfig(BaseModel):
+    hosts: str
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_config(cls, values: dict) -> dict:
+        if not values["hosts"]:
+            raise ValueError("config URL is required")
+        if not values["username"]:
+            raise ValueError("config USERNAME is required")
+        if not values["password"]:
+            raise ValueError("config PASSWORD is required")
+        return values
+
+    def to_opensearch_params(self) -> dict[str, Any]:
+        params = {
+            "hosts": self.hosts,
+        }
+        if self.username and self.password:
+            params["http_auth"] = (self.username, self.password)
+        return params
+
+
+class LindormVectorStore(BaseVector):
+    def __init__(self, collection_name: str, config: LindormVectorStoreConfig, **kwargs):
+        super().__init__(collection_name.lower())
+        self._client_config = config
+        self._client = OpenSearch(**config.to_opensearch_params())
+        self.kwargs = kwargs
+
+    def get_type(self) -> str:
+        return VectorType.LINDORM
+
+    def create(self, texts: list[Document], embeddings: list[list[float]], **kwargs):
+        self.create_collection(len(embeddings[0]), **kwargs)
+        self.add_texts(texts, embeddings)
+
+    def refresh(self):
+        self._client.indices.refresh(index=self._collection_name)
+
+    def __filter_existed_ids(
+        self,
+        texts: list[str],
+        metadatas: list[dict],
+        ids: list[str],
+        bulk_size: int = 1024,
+    ) -> tuple[Iterable[str], Optional[list[dict]], Optional[list[str]]]:
+        @retry(stop=stop_after_attempt(3), wait=wait_fixed(60))
+        def __fetch_existing_ids(batch_ids: list[str]) -> set[str]:
+            try:
+                existing_docs = self._client.mget(index=self._collection_name, body={"ids": batch_ids}, _source=False)
+                return {doc["_id"] for doc in existing_docs["docs"] if doc["found"]}
+            except Exception as e:
+                logger.error(f"Error fetching batch {batch_ids}: {e}")
+                return set()
+
+        @retry(stop=stop_after_attempt(3), wait=wait_fixed(60))
+        def __fetch_existing_routing_ids(batch_ids: list[str], route_ids: list[str]) -> set[str]:
+            try:
+                existing_docs = self._client.mget(
+                    body={
+                        "docs": [
+                            {"_index": self._collection_name, "_id": id, "routing": routing}
+                            for id, routing in zip(batch_ids, route_ids)
+                        ]
+                    },
+                    _source=False,
+                )
+                return {doc["_id"] for doc in existing_docs["docs"] if doc["found"]}
+            except Exception as e:
+                logger.error(f"Error fetching batch {batch_ids}: {e}")
+                return set()
+
+        if ids is None:
+            return texts, metadatas, ids
+
+        if len(texts) != len(ids):
+            raise RuntimeError(f"texts {len(texts)} != {ids}")
+
+        filtered_texts = []
+        filtered_metadatas = []
+        filtered_ids = []
+
+        def batch(iterable, n):
+            length = len(iterable)
+            for idx in range(0, length, n):
+                yield iterable[idx : min(idx + n, length)]
+
+        for ids_batch, texts_batch, metadatas_batch in zip(
+            batch(ids, bulk_size),
+            batch(texts, bulk_size),
+            batch(metadatas, bulk_size) if metadatas is not None else batch([None] * len(ids), bulk_size),
+        ):
+            existing_ids_set = __fetch_existing_ids(ids_batch)
+            for text, metadata, doc_id in zip(texts_batch, metadatas_batch, ids_batch):
+                if doc_id not in existing_ids_set:
+                    filtered_texts.append(text)
+                    filtered_ids.append(doc_id)
+                    if metadatas is not None:
+                        filtered_metadatas.append(metadata)
+
+        return filtered_texts, metadatas if metadatas is None else filtered_metadatas, filtered_ids
+
+    def add_texts(self, documents: list[Document], embeddings: list[list[float]], **kwargs):
+        actions = []
+        uuids = self._get_uuids(documents)
+        for i in range(len(documents)):
+            action = {
+                "_op_type": "index",
+                "_index": self._collection_name.lower(),
+                "_id": uuids[i],
+                "_source": {
+                    Field.CONTENT_KEY.value: documents[i].page_content,
+                    Field.VECTOR.value: embeddings[i],  # Make sure you pass an array here
+                    Field.METADATA_KEY.value: documents[i].metadata,
+                },
+            }
+            actions.append(action)
+        bulk(self._client, actions)
+        self.refresh()
+
+    def get_ids_by_metadata_field(self, key: str, value: str):
+        query = {"query": {"term": {f"{Field.METADATA_KEY.value}.{key}.keyword": value}}}
+        response = self._client.search(index=self._collection_name, body=query)
+        if response["hits"]["hits"]:
+            return [hit["_id"] for hit in response["hits"]["hits"]]
+        else:
+            return None
+
+    def delete_by_metadata_field(self, key: str, value: str):
+        query_str = {"query": {"match": {f"metadata.{key}": f"{value}"}}}
+        results = self._client.search(index=self._collection_name, body=query_str)
+        ids = [hit["_id"] for hit in results["hits"]["hits"]]
+        if ids:
+            self.delete_by_ids(ids)
+
+    def delete_by_ids(self, ids: list[str]) -> None:
+        for id in ids:
+            if self._client.exists(index=self._collection_name, id=id):
+                self._client.delete(index=self._collection_name, id=id)
+            else:
+                logger.warning(f"DELETE BY ID: ID {id} does not exist in the index.")
+
+    def delete(self) -> None:
+        try:
+            if self._client.indices.exists(index=self._collection_name):
+                self._client.indices.delete(index=self._collection_name, params={"timeout": 60})
+                logger.info("Delete index success")
+            else:
+                logger.warning(f"Index '{self._collection_name}' does not exist. No deletion performed.")
+        except Exception as e:
+            logger.error(f"Error occurred while deleting the index: {e}")
+            raise e
+
+    def text_exists(self, id: str) -> bool:
+        try:
+            self._client.get(index=self._collection_name, id=id)
+            return True
+        except:
+            return False
+
+    def search_by_vector(self, query_vector: list[float], **kwargs: Any) -> list[Document]:
+        # Make sure query_vector is a list
+        if not isinstance(query_vector, list):
+            raise ValueError("query_vector should be a list of floats")
+
+        # Check whether query_vector is a floating-point number list
+        if not all(isinstance(x, float) for x in query_vector):
+            raise ValueError("All elements in query_vector should be floats")
+
+        top_k = kwargs.get("top_k", 10)
+        query = default_vector_search_query(query_vector=query_vector, k=top_k, **kwargs)
+        try:
+            response = self._client.search(index=self._collection_name, body=query)
+        except Exception as e:
+            logger.error(f"Error executing search: {e}")
+            raise
+
+        docs_and_scores = []
+        for hit in response["hits"]["hits"]:
+            docs_and_scores.append(
+                (
+                    Document(
+                        page_content=hit["_source"][Field.CONTENT_KEY.value],
+                        vector=hit["_source"][Field.VECTOR.value],
+                        metadata=hit["_source"][Field.METADATA_KEY.value],
+                    ),
+                    hit["_score"],
+                )
+            )
+        docs = []
+        for doc, score in docs_and_scores:
+            score_threshold = kwargs.get("score_threshold", 0.0) or 0.0
+            if score > score_threshold:
+                doc.metadata["score"] = score
+                docs.append(doc)
+
+        return docs
+
+    def search_by_full_text(self, query: str, **kwargs: Any) -> list[Document]:
+        must = kwargs.get("must")
+        must_not = kwargs.get("must_not")
+        should = kwargs.get("should")
+        minimum_should_match = kwargs.get("minimum_should_match", 0)
+        top_k = kwargs.get("top_k", 10)
+        filters = kwargs.get("filter")
+        routing = kwargs.get("routing")
+        full_text_query = default_text_search_query(
+            query_text=query,
+            k=top_k,
+            text_field=Field.CONTENT_KEY.value,
+            must=must,
+            must_not=must_not,
+            should=should,
+            minimum_should_match=minimum_should_match,
+            filters=filters,
+            routing=routing,
+        )
+        response = self._client.search(index=self._collection_name, body=full_text_query)
+        docs = []
+        for hit in response["hits"]["hits"]:
+            docs.append(
+                Document(
+                    page_content=hit["_source"][Field.CONTENT_KEY.value],
+                    vector=hit["_source"][Field.VECTOR.value],
+                    metadata=hit["_source"][Field.METADATA_KEY.value],
+                )
+            )
+
+        return docs
+
+    def create_collection(self, dimension: int, **kwargs):
+        lock_name = f"vector_indexing_lock_{self._collection_name}"
+        with redis_client.lock(lock_name, timeout=20):
+            collection_exist_cache_key = f"vector_indexing_{self._collection_name}"
+            if redis_client.get(collection_exist_cache_key):
+                logger.info(f"Collection {self._collection_name} already exists.")
+                return
+            if self._client.indices.exists(index=self._collection_name):
+                logger.info("{self._collection_name.lower()} already exists.")
+                return
+            if len(self.kwargs) == 0 and len(kwargs) != 0:
+                self.kwargs = copy.deepcopy(kwargs)
+            vector_field = kwargs.pop("vector_field", Field.VECTOR.value)
+            shards = kwargs.pop("shards", 2)
+
+            engine = kwargs.pop("engine", "lvector")
+            method_name = kwargs.pop("method_name", "hnsw")
+            data_type = kwargs.pop("data_type", "float")
+            space_type = kwargs.pop("space_type", "cosinesimil")
+
+            hnsw_m = kwargs.pop("hnsw_m", 24)
+            hnsw_ef_construction = kwargs.pop("hnsw_ef_construction", 500)
+            ivfpq_m = kwargs.pop("ivfpq_m", dimension)
+            nlist = kwargs.pop("nlist", 1000)
+            centroids_use_hnsw = kwargs.pop("centroids_use_hnsw", True if nlist >= 5000 else False)
+            centroids_hnsw_m = kwargs.pop("centroids_hnsw_m", 24)
+            centroids_hnsw_ef_construct = kwargs.pop("centroids_hnsw_ef_construct", 500)
+            centroids_hnsw_ef_search = kwargs.pop("centroids_hnsw_ef_search", 100)
+            mapping = default_text_mapping(
+                dimension,
+                method_name,
+                shards=shards,
+                engine=engine,
+                data_type=data_type,
+                space_type=space_type,
+                vector_field=vector_field,
+                hnsw_m=hnsw_m,
+                hnsw_ef_construction=hnsw_ef_construction,
+                nlist=nlist,
+                ivfpq_m=ivfpq_m,
+                centroids_use_hnsw=centroids_use_hnsw,
+                centroids_hnsw_m=centroids_hnsw_m,
+                centroids_hnsw_ef_construct=centroids_hnsw_ef_construct,
+                centroids_hnsw_ef_search=centroids_hnsw_ef_search,
+                **kwargs,
+            )
+            self._client.indices.create(index=self._collection_name.lower(), body=mapping)
+            redis_client.set(collection_exist_cache_key, 1, ex=3600)
+            # logger.info(f"create index success: {self._collection_name}")
+
+
+def default_text_mapping(dimension: int, method_name: str, **kwargs: Any) -> dict:
+    routing_field = kwargs.get("routing_field")
+    excludes_from_source = kwargs.get("excludes_from_source")
+    analyzer = kwargs.get("analyzer", "ik_max_word")
+    text_field = kwargs.get("text_field", Field.CONTENT_KEY.value)
+    engine = kwargs["engine"]
+    shard = kwargs["shards"]
+    space_type = kwargs["space_type"]
+    data_type = kwargs["data_type"]
+    vector_field = kwargs.get("vector_field", Field.VECTOR.value)
+
+    if method_name == "ivfpq":
+        ivfpq_m = kwargs["ivfpq_m"]
+        nlist = kwargs["nlist"]
+        centroids_use_hnsw = True if nlist > 10000 else False
+        centroids_hnsw_m = 24
+        centroids_hnsw_ef_construct = 500
+        centroids_hnsw_ef_search = 100
+        parameters = {
+            "m": ivfpq_m,
+            "nlist": nlist,
+            "centroids_use_hnsw": centroids_use_hnsw,
+            "centroids_hnsw_m": centroids_hnsw_m,
+            "centroids_hnsw_ef_construct": centroids_hnsw_ef_construct,
+            "centroids_hnsw_ef_search": centroids_hnsw_ef_search,
+        }
+    elif method_name == "hnsw":
+        neighbor = kwargs["hnsw_m"]
+        ef_construction = kwargs["hnsw_ef_construction"]
+        parameters = {"m": neighbor, "ef_construction": ef_construction}
+    elif method_name == "flat":
+        parameters = {}
+    else:
+        raise RuntimeError(f"unexpected method_name: {method_name}")
+
+    mapping = {
+        "settings": {"index": {"number_of_shards": shard, "knn": True}},
+        "mappings": {
+            "properties": {
+                vector_field: {
+                    "type": "knn_vector",
+                    "dimension": dimension,
+                    "data_type": data_type,
+                    "method": {
+                        "engine": engine,
+                        "name": method_name,
+                        "space_type": space_type,
+                        "parameters": parameters,
+                    },
+                },
+                text_field: {"type": "text", "analyzer": analyzer},
+            }
+        },
+    }
+
+    if excludes_from_source:
+        mapping["mappings"]["_source"] = {"excludes": excludes_from_source}  # e.g. {"excludes": ["vector_field"]}
+
+    if method_name == "ivfpq" and routing_field is not None:
+        mapping["settings"]["index"]["knn_routing"] = True
+        mapping["settings"]["index"]["knn.offline.construction"] = True
+
+    if method_name == "flat" and routing_field is not None:
+        mapping["settings"]["index"]["knn_routing"] = True
+
+    return mapping
+
+
+def default_text_search_query(
+    query_text: str,
+    k: int = 4,
+    text_field: str = Field.CONTENT_KEY.value,
+    must: Optional[list[dict]] = None,
+    must_not: Optional[list[dict]] = None,
+    should: Optional[list[dict]] = None,
+    minimum_should_match: int = 0,
+    filters: Optional[list[dict]] = None,
+    routing: Optional[str] = None,
+    **kwargs,
+) -> dict:
+    if routing is not None:
+        routing_field = kwargs.get("routing_field", "routing_field")
+        query_clause = {
+            "bool": {
+                "must": [{"match": {text_field: query_text}}, {"term": {f"metadata.{routing_field}.keyword": routing}}]
+            }
+        }
+    else:
+        query_clause = {"match": {text_field: query_text}}
+    # build the simplest search_query when only query_text is specified
+    if not must and not must_not and not should and not filters:
+        search_query = {"size": k, "query": query_clause}
+        return search_query
+
+    # build complex search_query when either of must/must_not/should/filter is specified
+    if must:
+        if not isinstance(must, list):
+            raise RuntimeError(f"unexpected [must] clause with {type(filters)}")
+        if query_clause not in must:
+            must.append(query_clause)
+    else:
+        must = [query_clause]
+
+    boolean_query = {"must": must}
+
+    if must_not:
+        if not isinstance(must_not, list):
+            raise RuntimeError(f"unexpected [must_not] clause with {type(filters)}")
+        boolean_query["must_not"] = must_not
+
+    if should:
+        if not isinstance(should, list):
+            raise RuntimeError(f"unexpected [should] clause with {type(filters)}")
+        boolean_query["should"] = should
+        if minimum_should_match != 0:
+            boolean_query["minimum_should_match"] = minimum_should_match
+
+    if filters:
+        if not isinstance(filters, list):
+            raise RuntimeError(f"unexpected [filter] clause with {type(filters)}")
+        boolean_query["filter"] = filters
+
+    search_query = {"size": k, "query": {"bool": boolean_query}}
+    return search_query
+
+
+def default_vector_search_query(
+    query_vector: list[float],
+    k: int = 4,
+    min_score: str = "0.0",
+    ef_search: Optional[str] = None,  # only for hnsw
+    nprobe: Optional[str] = None,  # "2000"
+    reorder_factor: Optional[str] = None,  # "20"
+    client_refactor: Optional[str] = None,  # "true"
+    vector_field: str = Field.VECTOR.value,
+    filters: Optional[list[dict]] = None,
+    filter_type: Optional[str] = None,
+    **kwargs,
+) -> dict:
+    if filters is not None:
+        filter_type = "post_filter" if filter_type is None else filter_type
+        if not isinstance(filter, list):
+            raise RuntimeError(f"unexpected filter with {type(filters)}")
+    final_ext = {"lvector": {}}
+    if min_score != "0.0":
+        final_ext["lvector"]["min_score"] = min_score
+    if ef_search:
+        final_ext["lvector"]["ef_search"] = ef_search
+    if nprobe:
+        final_ext["lvector"]["nprobe"] = nprobe
+    if reorder_factor:
+        final_ext["lvector"]["reorder_factor"] = reorder_factor
+    if client_refactor:
+        final_ext["lvector"]["client_refactor"] = client_refactor
+
+    search_query = {
+        "size": k,
+        "_source": True,  # force return '_source'
+        "query": {"knn": {vector_field: {"vector": query_vector, "k": k}}},
+    }
+
+    if filters is not None:
+        # when using filter, transform filter from List[Dict] to Dict as valid format
+        filters = {"bool": {"must": filters}} if len(filters) > 1 else filters[0]
+        search_query["query"]["knn"][vector_field]["filter"] = filters  # filter should be Dict
+        if filter_type:
+            final_ext["lvector"]["filter_type"] = filter_type
+
+    if final_ext != {"lvector": {}}:
+        search_query["ext"] = final_ext
+    return search_query
+
+
+class LindormVectorStoreFactory(AbstractVectorFactory):
+    def init_vector(self, dataset: Dataset, attributes: list, embeddings: Embeddings) -> LindormVectorStore:
+        if dataset.index_struct_dict:
+            class_prefix: str = dataset.index_struct_dict["vector_store"]["class_prefix"]
+            collection_name = class_prefix
+        else:
+            dataset_id = dataset.id
+            collection_name = Dataset.gen_collection_name_by_id(dataset_id)
+            dataset.index_struct = json.dumps(self.gen_index_struct_dict(VectorType.LINDORM, collection_name))
+        lindorm_config = LindormVectorStoreConfig(
+            hosts=dify_config.LINDORM_URL,
+            username=dify_config.LINDORM_USERNAME,
+            password=dify_config.LINDORM_PASSWORD,
+        )
+        return LindormVectorStore(collection_name, lindorm_config)
--- a/api/core/rag/datasource/vdb/vector_factory.py
+++ b/api/core/rag/datasource/vdb/vector_factory.py
@@ -134,6 +134,10 @@ class Vector:
                from core.rag.datasource.vdb.tidb_on_qdrant.tidb_on_qdrant_vector import TidbOnQdrantVectorFactory

                return TidbOnQdrantVectorFactory
+            case VectorType.LINDORM:
+                from core.rag.datasource.vdb.lindorm.lindorm_vector import LindormVectorStoreFactory
+
+                return LindormVectorStoreFactory
            case VectorType.OCEANBASE:
                from core.rag.datasource.vdb.oceanbase.oceanbase_vector import OceanBaseVectorFactory

--- a/api/core/rag/datasource/vdb/vector_type.py
+++ b/api/core/rag/datasource/vdb/vector_type.py
@@ -16,6 +16,7 @@ class VectorType(str, Enum):
    TENCENT = "tencent"
    ORACLE = "oracle"
    ELASTICSEARCH = "elasticsearch"
+    LINDORM = "lindorm"
    COUCHBASE = "couchbase"
    BAIDU = "baidu"
    VIKINGDB = "vikingdb"
--- a/api/core/rag/extractor/word_extractor.py
+++ b/api/core/rag/extractor/word_extractor.py
@@ -14,6 +14,7 @@ import requests
 from docx import Document as DocxDocument

 from configs import dify_config
+from core.helper import ssrf_proxy
 from core.rag.extractor.extractor_base import BaseExtractor
 from core.rag.models.document import Document
 from extensions.ext_database import db
@@ -86,7 +87,7 @@ class WordExtractor(BaseExtractor):
                image_count += 1
                if rel.is_external:
                    url = rel.reltype
-                    response = requests.get(url, stream=True)
+                    response = ssrf_proxy.get(url, stream=True)
                    if response.status_code == 200:
                        image_ext = mimetypes.guess_extension(response.headers["Content-Type"])
                        file_uuid = str(uuid.uuid4())
--- a/api/core/tools/provider/builtin/aippt/tools/aippt.py
+++ b/api/core/tools/provider/builtin/aippt/tools/aippt.py
@@ -4,7 +4,7 @@ from hmac import new as hmac_new
 from json import loads as json_loads
 from threading import Lock
 from time import sleep, time
-from typing import Any, Optional
+from typing import Any

 from httpx import get, post
 from requests import get as requests_get
@@ -15,27 +15,27 @@ from core.tools.entities.tool_entities import ToolInvokeMessage, ToolParameter,
 from core.tools.tool.builtin_tool import BuiltinTool


-class AIPPTGenerateTool(BuiltinTool):
+class AIPPTGenerateToolAdapter:
    """
    A tool for generating a ppt
    """

    _api_base_url = URL("https://co.aippt.cn/api")
    _api_token_cache = {}
-    _api_token_cache_lock: Optional[Lock] = None
    _style_cache = {}
-    _style_cache_lock: Optional[Lock] = None
+
+    _api_token_cache_lock = Lock()
+    _style_cache_lock = Lock()

    _task = {}
    _task_type_map = {
        "auto": 1,
        "markdown": 7,
    }
+    _tool: BuiltinTool

-    def __init__(self, **kwargs: Any):
-        super().__init__(**kwargs)
-        self._api_token_cache_lock = Lock()
-        self._style_cache_lock = Lock()
+    def __init__(self, tool: BuiltinTool = None):
+        self._tool = tool

    def _invoke(self, user_id: str, tool_parameters: dict[str, Any]) -> ToolInvokeMessage | list[ToolInvokeMessage]:
        """
@@ -51,11 +51,11 @@ class AIPPTGenerateTool(BuiltinTool):
        """
        title = tool_parameters.get("title", "")
        if not title:
-            return self.create_text_message("Please provide a title for the ppt")
+            return self._tool.create_text_message("Please provide a title for the ppt")

        model = tool_parameters.get("model", "aippt")
        if not model:
-            return self.create_text_message("Please provide a model for the ppt")
+            return self._tool.create_text_message("Please provide a model for the ppt")

        outline = tool_parameters.get("outline", "")

@@ -68,8 +68,8 @@ class AIPPTGenerateTool(BuiltinTool):
        )

        # get suit
-        color = tool_parameters.get("color")
-        style = tool_parameters.get("style")
+        color: str = tool_parameters.get("color")
+        style: str = tool_parameters.get("style")

        if color == "__default__":
            color_id = ""
@@ -93,9 +93,9 @@ class AIPPTGenerateTool(BuiltinTool):
        # generate ppt
        _, ppt_url = self._generate_ppt(task_id=task_id, suit_id=suit_id, user_id=user_id)

-        return self.create_text_message(
+        return self._tool.create_text_message(
            """the ppt has been created successfully,"""
-            f"""the ppt url is {ppt_url}"""
+            f"""the ppt url is {ppt_url} ."""
            """please give the ppt url to user and direct user to download it."""
        )

@@ -111,8 +111,8 @@ class AIPPTGenerateTool(BuiltinTool):
        """
        headers = {
            "x-channel": "",
-            "x-api-key": self.runtime.credentials["aippt_access_key"],
-            "x-token": self._get_api_token(credentials=self.runtime.credentials, user_id=user_id),
+            "x-api-key": self._tool.runtime.credentials["aippt_access_key"],
+            "x-token": self._get_api_token(credentials=self._tool.runtime.credentials, user_id=user_id),
        }
        response = post(
            str(self._api_base_url / "ai" / "chat" / "v2" / "task"),
@@ -139,8 +139,8 @@ class AIPPTGenerateTool(BuiltinTool):

        headers = {
            "x-channel": "",
-            "x-api-key": self.runtime.credentials["aippt_access_key"],
-            "x-token": self._get_api_token(credentials=self.runtime.credentials, user_id=user_id),
+            "x-api-key": self._tool.runtime.credentials["aippt_access_key"],
+            "x-token": self._get_api_token(credentials=self._tool.runtime.credentials, user_id=user_id),
        }

        response = requests_get(url=api_url, headers=headers, stream=True, timeout=(10, 60))
@@ -183,8 +183,8 @@ class AIPPTGenerateTool(BuiltinTool):

        headers = {
            "x-channel": "",
-            "x-api-key": self.runtime.credentials["aippt_access_key"],
-            "x-token": self._get_api_token(credentials=self.runtime.credentials, user_id=user_id),
+            "x-api-key": self._tool.runtime.credentials["aippt_access_key"],
+            "x-token": self._get_api_token(credentials=self._tool.runtime.credentials, user_id=user_id),
        }

        response = requests_get(url=api_url, headers=headers, stream=True, timeout=(10, 60))
@@ -236,14 +236,15 @@ class AIPPTGenerateTool(BuiltinTool):
        """
        headers = {
            "x-channel": "",
-            "x-api-key": self.runtime.credentials["aippt_access_key"],
-            "x-token": self._get_api_token(credentials=self.runtime.credentials, user_id=user_id),
+            "x-api-key": self._tool.runtime.credentials["aippt_access_key"],
+            "x-token": self._get_api_token(credentials=self._tool.runtime.credentials, user_id=user_id),
        }

        response = post(
            str(self._api_base_url / "design" / "v2" / "save"),
            headers=headers,
            data={"task_id": task_id, "template_id": suit_id},
+            timeout=(10, 60),
        )

        if response.status_code != 200:
@@ -350,11 +351,13 @@ class AIPPTGenerateTool(BuiltinTool):

        return token

-    @classmethod
-    def _calculate_sign(cls, access_key: str, secret_key: str, timestamp: int) -> str:
+    @staticmethod
+    def _calculate_sign(access_key: str, secret_key: str, timestamp: int) -> str:
        return b64encode(
            hmac_new(
-                key=secret_key.encode("utf-8"), msg=f"GET@/api/grant/token/@{timestamp}".encode(), digestmod=sha1
+                key=secret_key.encode("utf-8"),
+                msg=f"GET@/api/grant/token/@{timestamp}".encode(),
+                digestmod=sha1,
            ).digest()
        ).decode("utf-8")

@@ -419,10 +422,12 @@ class AIPPTGenerateTool(BuiltinTool):
        :param credentials: the credentials
        :return: Tuple[list[dict[id, color]], list[dict[id, style]]
        """
-        if not self.runtime.credentials.get("aippt_access_key") or not self.runtime.credentials.get("aippt_secret_key"):
+        if not self._tool.runtime.credentials.get("aippt_access_key") or not self._tool.runtime.credentials.get(
+            "aippt_secret_key"
+        ):
            raise Exception("Please provide aippt credentials")

-        return self._get_styles(credentials=self.runtime.credentials, user_id=user_id)
+        return self._get_styles(credentials=self._tool.runtime.credentials, user_id=user_id)

    def _get_suit(self, style_id: int, colour_id: int) -> int:
        """
@@ -430,8 +435,8 @@ class AIPPTGenerateTool(BuiltinTool):
        """
        headers = {
            "x-channel": "",
-            "x-api-key": self.runtime.credentials["aippt_access_key"],
-            "x-token": self._get_api_token(credentials=self.runtime.credentials, user_id="__dify_system__"),
+            "x-api-key": self._tool.runtime.credentials["aippt_access_key"],
+            "x-token": self._get_api_token(credentials=self._tool.runtime.credentials, user_id="__dify_system__"),
        }
        response = get(
            str(self._api_base_url / "template_component" / "suit" / "search"),
@@ -496,3 +501,18 @@ class AIPPTGenerateTool(BuiltinTool):
                ],
            ),
        ]
+
+
+class AIPPTGenerateTool(BuiltinTool):
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+
+    def _invoke(self, user_id: str, tool_parameters: dict[str, Any]) -> ToolInvokeMessage | list[ToolInvokeMessage]:
+        return AIPPTGenerateToolAdapter(self)._invoke(user_id, tool_parameters)
+
+    def get_runtime_parameters(self) -> list[ToolParameter]:
+        return AIPPTGenerateToolAdapter(self).get_runtime_parameters()
+
+    @classmethod
+    def _get_api_token(cls, credentials: dict[str, str], user_id: str) -> str:
+        return AIPPTGenerateToolAdapter()._get_api_token(credentials, user_id)
--- a/api/core/workflow/nodes/code/code_node.py
+++ b/api/core/workflow/nodes/code/code_node.py
@@ -12,6 +12,12 @@ from core.workflow.nodes.code.entities import CodeNodeData
 from core.workflow.nodes.enums import NodeType
 from models.workflow import WorkflowNodeExecutionStatus

+from .exc import (
+    CodeNodeError,
+    DepthLimitError,
+    OutputValidationError,
+)
+

 class CodeNode(BaseNode[CodeNodeData]):
    _node_data_cls = CodeNodeData
@@ -60,7 +66,7 @@ class CodeNode(BaseNode[CodeNodeData]):

            # Transform result
            result = self._transform_result(result, self.node_data.outputs)
-        except (CodeExecutionError, ValueError) as e:
+        except (CodeExecutionError, CodeNodeError) as e:
            return NodeRunResult(status=WorkflowNodeExecutionStatus.FAILED, inputs=variables, error=str(e))

        return NodeRunResult(status=WorkflowNodeExecutionStatus.SUCCEEDED, inputs=variables, outputs=result)
@@ -76,10 +82,10 @@ class CodeNode(BaseNode[CodeNodeData]):
            if value is None:
                return None
            else:
-                raise ValueError(f"Output variable `{variable}` must be a string")
+                raise OutputValidationError(f"Output variable `{variable}` must be a string")

        if len(value) > dify_config.CODE_MAX_STRING_LENGTH:
-            raise ValueError(
+            raise OutputValidationError(
                f"The length of output variable `{variable}` must be"
                f" less than {dify_config.CODE_MAX_STRING_LENGTH} characters"
            )
@@ -97,10 +103,10 @@ class CodeNode(BaseNode[CodeNodeData]):
            if value is None:
                return None
            else:
-                raise ValueError(f"Output variable `{variable}` must be a number")
+                raise OutputValidationError(f"Output variable `{variable}` must be a number")

        if value > dify_config.CODE_MAX_NUMBER or value < dify_config.CODE_MIN_NUMBER:
-            raise ValueError(
+            raise OutputValidationError(
                f"Output variable `{variable}` is out of range,"
                f" it must be between {dify_config.CODE_MIN_NUMBER} and {dify_config.CODE_MAX_NUMBER}."
            )
@@ -108,7 +114,7 @@ class CodeNode(BaseNode[CodeNodeData]):
        if isinstance(value, float):
            # raise error if precision is too high
            if len(str(value).split(".")[1]) > dify_config.CODE_MAX_PRECISION:
-                raise ValueError(
+                raise OutputValidationError(
                    f"Output variable `{variable}` has too high precision,"
                    f" it must be less than {dify_config.CODE_MAX_PRECISION} digits."
                )
@@ -125,7 +131,7 @@ class CodeNode(BaseNode[CodeNodeData]):
        :return:
        """
        if depth > dify_config.CODE_MAX_DEPTH:
-            raise ValueError(f"Depth limit ${dify_config.CODE_MAX_DEPTH} reached, object too deep.")
+            raise DepthLimitError(f"Depth limit ${dify_config.CODE_MAX_DEPTH} reached, object too deep.")

        transformed_result = {}
        if output_schema is None:
@@ -177,14 +183,14 @@ class CodeNode(BaseNode[CodeNodeData]):
                                        depth=depth + 1,
                                    )
                        else:
-                            raise ValueError(
+                            raise OutputValidationError(
                                f"Output {prefix}.{output_name} is not a valid array."
                                f" make sure all elements are of the same type."
                            )
                elif output_value is None:
                    pass
                else:
-                    raise ValueError(f"Output {prefix}.{output_name} is not a valid type.")
+                    raise OutputValidationError(f"Output {prefix}.{output_name} is not a valid type.")

            return result

@@ -192,7 +198,7 @@ class CodeNode(BaseNode[CodeNodeData]):
        for output_name, output_config in output_schema.items():
            dot = "." if prefix else ""
            if output_name not in result:
-                raise ValueError(f"Output {prefix}{dot}{output_name} is missing.")
+                raise OutputValidationError(f"Output {prefix}{dot}{output_name} is missing.")

            if output_config.type == "object":
                # check if output is object
@@ -200,7 +206,7 @@ class CodeNode(BaseNode[CodeNodeData]):
                    if isinstance(result.get(output_name), type(None)):
                        transformed_result[output_name] = None
                    else:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"Output {prefix}{dot}{output_name} is not an object,"
                            f" got {type(result.get(output_name))} instead."
                        )
@@ -228,13 +234,13 @@ class CodeNode(BaseNode[CodeNodeData]):
                    if isinstance(result[output_name], type(None)):
                        transformed_result[output_name] = None
                    else:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"Output {prefix}{dot}{output_name} is not an array,"
                            f" got {type(result.get(output_name))} instead."
                        )
                else:
                    if len(result[output_name]) > dify_config.CODE_MAX_NUMBER_ARRAY_LENGTH:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"The length of output variable `{prefix}{dot}{output_name}` must be"
                            f" less than {dify_config.CODE_MAX_NUMBER_ARRAY_LENGTH} elements."
                        )
@@ -249,13 +255,13 @@ class CodeNode(BaseNode[CodeNodeData]):
                    if isinstance(result[output_name], type(None)):
                        transformed_result[output_name] = None
                    else:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"Output {prefix}{dot}{output_name} is not an array,"
                            f" got {type(result.get(output_name))} instead."
                        )
                else:
                    if len(result[output_name]) > dify_config.CODE_MAX_STRING_ARRAY_LENGTH:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"The length of output variable `{prefix}{dot}{output_name}` must be"
                            f" less than {dify_config.CODE_MAX_STRING_ARRAY_LENGTH} elements."
                        )
@@ -270,13 +276,13 @@ class CodeNode(BaseNode[CodeNodeData]):
                    if isinstance(result[output_name], type(None)):
                        transformed_result[output_name] = None
                    else:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"Output {prefix}{dot}{output_name} is not an array,"
                            f" got {type(result.get(output_name))} instead."
                        )
                else:
                    if len(result[output_name]) > dify_config.CODE_MAX_OBJECT_ARRAY_LENGTH:
-                        raise ValueError(
+                        raise OutputValidationError(
                            f"The length of output variable `{prefix}{dot}{output_name}` must be"
                            f" less than {dify_config.CODE_MAX_OBJECT_ARRAY_LENGTH} elements."
                        )
@@ -286,7 +292,7 @@ class CodeNode(BaseNode[CodeNodeData]):
                            if value is None:
                                pass
                            else:
-                                raise ValueError(
+                                raise OutputValidationError(
                                    f"Output {prefix}{dot}{output_name}[{i}] is not an object,"
                                    f" got {type(value)} instead at index {i}."
                                )
@@ -303,13 +309,13 @@ class CodeNode(BaseNode[CodeNodeData]):
                        for i, value in enumerate(result[output_name])
                    ]
            else:
-                raise ValueError(f"Output type {output_config.type} is not supported.")
+                raise OutputValidationError(f"Output type {output_config.type} is not supported.")

            parameters_validated[output_name] = True

        # check if all output parameters are validated
        if len(parameters_validated) != len(result):
-            raise ValueError("Not all output parameters are validated.")
+            raise CodeNodeError("Not all output parameters are validated.")

        return transformed_result

--- a/api/core/workflow/nodes/code/exc.py
+++ b/api/core/workflow/nodes/code/exc.py
@@ -0,0 +1,16 @@
+class CodeNodeError(ValueError):
+    """Base class for code node errors."""
+
+    pass
+
+
+class OutputValidationError(CodeNodeError):
+    """Raised when there is an output validation error."""
+
+    pass
+
+
+class DepthLimitError(CodeNodeError):
+    """Raised when the depth limit is reached."""
+
+    pass
--- a/api/core/workflow/nodes/http_request/exc.py
+++ b/api/core/workflow/nodes/http_request/exc.py
@@ -0,0 +1,18 @@
+class HttpRequestNodeError(ValueError):
+    """Custom error for HTTP request node."""
+
+
+class AuthorizationConfigError(HttpRequestNodeError):
+    """Raised when authorization config is missing or invalid."""
+
+
+class FileFetchError(HttpRequestNodeError):
+    """Raised when a file cannot be fetched."""
+
+
+class InvalidHttpMethodError(HttpRequestNodeError):
+    """Raised when an invalid HTTP method is used."""
+
+
+class ResponseSizeError(HttpRequestNodeError):
+    """Raised when the response size exceeds the allowed threshold."""
--- a/api/core/workflow/nodes/http_request/executor.py
+++ b/api/core/workflow/nodes/http_request/executor.py
@@ -18,6 +18,12 @@ from .entities import (
    HttpRequestNodeTimeout,
    Response,
 )
+from .exc import (
+    AuthorizationConfigError,
+    FileFetchError,
+    InvalidHttpMethodError,
+    ResponseSizeError,
+)

 BODY_TYPE_TO_CONTENT_TYPE = {
    "json": "application/json",
@@ -51,7 +57,7 @@ class Executor:
        # If authorization API key is present, convert the API key using the variable pool
        if node_data.authorization.type == "api-key":
            if node_data.authorization.config is None:
-                raise ValueError("authorization config is required")
+                raise AuthorizationConfigError("authorization config is required")
            node_data.authorization.config.api_key = variable_pool.convert_template(
                node_data.authorization.config.api_key
            ).text
@@ -116,7 +122,7 @@ class Executor:
                    file_selector = data[0].file
                    file_variable = self.variable_pool.get_file(file_selector)
                    if file_variable is None:
-                        raise ValueError(f"cannot fetch file with selector {file_selector}")
+                        raise FileFetchError(f"cannot fetch file with selector {file_selector}")
                    file = file_variable.value
                    self.content = file_manager.download(file)
                case "x-www-form-urlencoded":
@@ -155,12 +161,12 @@ class Executor:
        headers = deepcopy(self.headers) or {}
        if self.auth.type == "api-key":
            if self.auth.config is None:
-                raise ValueError("self.authorization config is required")
+                raise AuthorizationConfigError("self.authorization config is required")
            if authorization.config is None:
-                raise ValueError("authorization config is required")
+                raise AuthorizationConfigError("authorization config is required")

            if self.auth.config.api_key is None:
-                raise ValueError("api_key is required")
+                raise AuthorizationConfigError("api_key is required")

            if not authorization.config.header:
                authorization.config.header = "Authorization"
@@ -183,7 +189,7 @@ class Executor:
            else dify_config.HTTP_REQUEST_NODE_MAX_TEXT_SIZE
        )
        if executor_response.size > threshold_size:
-            raise ValueError(
+            raise ResponseSizeError(
                f'{"File" if executor_response.is_file else "Text"} size is too large,'
                f' max size is {threshold_size / 1024 / 1024:.2f} MB,'
                f' but current size is {executor_response.readable_size}.'
@@ -196,7 +202,7 @@ class Executor:
        do http request depending on api bundle
        """
        if self.method not in {"get", "head", "post", "put", "delete", "patch"}:
-            raise ValueError(f"Invalid http method {self.method}")
+            raise InvalidHttpMethodError(f"Invalid http method {self.method}")

        request_args = {
            "url": self.url,
--- a/api/core/workflow/nodes/http_request/node.py
+++ b/api/core/workflow/nodes/http_request/node.py
@@ -20,6 +20,7 @@ from .entities import (
    HttpRequestNodeTimeout,
    Response,
 )
+from .exc import HttpRequestNodeError

 HTTP_REQUEST_DEFAULT_TIMEOUT = HttpRequestNodeTimeout(
    connect=dify_config.HTTP_REQUEST_MAX_CONNECT_TIMEOUT,
@@ -77,7 +78,7 @@ class HttpRequestNode(BaseNode[HttpRequestNodeData]):
                    "request": http_executor.to_log(),
                },
            )
-        except Exception as e:
+        except HttpRequestNodeError as e:
            logger.warning(f"http request node {self.node_id} failed to run: {e}")
            return NodeRunResult(
                status=WorkflowNodeExecutionStatus.FAILED,
--- a/api/core/workflow/nodes/list_operator/node.py
+++ b/api/core/workflow/nodes/list_operator/node.py
@@ -295,4 +295,4 @@ def _order_file(*, order: Literal["asc", "desc"], order_by: str = "", array: Seq
        extract_func = _get_file_extract_number_func(key=order_by)
        return sorted(array, key=lambda x: extract_func(x), reverse=order == "desc")
    else:
-        raise ValueError(f"Invalid order key: {order_by}")
+        raise InvalidKeyError(f"Invalid order key: {order_by}")
--- a/api/core/workflow/nodes/llm/exc.py
+++ b/api/core/workflow/nodes/llm/exc.py
@@ -0,0 +1,26 @@
+class LLMNodeError(ValueError):
+    """Base class for LLM Node errors."""
+
+
+class VariableNotFoundError(LLMNodeError):
+    """Raised when a required variable is not found."""
+
+
+class InvalidContextStructureError(LLMNodeError):
+    """Raised when the context structure is invalid."""
+
+
+class InvalidVariableTypeError(LLMNodeError):
+    """Raised when the variable type is invalid."""
+
+
+class ModelNotExistError(LLMNodeError):
+    """Raised when the specified model does not exist."""
+
+
+class LLMModeRequiredError(LLMNodeError):
+    """Raised when LLM mode is required but not provided."""
+
+
+class NoPromptFoundError(LLMNodeError):
+    """Raised when no prompt is found in the LLM configuration."""
--- a/api/core/workflow/nodes/llm/node.py
+++ b/api/core/workflow/nodes/llm/node.py
@@ -56,6 +56,15 @@ from .entities import (
    LLMNodeData,
    ModelConfig,
 )
+from .exc import (
+    InvalidContextStructureError,
+    InvalidVariableTypeError,
+    LLMModeRequiredError,
+    LLMNodeError,
+    ModelNotExistError,
+    NoPromptFoundError,
+    VariableNotFoundError,
+)

 if TYPE_CHECKING:
    from core.file.models import File
@@ -103,7 +112,7 @@ class LLMNode(BaseNode[LLMNodeData]):
                    yield event

            if context:
-                node_inputs["#context#"] = context  # type: ignore
+                node_inputs["#context#"] = context

            # fetch model config
            model_instance, model_config = self._fetch_model_config(self.node_data.model)
@@ -115,7 +124,7 @@ class LLMNode(BaseNode[LLMNodeData]):
            if self.node_data.memory:
                query = self.graph_runtime_state.variable_pool.get((SYSTEM_VARIABLE_NODE_ID, SystemVariableKey.QUERY))
                if not query:
-                    raise ValueError("Query not found")
+                    raise VariableNotFoundError("Query not found")
                query = query.text
            else:
                query = None
@@ -161,7 +170,7 @@ class LLMNode(BaseNode[LLMNodeData]):
                    usage = event.usage
                    finish_reason = event.finish_reason
                    break
-        except Exception as e:
+        except LLMNodeError as e:
            yield RunCompletedEvent(
                run_result=NodeRunResult(
                    status=WorkflowNodeExecutionStatus.FAILED,
@@ -275,7 +284,7 @@ class LLMNode(BaseNode[LLMNodeData]):
            variable_name = variable_selector.variable
            variable = self.graph_runtime_state.variable_pool.get(variable_selector.value_selector)
            if variable is None:
-                raise ValueError(f"Variable {variable_selector.variable} not found")
+                raise VariableNotFoundError(f"Variable {variable_selector.variable} not found")

            def parse_dict(input_dict: Mapping[str, Any]) -> str:
                """
@@ -325,7 +334,7 @@ class LLMNode(BaseNode[LLMNodeData]):
        for variable_selector in variable_selectors:
            variable = self.graph_runtime_state.variable_pool.get(variable_selector.value_selector)
            if variable is None:
-                raise ValueError(f"Variable {variable_selector.variable} not found")
+                raise VariableNotFoundError(f"Variable {variable_selector.variable} not found")
            if isinstance(variable, NoneSegment):
                inputs[variable_selector.variable] = ""
            inputs[variable_selector.variable] = variable.to_object()
@@ -338,7 +347,7 @@ class LLMNode(BaseNode[LLMNodeData]):
            for variable_selector in query_variable_selectors:
                variable = self.graph_runtime_state.variable_pool.get(variable_selector.value_selector)
                if variable is None:
-                    raise ValueError(f"Variable {variable_selector.variable} not found")
+                    raise VariableNotFoundError(f"Variable {variable_selector.variable} not found")
                if isinstance(variable, NoneSegment):
                    continue
                inputs[variable_selector.variable] = variable.to_object()
@@ -355,7 +364,7 @@ class LLMNode(BaseNode[LLMNodeData]):
            return variable.value
        elif isinstance(variable, NoneSegment | ArrayAnySegment):
            return []
-        raise ValueError(f"Invalid variable type: {type(variable)}")
+        raise InvalidVariableTypeError(f"Invalid variable type: {type(variable)}")

    def _fetch_context(self, node_data: LLMNodeData):
        if not node_data.context.enabled:
@@ -376,7 +385,7 @@ class LLMNode(BaseNode[LLMNodeData]):
                        context_str += item + "\n"
                    else:
                        if "content" not in item:
-                            raise ValueError(f"Invalid context structure: {item}")
+                            raise InvalidContextStructureError(f"Invalid context structure: {item}")

                        context_str += item["content"] + "\n"

@@ -441,7 +450,7 @@ class LLMNode(BaseNode[LLMNodeData]):
        )

        if provider_model is None:
-            raise ValueError(f"Model {model_name} not exist.")
+            raise ModelNotExistError(f"Model {model_name} not exist.")

        if provider_model.status == ModelStatus.NO_CONFIGURE:
            raise ProviderTokenNotInitError(f"Model {model_name} credentials is not initialized.")
@@ -460,12 +469,12 @@ class LLMNode(BaseNode[LLMNodeData]):
        # get model mode
        model_mode = node_data_model.mode
        if not model_mode:
-            raise ValueError("LLM mode is required.")
+            raise LLMModeRequiredError("LLM mode is required.")

        model_schema = model_type_instance.get_model_schema(model_name, model_credentials)

        if not model_schema:
-            raise ValueError(f"Model {model_name} not exist.")
+            raise ModelNotExistError(f"Model {model_name} not exist.")

        return model_instance, ModelConfigWithCredentialsEntity(
            provider=provider_name,
@@ -564,7 +573,7 @@ class LLMNode(BaseNode[LLMNodeData]):
            filtered_prompt_messages.append(prompt_message)

        if not filtered_prompt_messages:
-            raise ValueError(
+            raise NoPromptFoundError(
                "No prompt found in the LLM configuration. "
                "Please ensure a prompt is properly configured before proceeding."
            )
@@ -636,7 +645,7 @@ class LLMNode(BaseNode[LLMNodeData]):
                variable_template_parser = VariableTemplateParser(template=prompt_template.text)
                variable_selectors = variable_template_parser.extract_variable_selectors()
        else:
-            raise ValueError(f"Invalid prompt template type: {type(prompt_template)}")
+            raise InvalidVariableTypeError(f"Invalid prompt template type: {type(prompt_template)}")

        variable_mapping = {}
        for variable_selector in variable_selectors:
--- a/api/core/workflow/nodes/parameter_extractor/exc.py
+++ b/api/core/workflow/nodes/parameter_extractor/exc.py
@@ -0,0 +1,50 @@
+class ParameterExtractorNodeError(ValueError):
+    """Base error for ParameterExtractorNode."""
+
+
+class InvalidModelTypeError(ParameterExtractorNodeError):
+    """Raised when the model is not a Large Language Model."""
+
+
+class ModelSchemaNotFoundError(ParameterExtractorNodeError):
+    """Raised when the model schema is not found."""
+
+
+class InvalidInvokeResultError(ParameterExtractorNodeError):
+    """Raised when the invoke result is invalid."""
+
+
+class InvalidTextContentTypeError(ParameterExtractorNodeError):
+    """Raised when the text content type is invalid."""
+
+
+class InvalidNumberOfParametersError(ParameterExtractorNodeError):
+    """Raised when the number of parameters is invalid."""
+
+
+class RequiredParameterMissingError(ParameterExtractorNodeError):
+    """Raised when a required parameter is missing."""
+
+
+class InvalidSelectValueError(ParameterExtractorNodeError):
+    """Raised when a select value is invalid."""
+
+
+class InvalidNumberValueError(ParameterExtractorNodeError):
+    """Raised when a number value is invalid."""
+
+
+class InvalidBoolValueError(ParameterExtractorNodeError):
+    """Raised when a bool value is invalid."""
+
+
+class InvalidStringValueError(ParameterExtractorNodeError):
+    """Raised when a string value is invalid."""
+
+
+class InvalidArrayValueError(ParameterExtractorNodeError):
+    """Raised when an array value is invalid."""
+
+
+class InvalidModelModeError(ParameterExtractorNodeError):
+    """Raised when the model mode is invalid."""
--- a/api/core/workflow/nodes/parameter_extractor/parameter_extractor_node.py
+++ b/api/core/workflow/nodes/parameter_extractor/parameter_extractor_node.py
@@ -32,6 +32,21 @@ from extensions.ext_database import db
 from models.workflow import WorkflowNodeExecutionStatus

 from .entities import ParameterExtractorNodeData
+from .exc import (
+    InvalidArrayValueError,
+    InvalidBoolValueError,
+    InvalidInvokeResultError,
+    InvalidModelModeError,
+    InvalidModelTypeError,
+    InvalidNumberOfParametersError,
+    InvalidNumberValueError,
+    InvalidSelectValueError,
+    InvalidStringValueError,
+    InvalidTextContentTypeError,
+    ModelSchemaNotFoundError,
+    ParameterExtractorNodeError,
+    RequiredParameterMissingError,
+)
 from .prompts import (
    CHAT_EXAMPLE,
    CHAT_GENERATE_JSON_USER_MESSAGE_TEMPLATE,
@@ -85,7 +100,7 @@ class ParameterExtractorNode(LLMNode):

        model_instance, model_config = self._fetch_model_config(node_data.model)
        if not isinstance(model_instance.model_type_instance, LargeLanguageModel):
-            raise ValueError("Model is not a Large Language Model")
+            raise InvalidModelTypeError("Model is not a Large Language Model")

        llm_model = model_instance.model_type_instance
        model_schema = llm_model.get_model_schema(
@@ -93,7 +108,7 @@ class ParameterExtractorNode(LLMNode):
            credentials=model_config.credentials,
        )
        if not model_schema:
-            raise ValueError("Model schema not found")
+            raise ModelSchemaNotFoundError("Model schema not found")

        # fetch memory
        memory = self._fetch_memory(
@@ -155,7 +170,7 @@ class ParameterExtractorNode(LLMNode):
            process_data["usage"] = jsonable_encoder(usage)
            process_data["tool_call"] = jsonable_encoder(tool_call)
            process_data["llm_text"] = text
-        except Exception as e:
+        except ParameterExtractorNodeError as e:
            return NodeRunResult(
                status=WorkflowNodeExecutionStatus.FAILED,
                inputs=inputs,
@@ -177,7 +192,7 @@ class ParameterExtractorNode(LLMNode):

        try:
            result = self._validate_result(data=node_data, result=result or {})
-        except Exception as e:
+        except ParameterExtractorNodeError as e:
            error = str(e)

        # transform result into standard format
@@ -217,11 +232,11 @@ class ParameterExtractorNode(LLMNode):

        # handle invoke result
        if not isinstance(invoke_result, LLMResult):
-            raise ValueError(f"Invalid invoke result: {invoke_result}")
+            raise InvalidInvokeResultError(f"Invalid invoke result: {invoke_result}")

        text = invoke_result.message.content
        if not isinstance(text, str):
-            raise ValueError(f"Invalid text content type: {type(text)}. Expected str.")
+            raise InvalidTextContentTypeError(f"Invalid text content type: {type(text)}. Expected str.")

        usage = invoke_result.usage
        tool_call = invoke_result.message.tool_calls[0] if invoke_result.message.tool_calls else None
@@ -344,7 +359,7 @@ class ParameterExtractorNode(LLMNode):
                files=files,
            )
        else:
-            raise ValueError(f"Invalid model mode: {model_mode}")
+            raise InvalidModelModeError(f"Invalid model mode: {model_mode}")

    def _generate_prompt_engineering_completion_prompt(
        self,
@@ -449,36 +464,36 @@ class ParameterExtractorNode(LLMNode):
        Validate result.
        """
        if len(data.parameters) != len(result):
-            raise ValueError("Invalid number of parameters")
+            raise InvalidNumberOfParametersError("Invalid number of parameters")

        for parameter in data.parameters:
            if parameter.required and parameter.name not in result:
-                raise ValueError(f"Parameter {parameter.name} is required")
+                raise RequiredParameterMissingError(f"Parameter {parameter.name} is required")

            if parameter.type == "select" and parameter.options and result.get(parameter.name) not in parameter.options:
-                raise ValueError(f"Invalid `select` value for parameter {parameter.name}")
+                raise InvalidSelectValueError(f"Invalid `select` value for parameter {parameter.name}")

            if parameter.type == "number" and not isinstance(result.get(parameter.name), int | float):
-                raise ValueError(f"Invalid `number` value for parameter {parameter.name}")
+                raise InvalidNumberValueError(f"Invalid `number` value for parameter {parameter.name}")

            if parameter.type == "bool" and not isinstance(result.get(parameter.name), bool):
-                raise ValueError(f"Invalid `bool` value for parameter {parameter.name}")
+                raise InvalidBoolValueError(f"Invalid `bool` value for parameter {parameter.name}")

            if parameter.type == "string" and not isinstance(result.get(parameter.name), str):
-                raise ValueError(f"Invalid `string` value for parameter {parameter.name}")
+                raise InvalidStringValueError(f"Invalid `string` value for parameter {parameter.name}")

            if parameter.type.startswith("array"):
                parameters = result.get(parameter.name)
                if not isinstance(parameters, list):
-                    raise ValueError(f"Invalid `array` value for parameter {parameter.name}")
+                    raise InvalidArrayValueError(f"Invalid `array` value for parameter {parameter.name}")
                nested_type = parameter.type[6:-1]
                for item in parameters:
                    if nested_type == "number" and not isinstance(item, int | float):
-                        raise ValueError(f"Invalid `array[number]` value for parameter {parameter.name}")
+                        raise InvalidArrayValueError(f"Invalid `array[number]` value for parameter {parameter.name}")
                    if nested_type == "string" and not isinstance(item, str):
-                        raise ValueError(f"Invalid `array[string]` value for parameter {parameter.name}")
+                        raise InvalidArrayValueError(f"Invalid `array[string]` value for parameter {parameter.name}")
                    if nested_type == "object" and not isinstance(item, dict):
-                        raise ValueError(f"Invalid `array[object]` value for parameter {parameter.name}")
+                        raise InvalidArrayValueError(f"Invalid `array[object]` value for parameter {parameter.name}")
        return result

    def _transform_result(self, data: ParameterExtractorNodeData, result: dict) -> dict:
@@ -634,7 +649,7 @@ class ParameterExtractorNode(LLMNode):
            user_prompt_message = ChatModelMessage(role=PromptMessageRole.USER, text=input_text)
            return [system_prompt_messages, user_prompt_message]
        else:
-            raise ValueError(f"Model mode {model_mode} not support.")
+            raise InvalidModelModeError(f"Model mode {model_mode} not support.")

    def _get_prompt_engineering_prompt_template(
        self,
@@ -669,7 +684,7 @@ class ParameterExtractorNode(LLMNode):
                .replace("}γγγ", "")
            )
        else:
-            raise ValueError(f"Model mode {model_mode} not support.")
+            raise InvalidModelModeError(f"Model mode {model_mode} not support.")

    def _calculate_rest_token(
        self,
@@ -683,12 +698,12 @@ class ParameterExtractorNode(LLMNode):

        model_instance, model_config = self._fetch_model_config(node_data.model)
        if not isinstance(model_instance.model_type_instance, LargeLanguageModel):
-            raise ValueError("Model is not a Large Language Model")
+            raise InvalidModelTypeError("Model is not a Large Language Model")

        llm_model = model_instance.model_type_instance
        model_schema = llm_model.get_model_schema(model_config.model, model_config.credentials)
        if not model_schema:
-            raise ValueError("Model schema not found")
+            raise ModelSchemaNotFoundError("Model schema not found")

        if set(model_schema.features or []) & {ModelFeature.MULTI_TOOL_CALL, ModelFeature.MULTI_TOOL_CALL}:
            prompt_template = self._get_function_calling_prompt_template(node_data, query, variable_pool, None, 2000)
--- a/api/core/workflow/nodes/tool/tool_node.py
+++ b/api/core/workflow/nodes/tool/tool_node.py
@@ -53,7 +53,7 @@ class ToolNode(BaseNode[ToolNodeData]):
            )

        # get parameters
-        tool_parameters = tool_runtime.get_runtime_parameters() or []
+        tool_parameters = tool_runtime.parameters or []
        parameters = self._generate_parameters(
            tool_parameters=tool_parameters,
            variable_pool=self.graph_runtime_state.variable_pool,
--- a/api/fields/file_fields.py
+++ b/api/fields/file_fields.py
@@ -8,6 +8,7 @@ upload_config_fields = {
    "image_file_size_limit": fields.Integer,
    "video_file_size_limit": fields.Integer,
    "audio_file_size_limit": fields.Integer,
+    "workflow_file_upload_limit": fields.Integer,
 }

 file_fields = {
--- a/api/models/init.py
+++ b/api/models/init.py
@@ -6,7 +6,6 @@ from .model import (
    AppMode,
    Conversation,
    EndUser,
-    FileUploadConfig,
    InstalledApp,
    Message,
    MessageAnnotation,
@@ -50,6 +49,5 @@ __all__ = [
    "Tenant",
    "Conversation",
    "MessageAnnotation",
-    "FileUploadConfig",
    "ToolFile",
 ]
--- a/api/models/model.py
+++ b/api/models/model.py
@@ -1,7 +1,7 @@
 import json
 import re
 import uuid
-from collections.abc import Mapping, Sequence
+from collections.abc import Mapping
 from datetime import datetime
 from enum import Enum
 from typing import Any, Literal, Optional
@@ -9,7 +9,6 @@ from typing import Any, Literal, Optional
 import sqlalchemy as sa
 from flask import request
 from flask_login import UserMixin
-from pydantic import BaseModel, Field
 from sqlalchemy import Float, func, text
 from sqlalchemy.orm import Mapped, mapped_column

@@ -25,14 +24,6 @@ from .account import Account, Tenant
 from .types import StringUUID


-class FileUploadConfig(BaseModel):
-    enabled: bool = Field(default=False)
-    allowed_file_types: Sequence[FileType] = Field(default_factory=list)
-    allowed_extensions: Sequence[str] = Field(default_factory=list)
-    allowed_upload_methods: Sequence[FileTransferMethod] = Field(default_factory=list)
-    number_limits: int = Field(default=0, gt=0, le=10)
-
-
 class DifySetup(db.Model):
    __tablename__ = "dify_setups"
    __table_args__ = (db.PrimaryKeyConstraint("version", name="dify_setup_pkey"),)
@@ -115,7 +106,7 @@ class App(db.Model):
        return site

    @property
-    def app_model_config(self) -> Optional["AppModelConfig"]:
+    def app_model_config(self):
        if self.app_model_config_id:
            return db.session.query(AppModelConfig).filter(AppModelConfig.id == self.app_model_config_id).first()

--- a/api/tests/integration_tests/vdb/lindorm/init.py
+++ b/api/tests/integration_tests/vdb/lindorm/init.py
--- a/api/tests/integration_tests/vdb/lindorm/test_lindorm.py
+++ b/api/tests/integration_tests/vdb/lindorm/test_lindorm.py
@@ -0,0 +1,35 @@
+import environs
+
+from core.rag.datasource.vdb.lindorm.lindorm_vector import LindormVectorStore, LindormVectorStoreConfig
+from tests.integration_tests.vdb.test_vector_store import AbstractVectorTest, setup_mock_redis
+
+env = environs.Env()
+
+
+class Config:
+    SEARCH_ENDPOINT = env.str("SEARCH_ENDPOINT", "http://ld-*************-proxy-search-pub.lindorm.aliyuncs.com:30070")
+    SEARCH_USERNAME = env.str("SEARCH_USERNAME", "ADMIN")
+    SEARCH_PWD = env.str("SEARCH_PWD", "PWD")
+
+
+class TestLindormVectorStore(AbstractVectorTest):
+    def __init__(self):
+        super().__init__()
+        self.vector = LindormVectorStore(
+            collection_name=self.collection_name,
+            config=LindormVectorStoreConfig(
+                hosts=Config.SEARCH_ENDPOINT,
+                username=Config.SEARCH_USERNAME,
+                password=Config.SEARCH_PWD,
+            ),
+        )
+
+    def get_ids_by_metadata_field(self):
+        ids = self.vector.get_ids_by_metadata_field(key="doc_id", value=self.example_doc_id)
+        assert ids is not None
+        assert len(ids) == 1
+        assert ids[0] == self.example_doc_id
+
+
+def test_lindorm_vector(setup_mock_redis):
+    TestLindormVectorStore().run_all_tests()
--- a/api/tests/unit_tests/core/app/apps/test_base_app_generator.py
+++ b/api/tests/unit_tests/core/app/apps/test_base_app_generator.py
@@ -0,0 +1,52 @@
+import pytest
+
+from core.app.app_config.entities import VariableEntity, VariableEntityType
+from core.app.apps.base_app_generator import BaseAppGenerator
+
+
+def test_validate_inputs_with_zero():
+    base_app_generator = BaseAppGenerator()
+
+    var = VariableEntity(
+        variable="test_var",
+        label="test_var",
+        type=VariableEntityType.NUMBER,
+        required=True,
+    )
+
+    # Test with input 0
+    result = base_app_generator._validate_inputs(
+        variable_entity=var,
+        value=0,
+    )
+
+    assert result == 0
+
+    # Test with input "0" (string)
+    result = base_app_generator._validate_inputs(
+        variable_entity=var,
+        value="0",
+    )
+
+    assert result == 0
+
+
+def test_validate_input_with_none_for_required_variable():
+    base_app_generator = BaseAppGenerator()
+
+    for var_type in VariableEntityType:
+        var = VariableEntity(
+            variable="test_var",
+            label="test_var",
+            type=var_type,
+            required=True,
+        )
+
+        # Test with input None
+        with pytest.raises(ValueError) as exc_info:
+            base_app_generator._validate_inputs(
+                variable_entity=var,
+                value=None,
+            )
+
+        assert str(exc_info.value) == "test_var is required in input form"
--- a/dev/reformat
+++ b/dev/reformat
@@ -9,10 +9,10 @@ if ! command -v ruff &> /dev/null || ! command -v dotenv-linter &> /dev/null; th
 fi

 # run ruff linter
-ruff check --fix ./api
+poetry run -C api ruff check --fix ./api

 # run ruff formatter
-ruff format ./api
+poetry run -C api ruff format ./api

 # run dotenv-linter linter
-dotenv-linter ./api/.env.example ./web/.env.example
+poetry run -C api dotenv-linter ./api/.env.example ./web/.env.example
--- a/docker/.env.example
+++ b/docker/.env.example
@@ -222,7 +222,6 @@ REDIS_PORT=6379
 REDIS_USERNAME=
 REDIS_PASSWORD=difyai123456
 REDIS_USE_SSL=false
-REDIS_DB=0

 # Whether to use Redis Sentinel mode.
 # If set to true, the application will automatically discover and connect to the master node through Sentinel.
@@ -531,6 +530,12 @@ VIKINGDB_SCHEMA=http
 VIKINGDB_CONNECTION_TIMEOUT=30
 VIKINGDB_SOCKET_TIMEOUT=30

+
+# Lindorm configuration, only available when VECTOR_STORE is `lindorm`
+LINDORM_URL=http://ld-***************-proxy-search-pub.lindorm.aliyuncs.com:30070
+LINDORM_USERNAME=username
+LINDORM_PASSWORD=password
+
 # OceanBase Vector configuration, only available when VECTOR_STORE is `oceanbase`
 OCEANBASE_VECTOR_HOST=oceanbase-vector
 OCEANBASE_VECTOR_PORT=2881
@@ -645,7 +650,6 @@ MAIL_DEFAULT_SEND_FROM=

 # API-Key for the Resend email provider, used when MAIL_TYPE is `resend`.
 RESEND_API_KEY=your-resend-api-key
-RESEND_API_URL=https://api.resend.com

 # SMTP server configuration, used when MAIL_TYPE is `smtp`
 SMTP_SERVER=
@@ -686,6 +690,7 @@ WORKFLOW_MAX_EXECUTION_STEPS=500
 WORKFLOW_MAX_EXECUTION_TIME=1200
 WORKFLOW_CALL_MAX_DEPTH=5
 MAX_VARIABLE_SIZE=204800
+WORKFLOW_FILE_UPLOAD_LIMIT=10

 # HTTP request node in workflow configuration
 HTTP_REQUEST_NODE_MAX_BINARY_SIZE=10485760
--- a/docker/docker-compose.yaml
+++ b/docker/docker-compose.yaml
@@ -1,4 +1,5 @@
 x-shared-env: &shared-api-worker-env
+  WORKFLOW_FILE_UPLOAD_LIMIT: ${WORKFLOW_FILE_UPLOAD_LIMIT:-10}
  LOG_LEVEL: ${LOG_LEVEL:-INFO}
  LOG_FILE: ${LOG_FILE:-}
  LOG_FILE_MAX_SIZE: ${LOG_FILE_MAX_SIZE:-20}
@@ -167,6 +168,9 @@ x-shared-env: &shared-api-worker-env
  ELASTICSEARCH_PORT: ${ELASTICSEARCH_PORT:-9200}
  ELASTICSEARCH_USERNAME: ${ELASTICSEARCH_USERNAME:-elastic}
  ELASTICSEARCH_PASSWORD: ${ELASTICSEARCH_PASSWORD:-elastic}
+  LINDORM_URL: ${LINDORM_URL:-http://lindorm:30070}
+  LINDORM_USERNAME: ${LINDORM_USERNAME:-lindorm}
+  LINDORM_PASSWORD: ${LINDORM_USERNAME:-lindorm }
  KIBANA_PORT: ${KIBANA_PORT:-5601}
  # AnalyticDB configuration
  ANALYTICDB_KEY_ID: ${ANALYTICDB_KEY_ID:-}
--- a/web/app/components/base/file-uploader/constants.ts
+++ b/web/app/components/base/file-uploader/constants.ts
@@ -3,5 +3,6 @@ export const IMG_SIZE_LIMIT = 10 * 1024 * 1024
 export const FILE_SIZE_LIMIT = 15 * 1024 * 1024
 export const AUDIO_SIZE_LIMIT = 50 * 1024 * 1024
 export const VIDEO_SIZE_LIMIT = 100 * 1024 * 1024
+export const MAX_FILE_UPLOAD_LIMIT = 10

 export const FILE_URL_REGEX = /^(https?|ftp):\/\//
--- a/web/app/components/base/file-uploader/hooks.ts
+++ b/web/app/components/base/file-uploader/hooks.ts
@@ -18,6 +18,7 @@ import {
  AUDIO_SIZE_LIMIT,
  FILE_SIZE_LIMIT,
  IMG_SIZE_LIMIT,
+  MAX_FILE_UPLOAD_LIMIT,
  VIDEO_SIZE_LIMIT,
 } from '@/app/components/base/file-uploader/constants'
 import { useToastContext } from '@/app/components/base/toast'
@@ -33,12 +34,14 @@ export const useFileSizeLimit = (fileUploadConfig?: FileUploadConfigResponse) =>
  const docSizeLimit = Number(fileUploadConfig?.file_size_limit) * 1024 * 1024 || FILE_SIZE_LIMIT
  const audioSizeLimit = Number(fileUploadConfig?.audio_file_size_limit) * 1024 * 1024 || AUDIO_SIZE_LIMIT
  const videoSizeLimit = Number(fileUploadConfig?.video_file_size_limit) * 1024 * 1024 || VIDEO_SIZE_LIMIT
+  const maxFileUploadLimit = Number(fileUploadConfig?.workflow_file_upload_limit) || MAX_FILE_UPLOAD_LIMIT

  return {
    imgSizeLimit,
    docSizeLimit,
    audioSizeLimit,
    videoSizeLimit,
+    maxFileUploadLimit,
  }
 }

--- a/web/app/components/workflow/nodes/_base/components/file-upload-setting.tsx
+++ b/web/app/components/workflow/nodes/_base/components/file-upload-setting.tsx
@@ -39,7 +39,13 @@ const FileUploadSetting: FC<Props> = ({
    allowed_file_extensions,
  } = payload
  const { data: fileUploadConfigResponse } = useSWR({ url: '/files/upload' }, fetchFileUploadConfig)
-  const { imgSizeLimit, docSizeLimit, audioSizeLimit, videoSizeLimit } = useFileSizeLimit(fileUploadConfigResponse)
+  const {
+    imgSizeLimit,
+    docSizeLimit,
+    audioSizeLimit,
+    videoSizeLimit,
+    maxFileUploadLimit,
+  } = useFileSizeLimit(fileUploadConfigResponse)

  const handleSupportFileTypeChange = useCallback((type: SupportUploadFileTypes) => {
    const newPayload = produce(payload, (draft) => {
@@ -156,7 +162,7 @@ const FileUploadSetting: FC<Props> = ({
            <InputNumberWithSlider
              value={max_length}
              min={1}
-              max={10}
+              max={maxFileUploadLimit}
              onChange={handleMaxUploadNumLimitChange}
            />
          </div>
--- a/web/i18n/ja-JP/app.ts
+++ b/web/i18n/ja-JP/app.ts
@@ -39,10 +39,10 @@ const translation = {
    workflowWarning: '現在ベータ版です',
    chatbotType: 'チャットボットのオーケストレーション方法',
    basic: '基本',
-    basicTip: '初心者向け。後で Chatflow に切り替えることができます',
+    basicTip: '初心者向け。後で「チャットフロー」に切り替えることができます',
    basicFor: '初心者向け',
    basicDescription: '基本オーケストレートは、組み込みのプロンプトを変更する機能がなく、簡単な設定を使用してチャットボット アプリをオーケストレートします。初心者向けです。',
-    advanced: 'Chatflow',
+    advanced: 'チャットフロー',
    advancedFor: '上級ユーザー向け',
    advancedDescription: 'ワークフロー オーケストレートは、ワークフロー形式でチャットボットをオーケストレートし、組み込みのプロンプトを編集する機能を含む高度なカスタマイズを提供します。経験豊富なユーザー向けです。',
    captionName: 'アプリのアイコンと名前',
--- a/web/models/common.ts
+++ b/web/models/common.ts
@@ -216,7 +216,7 @@ export type FileUploadConfigResponse = {
  file_size_limit: number // default is 15MB
  audio_file_size_limit?: number // default is 50MB
  video_file_size_limit?: number // default is 100MB
-
+  workflow_file_upload_limit?: number // default is 10
 }

 export type InvitationResult = {
Author	SHA1	Message	Date
-LAN-	195a2acaf5	fix(parameter_extractor): use graph runtime state variable pool in prompt generation	2024-11-04 20:33:47 +08:00
-LAN-	a088a1b02f	refactor(parameter_extractor): implement custom error classes - Introduced specific error classes for robust error handling. - Enhanced error clarity by replacing generic ValueErrors with custom exceptions. - Improved exception management in `ParameterExtractorNode` for better debugging and maintenance.	2024-11-04 20:24:09 +08:00
guogeer	971defbbbd	fix: buitin tool aippt (#10234 ) Co-authored-by: jinqi.guo <jinqi.guo@ubtrobot.com>	2024-11-04 18:46:39 +08:00
-LAN-	6b0de08157	fix(validation): allow to use 0 in the inputs form (#10255 )	2024-11-04 18:34:55 +08:00
-LAN-	87c1de66f2	chore(Dockerfile): upgrade zlib arm64 (#10244 )	2024-11-04 17:48:10 +08:00
方程	2aa171c348	Using a dedicated interface to obtain the token credential for the gitee.ai provider (#10243 )	2024-11-04 17:22:02 +08:00
-LAN-	6452342222	feat(workflow): add configurable workflow file upload limit (#10176 ) Co-authored-by: JzoNg <jzongcode@gmail.com>	2024-11-04 15:55:34 +08:00
shisaru292	da204c131d	fix: missing working directory parameter in script (#10226 )	2024-11-04 15:23:18 +08:00
-LAN-	9369cc44e6	refactor(list_operator): replace ValueError with InvalidKeyError (#10222 )	2024-11-04 15:23:08 +08:00
-LAN-	38bca6731c	refactor(workflow): introduce specific error handling for LLM nodes (#10221 )	2024-11-04 15:22:58 +08:00
-LAN-	2adab7f71a	refactor(http_request): add custom exception handling for HTTP request nodes (#10219 )	2024-11-04 15:22:50 +08:00
-LAN-	be96f6e62d	refactor(workflow): introduce specific exceptions for code validation (#10218 )	2024-11-04 15:22:41 +08:00
-LAN-	8b5ea39916	chore(llm_node): remove unnecessary type ignore for context assignment (#10216 )	2024-11-04 15:22:31 +08:00
Jyong	1024fc623e	fix the ssrf of docx file extractor external images (#10237 )	2024-11-04 15:22:07 +08:00
Hanqing Zhao	8ab05d4c36	Modify translation (#10213 )	2024-11-04 09:11:15 +08:00
Jiang	0c9e79cd67	Add Lindorm as a VDB choice (#10202 ) Co-authored-by: jiangzhijie <jiangzhijie.jzj@alibaba-inc.com>	2024-11-04 09:10:26 +08:00