dify

dify/api/configs/middleware/__init__.py

@@ -0,0 +1,366 @@
+import os
+from typing import Any, Literal
+from urllib.parse import parse_qsl, quote_plus
+
+from pydantic import Field, NonNegativeFloat, NonNegativeInt, PositiveFloat, PositiveInt, computed_field
+from pydantic_settings import BaseSettings
+
+from .cache.redis_config import RedisConfig
+from .storage.aliyun_oss_storage_config import AliyunOSSStorageConfig
+from .storage.amazon_s3_storage_config import S3StorageConfig
+from .storage.azure_blob_storage_config import AzureBlobStorageConfig
+from .storage.baidu_obs_storage_config import BaiduOBSStorageConfig
+from .storage.clickzetta_volume_storage_config import ClickZettaVolumeStorageConfig
+from .storage.google_cloud_storage_config import GoogleCloudStorageConfig
+from .storage.huawei_obs_storage_config import HuaweiCloudOBSStorageConfig
+from .storage.oci_storage_config import OCIStorageConfig
+from .storage.opendal_storage_config import OpenDALStorageConfig
+from .storage.supabase_storage_config import SupabaseStorageConfig
+from .storage.tencent_cos_storage_config import TencentCloudCOSStorageConfig
+from .storage.volcengine_tos_storage_config import VolcengineTOSStorageConfig
+from .vdb.alibabacloud_mysql_config import AlibabaCloudMySQLConfig
+from .vdb.analyticdb_config import AnalyticdbConfig
+from .vdb.baidu_vector_config import BaiduVectorDBConfig
+from .vdb.chroma_config import ChromaConfig
+from .vdb.clickzetta_config import ClickzettaConfig
+from .vdb.couchbase_config import CouchbaseConfig
+from .vdb.elasticsearch_config import ElasticsearchConfig
+from .vdb.huawei_cloud_config import HuaweiCloudConfig
+from .vdb.lindorm_config import LindormConfig
+from .vdb.matrixone_config import MatrixoneConfig
+from .vdb.milvus_config import MilvusConfig
+from .vdb.myscale_config import MyScaleConfig
+from .vdb.oceanbase_config import OceanBaseVectorConfig
+from .vdb.opengauss_config import OpenGaussConfig
+from .vdb.opensearch_config import OpenSearchConfig
+from .vdb.oracle_config import OracleConfig
+from .vdb.pgvector_config import PGVectorConfig
+from .vdb.pgvectors_config import PGVectoRSConfig
+from .vdb.qdrant_config import QdrantConfig
+from .vdb.relyt_config import RelytConfig
+from .vdb.tablestore_config import TableStoreConfig
+from .vdb.tencent_vector_config import TencentVectorDBConfig
+from .vdb.tidb_on_qdrant_config import TidbOnQdrantConfig
+from .vdb.tidb_vector_config import TiDBVectorConfig
+from .vdb.upstash_config import UpstashConfig
+from .vdb.vastbase_vector_config import VastbaseVectorConfig
+from .vdb.vikingdb_config import VikingDBConfig
+from .vdb.weaviate_config import WeaviateConfig
+
+
+class StorageConfig(BaseSettings):
+    STORAGE_TYPE: Literal[
+        "opendal",
+        "s3",
+        "aliyun-oss",
+        "azure-blob",
+        "baidu-obs",
+        "clickzetta-volume",
+        "google-storage",
+        "huawei-obs",
+        "oci-storage",
+        "tencent-cos",
+        "volcengine-tos",
+        "supabase",
+        "local",
+    ] = Field(
+        description="Type of storage to use."
+        " Options: 'opendal', '(deprecated) local', 's3', 'aliyun-oss', 'azure-blob', 'baidu-obs', "
+        "'clickzetta-volume', 'google-storage', 'huawei-obs', 'oci-storage', 'tencent-cos', "
+        "'volcengine-tos', 'supabase'. Default is 'opendal'.",
+        default="opendal",
+    )
+
+    STORAGE_LOCAL_PATH: str = Field(
+        description="Path for local storage when STORAGE_TYPE is set to 'local'.",
+        default="storage",
+        deprecated=True,
+    )
+
+
+class VectorStoreConfig(BaseSettings):
+    VECTOR_STORE: str | None = Field(
+        description="Type of vector store to use for efficient similarity search."
+        " Set to None if not using a vector store.",
+        default=None,
+    )
+
+    VECTOR_STORE_WHITELIST_ENABLE: bool | None = Field(
+        description="Enable whitelist for vector store.",
+        default=False,
+    )
+
+    VECTOR_INDEX_NAME_PREFIX: str | None = Field(
+        description="Prefix used to create collection name in vector database",
+        default="Vector_index",
+    )
+
+
+class KeywordStoreConfig(BaseSettings):
+    KEYWORD_STORE: str = Field(
+        description="Method for keyword extraction and storage."
+        " Default is 'jieba', a Chinese text segmentation library.",
+        default="jieba",
+    )
+
+
+class DatabaseConfig(BaseSettings):
+    # Database type selector
+    DB_TYPE: Literal["postgresql", "mysql", "oceanbase"] = Field(
+        description="Database type to use. OceanBase is MySQL-compatible.",
+        default="postgresql",
+    )
+
+    DB_HOST: str = Field(
+        description="Hostname or IP address of the database server.",
+        default="localhost",
+    )
+
+    DB_PORT: PositiveInt = Field(
+        description="Port number for database connection.",
+        default=5432,
+    )
+
+    DB_USERNAME: str = Field(
+        description="Username for database authentication.",
+        default="postgres",
+    )
+
+    DB_PASSWORD: str = Field(
+        description="Password for database authentication.",
+        default="",
+    )
+
+    DB_DATABASE: str = Field(
+        description="Name of the database to connect to.",
+        default="dify",
+    )
+
+    DB_CHARSET: str = Field(
+        description="Character set for database connection.",
+        default="",
+    )
+
+    DB_EXTRAS: str = Field(
+        description="Additional database connection parameters. Example: 'keepalives_idle=60&keepalives=1'",
+        default="",
+    )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def SQLALCHEMY_DATABASE_URI_SCHEME(self) -> str:
+        return "postgresql" if self.DB_TYPE == "postgresql" else "mysql+pymysql"
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def SQLALCHEMY_DATABASE_URI(self) -> str:
+        db_extras = (
+            f"{self.DB_EXTRAS}&client_encoding={self.DB_CHARSET}" if self.DB_CHARSET else self.DB_EXTRAS
+        ).strip("&")
+        db_extras = f"?{db_extras}" if db_extras else ""
+        return (
+            f"{self.SQLALCHEMY_DATABASE_URI_SCHEME}://"
+            f"{quote_plus(self.DB_USERNAME)}:{quote_plus(self.DB_PASSWORD)}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_DATABASE}"
+            f"{db_extras}"
+        )
+
+    SQLALCHEMY_POOL_SIZE: NonNegativeInt = Field(
+        description="Maximum number of database connections in the pool.",
+        default=30,
+    )
+
+    SQLALCHEMY_MAX_OVERFLOW: NonNegativeInt = Field(
+        description="Maximum number of connections that can be created beyond the pool_size.",
+        default=10,
+    )
+
+    SQLALCHEMY_POOL_RECYCLE: NonNegativeInt = Field(
+        description="Number of seconds after which a connection is automatically recycled.",
+        default=3600,
+    )
+
+    SQLALCHEMY_POOL_USE_LIFO: bool = Field(
+        description="If True, SQLAlchemy will use last-in-first-out way to retrieve connections from pool.",
+        default=False,
+    )
+
+    SQLALCHEMY_POOL_PRE_PING: bool = Field(
+        description="If True, enables connection pool pre-ping feature to check connections.",
+        default=False,
+    )
+
+    SQLALCHEMY_ECHO: bool | str = Field(
+        description="If True, SQLAlchemy will log all SQL statements.",
+        default=False,
+    )
+
+    SQLALCHEMY_POOL_TIMEOUT: NonNegativeInt = Field(
+        description="Number of seconds to wait for a connection from the pool before raising a timeout error.",
+        default=30,
+    )
+
+    RETRIEVAL_SERVICE_EXECUTORS: NonNegativeInt = Field(
+        description="Number of processes for the retrieval service, default to CPU cores.",
+        default=os.cpu_count() or 1,
+    )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def SQLALCHEMY_ENGINE_OPTIONS(self) -> dict[str, Any]:
+        # Parse DB_EXTRAS for 'options'
+        db_extras_dict = dict(parse_qsl(self.DB_EXTRAS))
+        options = db_extras_dict.get("options", "")
+        connect_args = {}
+        # Use the dynamic SQLALCHEMY_DATABASE_URI_SCHEME property
+        if self.SQLALCHEMY_DATABASE_URI_SCHEME.startswith("postgresql"):
+            timezone_opt = "-c timezone=UTC"
+            if options:
+                merged_options = f"{options} {timezone_opt}"
+            else:
+                merged_options = timezone_opt
+            connect_args = {"options": merged_options}
+
+        return {
+            "pool_size": self.SQLALCHEMY_POOL_SIZE,
+            "max_overflow": self.SQLALCHEMY_MAX_OVERFLOW,
+            "pool_recycle": self.SQLALCHEMY_POOL_RECYCLE,
+            "pool_pre_ping": self.SQLALCHEMY_POOL_PRE_PING,
+            "connect_args": connect_args,
+            "pool_use_lifo": self.SQLALCHEMY_POOL_USE_LIFO,
+            "pool_reset_on_return": None,
+            "pool_timeout": self.SQLALCHEMY_POOL_TIMEOUT,
+        }
+
+
+class CeleryConfig(DatabaseConfig):
+    CELERY_BACKEND: str = Field(
+        description="Backend for Celery task results. Options: 'database', 'redis', 'rabbitmq'.",
+        default="redis",
+    )
+
+    CELERY_BROKER_URL: str | None = Field(
+        description="URL of the message broker for Celery tasks.",
+        default=None,
+    )
+
+    CELERY_USE_SENTINEL: bool | None = Field(
+        description="Whether to use Redis Sentinel for high availability.",
+        default=False,
+    )
+
+    CELERY_SENTINEL_MASTER_NAME: str | None = Field(
+        description="Name of the Redis Sentinel master.",
+        default=None,
+    )
+
+    CELERY_SENTINEL_PASSWORD: str | None = Field(
+        description="Password of the Redis Sentinel master.",
+        default=None,
+    )
+    CELERY_SENTINEL_SOCKET_TIMEOUT: PositiveFloat | None = Field(
+        description="Timeout for Redis Sentinel socket operations in seconds.",
+        default=0.1,
+    )
+
+    @computed_field
+    def CELERY_RESULT_BACKEND(self) -> str | None:
+        if self.CELERY_BACKEND in ("database", "rabbitmq"):
+            return f"db+{self.SQLALCHEMY_DATABASE_URI}"
+        elif self.CELERY_BACKEND == "redis":
+            return self.CELERY_BROKER_URL
+        else:
+            return None
+
+    @property
+    def BROKER_USE_SSL(self) -> bool:
+        return self.CELERY_BROKER_URL.startswith("rediss://") if self.CELERY_BROKER_URL else False
+
+
+class InternalTestConfig(BaseSettings):
+    """
+    Configuration settings for Internal Test
+    """
+
+    AWS_SECRET_ACCESS_KEY: str | None = Field(
+        description="Internal test AWS secret access key",
+        default=None,
+    )
+
+    AWS_ACCESS_KEY_ID: str | None = Field(
+        description="Internal test AWS access key ID",
+        default=None,
+    )
+
+
+class DatasetQueueMonitorConfig(BaseSettings):
+    """
+    Configuration settings for Dataset Queue Monitor
+    """
+
+    QUEUE_MONITOR_THRESHOLD: NonNegativeInt | None = Field(
+        description="Threshold for dataset queue monitor",
+        default=200,
+    )
+    QUEUE_MONITOR_ALERT_EMAILS: str | None = Field(
+        description="Emails for dataset queue monitor alert, separated by commas",
+        default=None,
+    )
+    QUEUE_MONITOR_INTERVAL: NonNegativeFloat | None = Field(
+        description="Interval for dataset queue monitor in minutes",
+        default=30,
+    )
+
+
+class MiddlewareConfig(
+    # place the configs in alphabet order
+    CeleryConfig,  # Note: CeleryConfig already inherits from DatabaseConfig
+    KeywordStoreConfig,
+    RedisConfig,
+    # configs of storage and storage providers
+    StorageConfig,
+    AliyunOSSStorageConfig,
+    AzureBlobStorageConfig,
+    BaiduOBSStorageConfig,
+    ClickZettaVolumeStorageConfig,
+    GoogleCloudStorageConfig,
+    HuaweiCloudOBSStorageConfig,
+    OCIStorageConfig,
+    OpenDALStorageConfig,
+    S3StorageConfig,
+    SupabaseStorageConfig,
+    TencentCloudCOSStorageConfig,
+    VolcengineTOSStorageConfig,
+    # configs of vdb and vdb providers
+    VectorStoreConfig,
+    AnalyticdbConfig,
+    ChromaConfig,
+    ClickzettaConfig,
+    HuaweiCloudConfig,
+    MilvusConfig,
+    AlibabaCloudMySQLConfig,
+    MyScaleConfig,
+    OpenSearchConfig,
+    OracleConfig,
+    PGVectorConfig,
+    VastbaseVectorConfig,
+    PGVectoRSConfig,
+    QdrantConfig,
+    RelytConfig,
+    TencentVectorDBConfig,
+    TiDBVectorConfig,
+    WeaviateConfig,
+    ElasticsearchConfig,
+    CouchbaseConfig,
+    InternalTestConfig,
+    VikingDBConfig,
+    UpstashConfig,
+    TidbOnQdrantConfig,
+    LindormConfig,
+    OceanBaseVectorConfig,
+    BaiduVectorDBConfig,
+    OpenGaussConfig,
+    TableStoreConfig,
+    DatasetQueueMonitorConfig,
+    MatrixoneConfig,
+):
+    pass

dify/api/configs/middleware/cache/redis_config.py

@@ -0,0 +1,113 @@
+from pydantic import Field, NonNegativeInt, PositiveFloat, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class RedisConfig(BaseSettings):
+    """
+    Configuration settings for Redis connection
+    """
+
+    REDIS_HOST: str = Field(
+        description="Hostname or IP address of the Redis server",
+        default="localhost",
+    )
+
+    REDIS_PORT: PositiveInt = Field(
+        description="Port number on which the Redis server is listening",
+        default=6379,
+    )
+
+    REDIS_USERNAME: str | None = Field(
+        description="Username for Redis authentication (if required)",
+        default=None,
+    )
+
+    REDIS_PASSWORD: str | None = Field(
+        description="Password for Redis authentication (if required)",
+        default=None,
+    )
+
+    REDIS_DB: NonNegativeInt = Field(
+        description="Redis database number to use (0-15)",
+        default=0,
+    )
+
+    REDIS_USE_SSL: bool = Field(
+        description="Enable SSL/TLS for the Redis connection",
+        default=False,
+    )
+
+    REDIS_SSL_CERT_REQS: str = Field(
+        description="SSL certificate requirements (CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED)",
+        default="CERT_NONE",
+    )
+
+    REDIS_SSL_CA_CERTS: str | None = Field(
+        description="Path to the CA certificate file for SSL verification",
+        default=None,
+    )
+
+    REDIS_SSL_CERTFILE: str | None = Field(
+        description="Path to the client certificate file for SSL authentication",
+        default=None,
+    )
+
+    REDIS_SSL_KEYFILE: str | None = Field(
+        description="Path to the client private key file for SSL authentication",
+        default=None,
+    )
+
+    REDIS_USE_SENTINEL: bool | None = Field(
+        description="Enable Redis Sentinel mode for high availability",
+        default=False,
+    )
+
+    REDIS_SENTINELS: str | None = Field(
+        description="Comma-separated list of Redis Sentinel nodes (host:port)",
+        default=None,
+    )
+
+    REDIS_SENTINEL_SERVICE_NAME: str | None = Field(
+        description="Name of the Redis Sentinel service to monitor",
+        default=None,
+    )
+
+    REDIS_SENTINEL_USERNAME: str | None = Field(
+        description="Username for Redis Sentinel authentication (if required)",
+        default=None,
+    )
+
+    REDIS_SENTINEL_PASSWORD: str | None = Field(
+        description="Password for Redis Sentinel authentication (if required)",
+        default=None,
+    )
+
+    REDIS_SENTINEL_SOCKET_TIMEOUT: PositiveFloat | None = Field(
+        description="Socket timeout in seconds for Redis Sentinel connections",
+        default=0.1,
+    )
+
+    REDIS_USE_CLUSTERS: bool = Field(
+        description="Enable Redis Clusters mode for high availability",
+        default=False,
+    )
+
+    REDIS_CLUSTERS: str | None = Field(
+        description="Comma-separated list of Redis Clusters nodes (host:port)",
+        default=None,
+    )
+
+    REDIS_CLUSTERS_PASSWORD: str | None = Field(
+        description="Password for Redis Clusters authentication (if required)",
+        default=None,
+    )
+
+    REDIS_SERIALIZATION_PROTOCOL: int = Field(
+        description="Redis serialization protocol (RESP) version",
+        default=3,
+    )
+
+    REDIS_ENABLE_CLIENT_SIDE_CACHE: bool = Field(
+        description="Enable client side cache in redis",
+        default=False,
+    )

dify/api/configs/middleware/storage/aliyun_oss_storage_config.py

@@ -0,0 +1,43 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class AliyunOSSStorageConfig(BaseSettings):
+    """
+    Configuration settings for Aliyun Object Storage Service (OSS)
+    """
+
+    ALIYUN_OSS_BUCKET_NAME: str | None = Field(
+        description="Name of the Aliyun OSS bucket to store and retrieve objects",
+        default=None,
+    )
+
+    ALIYUN_OSS_ACCESS_KEY: str | None = Field(
+        description="Access key ID for authenticating with Aliyun OSS",
+        default=None,
+    )
+
+    ALIYUN_OSS_SECRET_KEY: str | None = Field(
+        description="Secret access key for authenticating with Aliyun OSS",
+        default=None,
+    )
+
+    ALIYUN_OSS_ENDPOINT: str | None = Field(
+        description="URL of the Aliyun OSS endpoint for your chosen region",
+        default=None,
+    )
+
+    ALIYUN_OSS_REGION: str | None = Field(
+        description="Aliyun OSS region where your bucket is located (e.g., 'oss-cn-hangzhou')",
+        default=None,
+    )
+
+    ALIYUN_OSS_AUTH_VERSION: str | None = Field(
+        description="Version of the authentication protocol to use with Aliyun OSS (e.g., 'v4')",
+        default=None,
+    )
+
+    ALIYUN_OSS_PATH: str | None = Field(
+        description="Base path within the bucket to store objects (e.g., 'my-app-data/')",
+        default=None,
+    )

dify/api/configs/middleware/storage/amazon_s3_storage_config.py

@@ -0,0 +1,45 @@
+from typing import Literal
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class S3StorageConfig(BaseSettings):
+    """
+    Configuration settings for S3-compatible object storage
+    """
+
+    S3_ENDPOINT: str | None = Field(
+        description="URL of the S3-compatible storage endpoint (e.g., 'https://s3.amazonaws.com')",
+        default=None,
+    )
+
+    S3_REGION: str | None = Field(
+        description="Region where the S3 bucket is located (e.g., 'us-east-1')",
+        default=None,
+    )
+
+    S3_BUCKET_NAME: str | None = Field(
+        description="Name of the S3 bucket to store and retrieve objects",
+        default=None,
+    )
+
+    S3_ACCESS_KEY: str | None = Field(
+        description="Access key ID for authenticating with the S3 service",
+        default=None,
+    )
+
+    S3_SECRET_KEY: str | None = Field(
+        description="Secret access key for authenticating with the S3 service",
+        default=None,
+    )
+
+    S3_ADDRESS_STYLE: Literal["auto", "virtual", "path"] = Field(
+        description="S3 addressing style: 'auto', 'path', or 'virtual'",
+        default="auto",
+    )
+
+    S3_USE_AWS_MANAGED_IAM: bool = Field(
+        description="Use AWS managed IAM roles for authentication instead of access/secret keys",
+        default=False,
+    )

dify/api/configs/middleware/storage/azure_blob_storage_config.py

@@ -0,0 +1,28 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class AzureBlobStorageConfig(BaseSettings):
+    """
+    Configuration settings for Azure Blob Storage
+    """
+
+    AZURE_BLOB_ACCOUNT_NAME: str | None = Field(
+        description="Name of the Azure Storage account (e.g., 'mystorageaccount')",
+        default=None,
+    )
+
+    AZURE_BLOB_ACCOUNT_KEY: str | None = Field(
+        description="Access key for authenticating with the Azure Storage account",
+        default=None,
+    )
+
+    AZURE_BLOB_CONTAINER_NAME: str | None = Field(
+        description="Name of the Azure Blob container to store and retrieve objects",
+        default=None,
+    )
+
+    AZURE_BLOB_ACCOUNT_URL: str | None = Field(
+        description="URL of the Azure Blob storage endpoint (e.g., 'https://mystorageaccount.blob.core.windows.net')",
+        default=None,
+    )

dify/api/configs/middleware/storage/baidu_obs_storage_config.py

@@ -0,0 +1,28 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class BaiduOBSStorageConfig(BaseSettings):
+    """
+    Configuration settings for Baidu Object Storage Service (OBS)
+    """
+
+    BAIDU_OBS_BUCKET_NAME: str | None = Field(
+        description="Name of the Baidu OBS bucket to store and retrieve objects (e.g., 'my-obs-bucket')",
+        default=None,
+    )
+
+    BAIDU_OBS_ACCESS_KEY: str | None = Field(
+        description="Access Key ID for authenticating with Baidu OBS",
+        default=None,
+    )
+
+    BAIDU_OBS_SECRET_KEY: str | None = Field(
+        description="Secret Access Key for authenticating with Baidu OBS",
+        default=None,
+    )
+
+    BAIDU_OBS_ENDPOINT: str | None = Field(
+        description="URL of the Baidu OSS endpoint for your chosen region (e.g., 'https://.bj.bcebos.com')",
+        default=None,
+    )

dify/api/configs/middleware/storage/clickzetta_volume_storage_config.py

@@ -0,0 +1,63 @@
+"""ClickZetta Volume Storage Configuration"""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class ClickZettaVolumeStorageConfig(BaseSettings):
+    """Configuration for ClickZetta Volume storage."""
+
+    CLICKZETTA_VOLUME_USERNAME: str | None = Field(
+        description="Username for ClickZetta Volume authentication",
+        default=None,
+    )
+
+    CLICKZETTA_VOLUME_PASSWORD: str | None = Field(
+        description="Password for ClickZetta Volume authentication",
+        default=None,
+    )
+
+    CLICKZETTA_VOLUME_INSTANCE: str | None = Field(
+        description="ClickZetta instance identifier",
+        default=None,
+    )
+
+    CLICKZETTA_VOLUME_SERVICE: str = Field(
+        description="ClickZetta service endpoint",
+        default="api.clickzetta.com",
+    )
+
+    CLICKZETTA_VOLUME_WORKSPACE: str = Field(
+        description="ClickZetta workspace name",
+        default="quick_start",
+    )
+
+    CLICKZETTA_VOLUME_VCLUSTER: str = Field(
+        description="ClickZetta virtual cluster name",
+        default="default_ap",
+    )
+
+    CLICKZETTA_VOLUME_SCHEMA: str = Field(
+        description="ClickZetta schema name",
+        default="dify",
+    )
+
+    CLICKZETTA_VOLUME_TYPE: str = Field(
+        description="ClickZetta volume type (table|user|external)",
+        default="user",
+    )
+
+    CLICKZETTA_VOLUME_NAME: str | None = Field(
+        description="ClickZetta volume name for external volumes",
+        default=None,
+    )
+
+    CLICKZETTA_VOLUME_TABLE_PREFIX: str = Field(
+        description="Prefix for ClickZetta volume table names",
+        default="dataset_",
+    )
+
+    CLICKZETTA_VOLUME_DIFY_PREFIX: str = Field(
+        description="Directory prefix for User Volume to organize Dify files",
+        default="dify_km",
+    )

dify/api/configs/middleware/storage/google_cloud_storage_config.py

@@ -0,0 +1,18 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class GoogleCloudStorageConfig(BaseSettings):
+    """
+    Configuration settings for Google Cloud Storage
+    """
+
+    GOOGLE_STORAGE_BUCKET_NAME: str | None = Field(
+        description="Name of the Google Cloud Storage bucket to store and retrieve objects (e.g., 'my-gcs-bucket')",
+        default=None,
+    )
+
+    GOOGLE_STORAGE_SERVICE_ACCOUNT_JSON_BASE64: str | None = Field(
+        description="Base64-encoded JSON key file for Google Cloud service account authentication",
+        default=None,
+    )

dify/api/configs/middleware/storage/huawei_obs_storage_config.py

@@ -0,0 +1,28 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class HuaweiCloudOBSStorageConfig(BaseSettings):
+    """
+    Configuration settings for Huawei Cloud Object Storage Service (OBS)
+    """
+
+    HUAWEI_OBS_BUCKET_NAME: str | None = Field(
+        description="Name of the Huawei Cloud OBS bucket to store and retrieve objects (e.g., 'my-obs-bucket')",
+        default=None,
+    )
+
+    HUAWEI_OBS_ACCESS_KEY: str | None = Field(
+        description="Access Key ID for authenticating with Huawei Cloud OBS",
+        default=None,
+    )
+
+    HUAWEI_OBS_SECRET_KEY: str | None = Field(
+        description="Secret Access Key for authenticating with Huawei Cloud OBS",
+        default=None,
+    )
+
+    HUAWEI_OBS_SERVER: str | None = Field(
+        description="Endpoint URL for Huawei Cloud OBS (e.g., 'https://obs.cn-north-4.myhuaweicloud.com')",
+        default=None,
+    )

dify/api/configs/middleware/storage/oci_storage_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class OCIStorageConfig(BaseSettings):
+    """
+    Configuration settings for Oracle Cloud Infrastructure (OCI) Object Storage
+    """
+
+    OCI_ENDPOINT: str | None = Field(
+        description="URL of the OCI Object Storage endpoint (e.g., 'https://objectstorage.us-phoenix-1.oraclecloud.com')",
+        default=None,
+    )
+
+    OCI_REGION: str | None = Field(
+        description="OCI region where the bucket is located (e.g., 'us-phoenix-1')",
+        default=None,
+    )
+
+    OCI_BUCKET_NAME: str | None = Field(
+        description="Name of the OCI Object Storage bucket to store and retrieve objects (e.g., 'my-oci-bucket')",
+        default=None,
+    )
+
+    OCI_ACCESS_KEY: str | None = Field(
+        description="Access key (also known as API key) for authenticating with OCI Object Storage",
+        default=None,
+    )
+
+    OCI_SECRET_KEY: str | None = Field(
+        description="Secret key associated with the access key for authenticating with OCI Object Storage",
+        default=None,
+    )

dify/api/configs/middleware/storage/opendal_storage_config.py

@@ -0,0 +1,9 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class OpenDALStorageConfig(BaseSettings):
+    OPENDAL_SCHEME: str = Field(
+        default="fs",
+        description="OpenDAL scheme.",
+    )

dify/api/configs/middleware/storage/supabase_storage_config.py

@@ -0,0 +1,23 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class SupabaseStorageConfig(BaseSettings):
+    """
+    Configuration settings for Supabase Object Storage Service
+    """
+
+    SUPABASE_BUCKET_NAME: str | None = Field(
+        description="Name of the Supabase bucket to store and retrieve objects (e.g., 'dify-bucket')",
+        default=None,
+    )
+
+    SUPABASE_API_KEY: str | None = Field(
+        description="API KEY for authenticating with Supabase",
+        default=None,
+    )
+
+    SUPABASE_URL: str | None = Field(
+        description="URL of the Supabase",
+        default=None,
+    )

dify/api/configs/middleware/storage/tencent_cos_storage_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class TencentCloudCOSStorageConfig(BaseSettings):
+    """
+    Configuration settings for Tencent Cloud Object Storage (COS)
+    """
+
+    TENCENT_COS_BUCKET_NAME: str | None = Field(
+        description="Name of the Tencent Cloud COS bucket to store and retrieve objects",
+        default=None,
+    )
+
+    TENCENT_COS_REGION: str | None = Field(
+        description="Tencent Cloud region where the COS bucket is located (e.g., 'ap-guangzhou')",
+        default=None,
+    )
+
+    TENCENT_COS_SECRET_ID: str | None = Field(
+        description="SecretId for authenticating with Tencent Cloud COS (part of API credentials)",
+        default=None,
+    )
+
+    TENCENT_COS_SECRET_KEY: str | None = Field(
+        description="SecretKey for authenticating with Tencent Cloud COS (part of API credentials)",
+        default=None,
+    )
+
+    TENCENT_COS_SCHEME: str | None = Field(
+        description="Protocol scheme for COS requests: 'https' (recommended) or 'http'",
+        default=None,
+    )

dify/api/configs/middleware/storage/volcengine_tos_storage_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class VolcengineTOSStorageConfig(BaseSettings):
+    """
+    Configuration settings for Volcengine Tinder Object Storage (TOS)
+    """
+
+    VOLCENGINE_TOS_BUCKET_NAME: str | None = Field(
+        description="Name of the Volcengine TOS bucket to store and retrieve objects (e.g., 'my-tos-bucket')",
+        default=None,
+    )
+
+    VOLCENGINE_TOS_ACCESS_KEY: str | None = Field(
+        description="Access Key ID for authenticating with Volcengine TOS",
+        default=None,
+    )
+
+    VOLCENGINE_TOS_SECRET_KEY: str | None = Field(
+        description="Secret Access Key for authenticating with Volcengine TOS",
+        default=None,
+    )
+
+    VOLCENGINE_TOS_ENDPOINT: str | None = Field(
+        description="URL of the Volcengine TOS endpoint (e.g., 'https://tos-cn-beijing.volces.com')",
+        default=None,
+    )
+
+    VOLCENGINE_TOS_REGION: str | None = Field(
+        description="Volcengine region where the TOS bucket is located (e.g., 'cn-beijing')",
+        default=None,
+    )

dify/api/configs/middleware/vdb/alibabacloud_mysql_config.py

@@ -0,0 +1,54 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class AlibabaCloudMySQLConfig(BaseSettings):
+    """
+    Configuration settings for AlibabaCloud MySQL vector database
+    """
+
+    ALIBABACLOUD_MYSQL_HOST: str = Field(
+        description="Hostname or IP address of the AlibabaCloud MySQL server (e.g., 'localhost' or 'mysql.aliyun.com')",
+        default="localhost",
+    )
+
+    ALIBABACLOUD_MYSQL_PORT: PositiveInt = Field(
+        description="Port number on which the AlibabaCloud MySQL server is listening (default is 3306)",
+        default=3306,
+    )
+
+    ALIBABACLOUD_MYSQL_USER: str = Field(
+        description="Username for authenticating with AlibabaCloud MySQL (default is 'root')",
+        default="root",
+    )
+
+    ALIBABACLOUD_MYSQL_PASSWORD: str = Field(
+        description="Password for authenticating with AlibabaCloud MySQL (default is an empty string)",
+        default="",
+    )
+
+    ALIBABACLOUD_MYSQL_DATABASE: str = Field(
+        description="Name of the AlibabaCloud MySQL database to connect to (default is 'dify')",
+        default="dify",
+    )
+
+    ALIBABACLOUD_MYSQL_MAX_CONNECTION: PositiveInt = Field(
+        description="Maximum number of connections in the connection pool",
+        default=5,
+    )
+
+    ALIBABACLOUD_MYSQL_CHARSET: str = Field(
+        description="Character set for AlibabaCloud MySQL connection (default is 'utf8mb4')",
+        default="utf8mb4",
+    )
+
+    ALIBABACLOUD_MYSQL_DISTANCE_FUNCTION: str = Field(
+        description="Distance function used for vector similarity search in AlibabaCloud MySQL "
+        "(e.g., 'cosine', 'euclidean')",
+        default="cosine",
+    )
+
+    ALIBABACLOUD_MYSQL_HNSW_M: PositiveInt = Field(
+        description="Maximum number of connections per layer for HNSW vector index (default is 6, range: 3-200)",
+        default=6,
+    )

dify/api/configs/middleware/vdb/analyticdb_config.py

@@ -0,0 +1,49 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class AnalyticdbConfig(BaseSettings):
+    """
+    Configuration for connecting to Alibaba Cloud AnalyticDB for PostgreSQL.
+    Refer to the following documentation for details on obtaining credentials:
+    https://www.alibabacloud.com/help/en/analyticdb-for-postgresql/getting-started/create-an-instance-instances-with-vector-engine-optimization-enabled
+    """
+
+    ANALYTICDB_KEY_ID: str | None = Field(
+        default=None, description="The Access Key ID provided by Alibaba Cloud for API authentication."
+    )
+    ANALYTICDB_KEY_SECRET: str | None = Field(
+        default=None, description="The Secret Access Key corresponding to the Access Key ID for secure API access."
+    )
+    ANALYTICDB_REGION_ID: str | None = Field(
+        default=None,
+        description="The region where the AnalyticDB instance is deployed (e.g., 'cn-hangzhou', 'ap-southeast-1').",
+    )
+    ANALYTICDB_INSTANCE_ID: str | None = Field(
+        default=None,
+        description="The unique identifier of the AnalyticDB instance you want to connect to.",
+    )
+    ANALYTICDB_ACCOUNT: str | None = Field(
+        default=None,
+        description="The account name used to log in to the AnalyticDB instance"
+        " (usually the initial account created with the instance).",
+    )
+    ANALYTICDB_PASSWORD: str | None = Field(
+        default=None, description="The password associated with the AnalyticDB account for database authentication."
+    )
+    ANALYTICDB_NAMESPACE: str | None = Field(
+        default=None, description="The namespace within AnalyticDB for schema isolation (if using namespace feature)."
+    )
+    ANALYTICDB_NAMESPACE_PASSWORD: str | None = Field(
+        default=None,
+        description="The password for accessing the specified namespace within the AnalyticDB instance"
+        " (if namespace feature is enabled).",
+    )
+    ANALYTICDB_HOST: str | None = Field(
+        default=None, description="The host of the AnalyticDB instance you want to connect to."
+    )
+    ANALYTICDB_PORT: PositiveInt = Field(
+        default=5432, description="The port of the AnalyticDB instance you want to connect to."
+    )
+    ANALYTICDB_MIN_CONNECTION: PositiveInt = Field(default=1, description="Min connection of the AnalyticDB database.")
+    ANALYTICDB_MAX_CONNECTION: PositiveInt = Field(default=5, description="Max connection of the AnalyticDB database.")

dify/api/configs/middleware/vdb/baidu_vector_config.py

@@ -0,0 +1,53 @@
+from pydantic import Field, NonNegativeInt, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class BaiduVectorDBConfig(BaseSettings):
+    """
+    Configuration settings for Baidu Vector Database
+    """
+
+    BAIDU_VECTOR_DB_ENDPOINT: str | None = Field(
+        description="URL of the Baidu Vector Database service (e.g., 'http://vdb.bj.baidubce.com')",
+        default=None,
+    )
+
+    BAIDU_VECTOR_DB_CONNECTION_TIMEOUT_MS: PositiveInt = Field(
+        description="Timeout in milliseconds for Baidu Vector Database operations (default is 30000 milliseconds)",
+        default=30000,
+    )
+
+    BAIDU_VECTOR_DB_ACCOUNT: str | None = Field(
+        description="Account for authenticating with the Baidu Vector Database",
+        default=None,
+    )
+
+    BAIDU_VECTOR_DB_API_KEY: str | None = Field(
+        description="API key for authenticating with the Baidu Vector Database service",
+        default=None,
+    )
+
+    BAIDU_VECTOR_DB_DATABASE: str | None = Field(
+        description="Name of the specific Baidu Vector Database to connect to",
+        default=None,
+    )
+
+    BAIDU_VECTOR_DB_SHARD: PositiveInt = Field(
+        description="Number of shards for the Baidu Vector Database (default is 1)",
+        default=1,
+    )
+
+    BAIDU_VECTOR_DB_REPLICAS: NonNegativeInt = Field(
+        description="Number of replicas for the Baidu Vector Database (default is 3)",
+        default=3,
+    )
+
+    BAIDU_VECTOR_DB_INVERTED_INDEX_ANALYZER: str = Field(
+        description="Analyzer type for inverted index in Baidu Vector Database (default is DEFAULT_ANALYZER)",
+        default="DEFAULT_ANALYZER",
+    )
+
+    BAIDU_VECTOR_DB_INVERTED_INDEX_PARSER_MODE: str = Field(
+        description="Parser mode for inverted index in Baidu Vector Database (default is COARSE_MODE)",
+        default="COARSE_MODE",
+    )

dify/api/configs/middleware/vdb/chroma_config.py

@@ -0,0 +1,38 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class ChromaConfig(BaseSettings):
+    """
+    Configuration settings for Chroma vector database
+    """
+
+    CHROMA_HOST: str | None = Field(
+        description="Hostname or IP address of the Chroma server (e.g., 'localhost' or '192.168.1.100')",
+        default=None,
+    )
+
+    CHROMA_PORT: PositiveInt = Field(
+        description="Port number on which the Chroma server is listening (default is 8000)",
+        default=8000,
+    )
+
+    CHROMA_TENANT: str | None = Field(
+        description="Tenant identifier for multi-tenancy support in Chroma",
+        default=None,
+    )
+
+    CHROMA_DATABASE: str | None = Field(
+        description="Name of the Chroma database to connect to",
+        default=None,
+    )
+
+    CHROMA_AUTH_PROVIDER: str | None = Field(
+        description="Authentication provider for Chroma (e.g., 'basic', 'token', or a custom provider)",
+        default=None,
+    )
+
+    CHROMA_AUTH_CREDENTIALS: str | None = Field(
+        description="Authentication credentials for Chroma (format depends on the auth provider)",
+        default=None,
+    )

dify/api/configs/middleware/vdb/clickzetta_config.py

@@ -0,0 +1,68 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class ClickzettaConfig(BaseSettings):
+    """
+    Clickzetta Lakehouse vector database configuration
+    """
+
+    CLICKZETTA_USERNAME: str | None = Field(
+        description="Username for authenticating with Clickzetta Lakehouse",
+        default=None,
+    )
+
+    CLICKZETTA_PASSWORD: str | None = Field(
+        description="Password for authenticating with Clickzetta Lakehouse",
+        default=None,
+    )
+
+    CLICKZETTA_INSTANCE: str | None = Field(
+        description="Clickzetta Lakehouse instance ID",
+        default=None,
+    )
+
+    CLICKZETTA_SERVICE: str | None = Field(
+        description="Clickzetta API service endpoint (e.g., 'api.clickzetta.com')",
+        default="api.clickzetta.com",
+    )
+
+    CLICKZETTA_WORKSPACE: str | None = Field(
+        description="Clickzetta workspace name",
+        default="default",
+    )
+
+    CLICKZETTA_VCLUSTER: str | None = Field(
+        description="Clickzetta virtual cluster name",
+        default="default_ap",
+    )
+
+    CLICKZETTA_SCHEMA: str | None = Field(
+        description="Database schema name in Clickzetta",
+        default="public",
+    )
+
+    CLICKZETTA_BATCH_SIZE: int | None = Field(
+        description="Batch size for bulk insert operations",
+        default=100,
+    )
+
+    CLICKZETTA_ENABLE_INVERTED_INDEX: bool | None = Field(
+        description="Enable inverted index for full-text search capabilities",
+        default=True,
+    )
+
+    CLICKZETTA_ANALYZER_TYPE: str | None = Field(
+        description="Analyzer type for full-text search: keyword, english, chinese, unicode",
+        default="chinese",
+    )
+
+    CLICKZETTA_ANALYZER_MODE: str | None = Field(
+        description="Analyzer mode for tokenization: max_word (fine-grained) or smart (intelligent)",
+        default="smart",
+    )
+
+    CLICKZETTA_VECTOR_DISTANCE_FUNCTION: str | None = Field(
+        description="Distance function for vector similarity: l2_distance or cosine_distance",
+        default="cosine_distance",
+    )

dify/api/configs/middleware/vdb/couchbase_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class CouchbaseConfig(BaseSettings):
+    """
+    Couchbase configs
+    """
+
+    COUCHBASE_CONNECTION_STRING: str | None = Field(
+        description="COUCHBASE connection string",
+        default=None,
+    )
+
+    COUCHBASE_USER: str | None = Field(
+        description="COUCHBASE user",
+        default=None,
+    )
+
+    COUCHBASE_PASSWORD: str | None = Field(
+        description="COUCHBASE password",
+        default=None,
+    )
+
+    COUCHBASE_BUCKET_NAME: str | None = Field(
+        description="COUCHBASE bucket name",
+        default=None,
+    )
+
+    COUCHBASE_SCOPE_NAME: str | None = Field(
+        description="COUCHBASE scope name",
+        default=None,
+    )

dify/api/configs/middleware/vdb/elasticsearch_config.py

@@ -0,0 +1,74 @@
+from pydantic import Field, PositiveInt, model_validator
+from pydantic_settings import BaseSettings
+
+
+class ElasticsearchConfig(BaseSettings):
+    """
+    Configuration settings for both self-managed and Elastic Cloud deployments.
+    Can load from environment variables or .env files.
+    """
+
+    ELASTICSEARCH_HOST: str | None = Field(
+        description="Hostname or IP address of the Elasticsearch server (e.g., 'localhost' or '192.168.1.100')",
+        default="127.0.0.1",
+    )
+
+    ELASTICSEARCH_PORT: PositiveInt = Field(
+        description="Port number on which the Elasticsearch server is listening (default is 9200)",
+        default=9200,
+    )
+
+    ELASTICSEARCH_USERNAME: str | None = Field(
+        description="Username for authenticating with Elasticsearch (default is 'elastic')",
+        default="elastic",
+    )
+
+    ELASTICSEARCH_PASSWORD: str | None = Field(
+        description="Password for authenticating with Elasticsearch (default is 'elastic')",
+        default="elastic",
+    )
+
+    # Elastic Cloud (optional)
+    ELASTICSEARCH_USE_CLOUD: bool | None = Field(
+        description="Set to True to use Elastic Cloud instead of self-hosted Elasticsearch", default=False
+    )
+    ELASTICSEARCH_CLOUD_URL: str | None = Field(
+        description="Full URL for Elastic Cloud deployment (e.g., 'https://example.es.region.aws.found.io:443')",
+        default=None,
+    )
+    ELASTICSEARCH_API_KEY: str | None = Field(description="API key for authenticating with Elastic Cloud", default=None)
+
+    # Common options
+    ELASTICSEARCH_CA_CERTS: str | None = Field(
+        description="Path to CA certificate file for SSL verification", default=None
+    )
+    ELASTICSEARCH_VERIFY_CERTS: bool = Field(
+        description="Whether to verify SSL certificates (default is False)", default=False
+    )
+    ELASTICSEARCH_REQUEST_TIMEOUT: int = Field(
+        description="Request timeout in milliseconds (default is 100000)", default=100000
+    )
+    ELASTICSEARCH_RETRY_ON_TIMEOUT: bool = Field(
+        description="Whether to retry requests on timeout (default is True)", default=True
+    )
+    ELASTICSEARCH_MAX_RETRIES: int = Field(
+        description="Maximum number of retry attempts (default is 10000)", default=10000
+    )
+
+    @model_validator(mode="after")
+    def validate_elasticsearch_config(self):
+        """Validate Elasticsearch configuration based on deployment type."""
+        if self.ELASTICSEARCH_USE_CLOUD:
+            if not self.ELASTICSEARCH_CLOUD_URL:
+                raise ValueError("ELASTICSEARCH_CLOUD_URL is required when using Elastic Cloud")
+            if not self.ELASTICSEARCH_API_KEY:
+                raise ValueError("ELASTICSEARCH_API_KEY is required when using Elastic Cloud")
+        else:
+            if not self.ELASTICSEARCH_HOST:
+                raise ValueError("ELASTICSEARCH_HOST is required for self-hosted Elasticsearch")
+            if not self.ELASTICSEARCH_USERNAME:
+                raise ValueError("ELASTICSEARCH_USERNAME is required for self-hosted Elasticsearch")
+            if not self.ELASTICSEARCH_PASSWORD:
+                raise ValueError("ELASTICSEARCH_PASSWORD is required for self-hosted Elasticsearch")
+
+        return self

dify/api/configs/middleware/vdb/huawei_cloud_config.py

@@ -0,0 +1,23 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class HuaweiCloudConfig(BaseSettings):
+    """
+    Configuration settings for Huawei cloud search service
+    """
+
+    HUAWEI_CLOUD_HOSTS: str | None = Field(
+        description="Hostname or IP address of the Huawei cloud search service instance",
+        default=None,
+    )
+
+    HUAWEI_CLOUD_USER: str | None = Field(
+        description="Username for authenticating with Huawei cloud search service",
+        default=None,
+    )
+
+    HUAWEI_CLOUD_PASSWORD: str | None = Field(
+        description="Password for authenticating with Huawei cloud search service",
+        default=None,
+    )

dify/api/configs/middleware/vdb/lindorm_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class LindormConfig(BaseSettings):
+    """
+    Lindorm configs
+    """
+
+    LINDORM_URL: str | None = Field(
+        description="Lindorm url",
+        default=None,
+    )
+    LINDORM_USERNAME: str | None = Field(
+        description="Lindorm user",
+        default=None,
+    )
+    LINDORM_PASSWORD: str | None = Field(
+        description="Lindorm password",
+        default=None,
+    )
+    LINDORM_INDEX_TYPE: str | None = Field(
+        description="Lindorm Vector Index Type, hnsw or flat is available in dify",
+        default="hnsw",
+    )
+    LINDORM_DISTANCE_TYPE: str | None = Field(
+        description="Vector Distance Type, support l2, cosinesimil, innerproduct", default="l2"
+    )
+    LINDORM_USING_UGC: bool | None = Field(
+        description="Using UGC index will store indexes with the same IndexType/Dimension in a single big index.",
+        default=True,
+    )
+    LINDORM_QUERY_TIMEOUT: float | None = Field(description="The lindorm search request timeout (s)", default=2.0)

dify/api/configs/middleware/vdb/matrixone_config.py

@@ -0,0 +1,15 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class MatrixoneConfig(BaseSettings):
+    """Matrixone vector database configuration."""
+
+    MATRIXONE_HOST: str = Field(default="localhost", description="Host address of the Matrixone server")
+    MATRIXONE_PORT: int = Field(default=6001, description="Port number of the Matrixone server")
+    MATRIXONE_USER: str = Field(default="dump", description="Username for authenticating with Matrixone")
+    MATRIXONE_PASSWORD: str = Field(default="111", description="Password for authenticating with Matrixone")
+    MATRIXONE_DATABASE: str = Field(default="dify", description="Name of the Matrixone database to connect to")
+    MATRIXONE_METRIC: str = Field(
+        default="l2", description="Distance metric type for vector similarity search (cosine or l2)"
+    )

dify/api/configs/middleware/vdb/milvus_config.py

@@ -0,0 +1,44 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class MilvusConfig(BaseSettings):
+    """
+    Configuration settings for Milvus vector database
+    """
+
+    MILVUS_URI: str | None = Field(
+        description="URI for connecting to the Milvus server (e.g., 'http://localhost:19530' or 'https://milvus-instance.example.com:19530')",
+        default="http://127.0.0.1:19530",
+    )
+
+    MILVUS_TOKEN: str | None = Field(
+        description="Authentication token for Milvus, if token-based authentication is enabled",
+        default=None,
+    )
+
+    MILVUS_USER: str | None = Field(
+        description="Username for authenticating with Milvus, if username/password authentication is enabled",
+        default=None,
+    )
+
+    MILVUS_PASSWORD: str | None = Field(
+        description="Password for authenticating with Milvus, if username/password authentication is enabled",
+        default=None,
+    )
+
+    MILVUS_DATABASE: str = Field(
+        description="Name of the Milvus database to connect to (default is 'default')",
+        default="default",
+    )
+
+    MILVUS_ENABLE_HYBRID_SEARCH: bool = Field(
+        description="Enable hybrid search features (requires Milvus >= 2.5.0). Set to false for compatibility with "
+        "older versions",
+        default=True,
+    )
+
+    MILVUS_ANALYZER_PARAMS: str | None = Field(
+        description='Milvus text analyzer parameters, e.g., {"type": "chinese"} for Chinese segmentation support.',
+        default=None,
+    )

dify/api/configs/middleware/vdb/myscale_config.py

@@ -0,0 +1,38 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class MyScaleConfig(BaseSettings):
+    """
+    Configuration settings for MyScale vector database
+    """
+
+    MYSCALE_HOST: str = Field(
+        description="Hostname or IP address of the MyScale server (e.g., 'localhost' or 'myscale.example.com')",
+        default="localhost",
+    )
+
+    MYSCALE_PORT: PositiveInt = Field(
+        description="Port number on which the MyScale server is listening (default is 8123)",
+        default=8123,
+    )
+
+    MYSCALE_USER: str = Field(
+        description="Username for authenticating with MyScale (default is 'default')",
+        default="default",
+    )
+
+    MYSCALE_PASSWORD: str = Field(
+        description="Password for authenticating with MyScale (default is an empty string)",
+        default="",
+    )
+
+    MYSCALE_DATABASE: str = Field(
+        description="Name of the MyScale database to connect to (default is 'default')",
+        default="default",
+    )
+
+    MYSCALE_FTS_PARAMS: str = Field(
+        description="Additional parameters for MyScale Full Text Search index)",
+        default="",
+    )

dify/api/configs/middleware/vdb/oceanbase_config.py

@@ -0,0 +1,51 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class OceanBaseVectorConfig(BaseSettings):
+    """
+    Configuration settings for OceanBase Vector database
+    """
+
+    OCEANBASE_VECTOR_HOST: str | None = Field(
+        description="Hostname or IP address of the OceanBase Vector server (e.g. 'localhost')",
+        default=None,
+    )
+
+    OCEANBASE_VECTOR_PORT: PositiveInt | None = Field(
+        description="Port number on which the OceanBase Vector server is listening (default is 2881)",
+        default=2881,
+    )
+
+    OCEANBASE_VECTOR_USER: str | None = Field(
+        description="Username for authenticating with the OceanBase Vector database",
+        default=None,
+    )
+
+    OCEANBASE_VECTOR_PASSWORD: str | None = Field(
+        description="Password for authenticating with the OceanBase Vector database",
+        default=None,
+    )
+
+    OCEANBASE_VECTOR_DATABASE: str | None = Field(
+        description="Name of the OceanBase Vector database to connect to",
+        default=None,
+    )
+
+    OCEANBASE_ENABLE_HYBRID_SEARCH: bool = Field(
+        description="Enable hybrid search features (requires OceanBase >= 4.3.5.1). Set to false for compatibility "
+        "with older versions",
+        default=False,
+    )
+
+    OCEANBASE_FULLTEXT_PARSER: str | None = Field(
+        description=(
+            "Fulltext parser to use for text indexing. "
+            "Built-in options: 'ngram' (N-gram tokenizer for English/numbers), "
+            "'beng' (Basic English tokenizer), 'space' (Space-based tokenizer), "
+            "'ngram2' (Improved N-gram tokenizer), 'ik' (Chinese tokenizer). "
+            "External plugins (require installation): 'japanese_ftparser' (Japanese tokenizer), "
+            "'thai_ftparser' (Thai tokenizer). Default is 'ik'"
+        ),
+        default="ik",
+    )

dify/api/configs/middleware/vdb/opengauss_config.py

@@ -0,0 +1,48 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class OpenGaussConfig(BaseSettings):
+    """
+    Configuration settings for OpenGauss
+    """
+
+    OPENGAUSS_HOST: str | None = Field(
+        description="Hostname or IP address of the OpenGauss server(e.g., 'localhost')",
+        default=None,
+    )
+
+    OPENGAUSS_PORT: PositiveInt = Field(
+        description="Port number on which the OpenGauss server is listening (default is 6600)",
+        default=6600,
+    )
+
+    OPENGAUSS_USER: str | None = Field(
+        description="Username for authenticating with the OpenGauss database",
+        default=None,
+    )
+
+    OPENGAUSS_PASSWORD: str | None = Field(
+        description="Password for authenticating with the OpenGauss database",
+        default=None,
+    )
+
+    OPENGAUSS_DATABASE: str | None = Field(
+        description="Name of the OpenGauss database to connect to",
+        default=None,
+    )
+
+    OPENGAUSS_MIN_CONNECTION: PositiveInt = Field(
+        description="Min connection of the OpenGauss database",
+        default=1,
+    )
+
+    OPENGAUSS_MAX_CONNECTION: PositiveInt = Field(
+        description="Max connection of the OpenGauss database",
+        default=5,
+    )
+
+    OPENGAUSS_ENABLE_PQ: bool = Field(
+        description="Enable openGauss PQ acceleration feature",
+        default=False,
+    )

dify/api/configs/middleware/vdb/opensearch_config.py

@@ -0,0 +1,64 @@
+from enum import StrEnum
+from typing import Literal
+
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class AuthMethod(StrEnum):
+    """
+    Authentication method for OpenSearch
+    """
+
+    BASIC = "basic"
+    AWS_MANAGED_IAM = "aws_managed_iam"
+
+
+class OpenSearchConfig(BaseSettings):
+    """
+    Configuration settings for OpenSearch
+    """
+
+    OPENSEARCH_HOST: str | None = Field(
+        description="Hostname or IP address of the OpenSearch server (e.g., 'localhost' or 'opensearch.example.com')",
+        default=None,
+    )
+
+    OPENSEARCH_PORT: PositiveInt = Field(
+        description="Port number on which the OpenSearch server is listening (default is 9200)",
+        default=9200,
+    )
+
+    OPENSEARCH_SECURE: bool = Field(
+        description="Whether to use SSL/TLS encrypted connection for OpenSearch (True for HTTPS, False for HTTP)",
+        default=False,
+    )
+
+    OPENSEARCH_VERIFY_CERTS: bool = Field(
+        description="Whether to verify SSL certificates for HTTPS connections (recommended to set True in production)",
+        default=True,
+    )
+
+    OPENSEARCH_AUTH_METHOD: AuthMethod = Field(
+        description="Authentication method for OpenSearch connection (default is 'basic')",
+        default=AuthMethod.BASIC,
+    )
+
+    OPENSEARCH_USER: str | None = Field(
+        description="Username for authenticating with OpenSearch",
+        default=None,
+    )
+
+    OPENSEARCH_PASSWORD: str | None = Field(
+        description="Password for authenticating with OpenSearch",
+        default=None,
+    )
+
+    OPENSEARCH_AWS_REGION: str | None = Field(
+        description="AWS region for OpenSearch (e.g. 'us-west-2')",
+        default=None,
+    )
+
+    OPENSEARCH_AWS_SERVICE: Literal["es", "aoss"] | None = Field(
+        description="AWS service for OpenSearch (e.g. 'aoss' for OpenSearch Serverless)", default=None
+    )

dify/api/configs/middleware/vdb/oracle_config.py

@@ -0,0 +1,44 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class OracleConfig(BaseSettings):
+    """
+    Configuration settings for Oracle database
+    """
+
+    ORACLE_USER: str | None = Field(
+        description="Username for authenticating with the Oracle database",
+        default=None,
+    )
+
+    ORACLE_PASSWORD: str | None = Field(
+        description="Password for authenticating with the Oracle database",
+        default=None,
+    )
+
+    ORACLE_DSN: str | None = Field(
+        description="Oracle database connection string. For traditional database, use format 'host:port/service_name'. "
+        "For autonomous database, use the service name from tnsnames.ora in the wallet",
+        default=None,
+    )
+
+    ORACLE_CONFIG_DIR: str | None = Field(
+        description="Directory containing the tnsnames.ora configuration file. Only used in thin mode connection",
+        default=None,
+    )
+
+    ORACLE_WALLET_LOCATION: str | None = Field(
+        description="Oracle wallet directory path containing the wallet files for secure connection",
+        default=None,
+    )
+
+    ORACLE_WALLET_PASSWORD: str | None = Field(
+        description="Password to decrypt the Oracle wallet, if it is encrypted",
+        default=None,
+    )
+
+    ORACLE_IS_AUTONOMOUS: bool = Field(
+        description="Flag indicating whether connecting to Oracle Autonomous Database",
+        default=False,
+    )

dify/api/configs/middleware/vdb/pgvector_config.py

@@ -0,0 +1,48 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class PGVectorConfig(BaseSettings):
+    """
+    Configuration settings for PGVector (PostgreSQL with vector extension)
+    """
+
+    PGVECTOR_HOST: str | None = Field(
+        description="Hostname or IP address of the PostgreSQL server with PGVector extension (e.g., 'localhost')",
+        default=None,
+    )
+
+    PGVECTOR_PORT: PositiveInt = Field(
+        description="Port number on which the PostgreSQL server is listening (default is 5433)",
+        default=5433,
+    )
+
+    PGVECTOR_USER: str | None = Field(
+        description="Username for authenticating with the PostgreSQL database",
+        default=None,
+    )
+
+    PGVECTOR_PASSWORD: str | None = Field(
+        description="Password for authenticating with the PostgreSQL database",
+        default=None,
+    )
+
+    PGVECTOR_DATABASE: str | None = Field(
+        description="Name of the PostgreSQL database to connect to",
+        default=None,
+    )
+
+    PGVECTOR_MIN_CONNECTION: PositiveInt = Field(
+        description="Min connection of the PostgreSQL database",
+        default=1,
+    )
+
+    PGVECTOR_MAX_CONNECTION: PositiveInt = Field(
+        description="Max connection of the PostgreSQL database",
+        default=5,
+    )
+
+    PGVECTOR_PG_BIGM: bool = Field(
+        description="Whether to use pg_bigm module for full text search",
+        default=False,
+    )

dify/api/configs/middleware/vdb/pgvectors_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class PGVectoRSConfig(BaseSettings):
+    """
+    Configuration settings for PGVecto.RS (Rust-based vector extension for PostgreSQL)
+    """
+
+    PGVECTO_RS_HOST: str | None = Field(
+        description="Hostname or IP address of the PostgreSQL server with PGVecto.RS extension (e.g., 'localhost')",
+        default=None,
+    )
+
+    PGVECTO_RS_PORT: PositiveInt = Field(
+        description="Port number on which the PostgreSQL server with PGVecto.RS is listening (default is 5431)",
+        default=5431,
+    )
+
+    PGVECTO_RS_USER: str | None = Field(
+        description="Username for authenticating with the PostgreSQL database using PGVecto.RS",
+        default=None,
+    )
+
+    PGVECTO_RS_PASSWORD: str | None = Field(
+        description="Password for authenticating with the PostgreSQL database using PGVecto.RS",
+        default=None,
+    )
+
+    PGVECTO_RS_DATABASE: str | None = Field(
+        description="Name of the PostgreSQL database with PGVecto.RS extension to connect to",
+        default=None,
+    )

dify/api/configs/middleware/vdb/qdrant_config.py

@@ -0,0 +1,38 @@
+from pydantic import Field, NonNegativeInt, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class QdrantConfig(BaseSettings):
+    """
+    Configuration settings for Qdrant vector database
+    """
+
+    QDRANT_URL: str | None = Field(
+        description="URL of the Qdrant server (e.g., 'http://localhost:6333' or 'https://qdrant.example.com')",
+        default=None,
+    )
+
+    QDRANT_API_KEY: str | None = Field(
+        description="API key for authenticating with the Qdrant server",
+        default=None,
+    )
+
+    QDRANT_CLIENT_TIMEOUT: NonNegativeInt = Field(
+        description="Timeout in seconds for Qdrant client operations (default is 20 seconds)",
+        default=20,
+    )
+
+    QDRANT_GRPC_ENABLED: bool = Field(
+        description="Whether to enable gRPC support for Qdrant connection (True for gRPC, False for HTTP)",
+        default=False,
+    )
+
+    QDRANT_GRPC_PORT: PositiveInt = Field(
+        description="Port number for gRPC connection to Qdrant server (default is 6334)",
+        default=6334,
+    )
+
+    QDRANT_REPLICATION_FACTOR: PositiveInt = Field(
+        description="Replication factor for Qdrant collections (default is 1)",
+        default=1,
+    )

dify/api/configs/middleware/vdb/relyt_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class RelytConfig(BaseSettings):
+    """
+    Configuration settings for Relyt database
+    """
+
+    RELYT_HOST: str | None = Field(
+        description="Hostname or IP address of the Relyt server (e.g., 'localhost' or 'relyt.example.com')",
+        default=None,
+    )
+
+    RELYT_PORT: PositiveInt = Field(
+        description="Port number on which the Relyt server is listening (default is 9200)",
+        default=9200,
+    )
+
+    RELYT_USER: str | None = Field(
+        description="Username for authenticating with the Relyt database",
+        default=None,
+    )
+
+    RELYT_PASSWORD: str | None = Field(
+        description="Password for authenticating with the Relyt database",
+        default=None,
+    )
+
+    RELYT_DATABASE: str | None = Field(
+        description="Name of the Relyt database to connect to (default is 'default')",
+        default="default",
+    )

dify/api/configs/middleware/vdb/tablestore_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class TableStoreConfig(BaseSettings):
+    """
+    Configuration settings for TableStore.
+    """
+
+    TABLESTORE_ENDPOINT: str | None = Field(
+        description="Endpoint address of the TableStore server (e.g. 'https://instance-name.cn-hangzhou.ots.aliyuncs.com')",
+        default=None,
+    )
+
+    TABLESTORE_INSTANCE_NAME: str | None = Field(
+        description="Instance name to access TableStore server (eg. 'instance-name')",
+        default=None,
+    )
+
+    TABLESTORE_ACCESS_KEY_ID: str | None = Field(
+        description="AccessKey id for the instance name",
+        default=None,
+    )
+
+    TABLESTORE_ACCESS_KEY_SECRET: str | None = Field(
+        description="AccessKey secret for the instance name",
+        default=None,
+    )
+
+    TABLESTORE_NORMALIZE_FULLTEXT_BM25_SCORE: bool = Field(
+        description="Whether to normalize full-text search scores to [0, 1]",
+        default=False,
+    )

dify/api/configs/middleware/vdb/tencent_vector_config.py

@@ -0,0 +1,53 @@
+from pydantic import Field, NonNegativeInt, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class TencentVectorDBConfig(BaseSettings):
+    """
+    Configuration settings for Tencent Vector Database
+    """
+
+    TENCENT_VECTOR_DB_URL: str | None = Field(
+        description="URL of the Tencent Vector Database service (e.g., 'https://vectordb.tencentcloudapi.com')",
+        default=None,
+    )
+
+    TENCENT_VECTOR_DB_API_KEY: str | None = Field(
+        description="API key for authenticating with the Tencent Vector Database service",
+        default=None,
+    )
+
+    TENCENT_VECTOR_DB_TIMEOUT: PositiveInt = Field(
+        description="Timeout in seconds for Tencent Vector Database operations (default is 30 seconds)",
+        default=30,
+    )
+
+    TENCENT_VECTOR_DB_USERNAME: str | None = Field(
+        description="Username for authenticating with the Tencent Vector Database (if required)",
+        default=None,
+    )
+
+    TENCENT_VECTOR_DB_PASSWORD: str | None = Field(
+        description="Password for authenticating with the Tencent Vector Database (if required)",
+        default=None,
+    )
+
+    TENCENT_VECTOR_DB_SHARD: PositiveInt = Field(
+        description="Number of shards for the Tencent Vector Database (default is 1)",
+        default=1,
+    )
+
+    TENCENT_VECTOR_DB_REPLICAS: NonNegativeInt = Field(
+        description="Number of replicas for the Tencent Vector Database (default is 2)",
+        default=2,
+    )
+
+    TENCENT_VECTOR_DB_DATABASE: str | None = Field(
+        description="Name of the specific Tencent Vector Database to connect to",
+        default=None,
+    )
+
+    TENCENT_VECTOR_DB_ENABLE_HYBRID_SEARCH: bool = Field(
+        description="Enable hybrid search features",
+        default=False,
+    )

dify/api/configs/middleware/vdb/tidb_on_qdrant_config.py

@@ -0,0 +1,68 @@
+from pydantic import Field, NonNegativeInt, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class TidbOnQdrantConfig(BaseSettings):
+    """
+    Tidb on Qdrant configs
+    """
+
+    TIDB_ON_QDRANT_URL: str | None = Field(
+        description="Tidb on Qdrant url",
+        default=None,
+    )
+
+    TIDB_ON_QDRANT_API_KEY: str | None = Field(
+        description="Tidb on Qdrant api key",
+        default=None,
+    )
+
+    TIDB_ON_QDRANT_CLIENT_TIMEOUT: NonNegativeInt = Field(
+        description="Tidb on Qdrant client timeout in seconds",
+        default=20,
+    )
+
+    TIDB_ON_QDRANT_GRPC_ENABLED: bool = Field(
+        description="whether enable grpc support for Tidb on Qdrant connection",
+        default=False,
+    )
+
+    TIDB_ON_QDRANT_GRPC_PORT: PositiveInt = Field(
+        description="Tidb on Qdrant grpc port",
+        default=6334,
+    )
+
+    TIDB_PUBLIC_KEY: str | None = Field(
+        description="Tidb account public key",
+        default=None,
+    )
+
+    TIDB_PRIVATE_KEY: str | None = Field(
+        description="Tidb account private key",
+        default=None,
+    )
+
+    TIDB_API_URL: str | None = Field(
+        description="Tidb API url",
+        default=None,
+    )
+
+    TIDB_IAM_API_URL: str | None = Field(
+        description="Tidb IAM API url",
+        default=None,
+    )
+
+    TIDB_REGION: str | None = Field(
+        description="Tidb serverless region",
+        default="regions/aws-us-east-1",
+    )
+
+    TIDB_PROJECT_ID: str | None = Field(
+        description="Tidb project id",
+        default=None,
+    )
+
+    TIDB_SPEND_LIMIT: int | None = Field(
+        description="Tidb spend limit",
+        default=100,
+    )

dify/api/configs/middleware/vdb/tidb_vector_config.py

@@ -0,0 +1,33 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class TiDBVectorConfig(BaseSettings):
+    """
+    Configuration settings for TiDB Vector database
+    """
+
+    TIDB_VECTOR_HOST: str | None = Field(
+        description="Hostname or IP address of the TiDB Vector server (e.g., 'localhost' or 'tidb.example.com')",
+        default=None,
+    )
+
+    TIDB_VECTOR_PORT: PositiveInt | None = Field(
+        description="Port number on which the TiDB Vector server is listening (default is 4000)",
+        default=4000,
+    )
+
+    TIDB_VECTOR_USER: str | None = Field(
+        description="Username for authenticating with the TiDB Vector database",
+        default=None,
+    )
+
+    TIDB_VECTOR_PASSWORD: str | None = Field(
+        description="Password for authenticating with the TiDB Vector database",
+        default=None,
+    )
+
+    TIDB_VECTOR_DATABASE: str | None = Field(
+        description="Name of the TiDB Vector database to connect to",
+        default=None,
+    )

dify/api/configs/middleware/vdb/upstash_config.py

@@ -0,0 +1,18 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class UpstashConfig(BaseSettings):
+    """
+    Configuration settings for Upstash vector database
+    """
+
+    UPSTASH_VECTOR_URL: str | None = Field(
+        description="URL of the upstash server (e.g., 'https://vector.upstash.io')",
+        default=None,
+    )
+
+    UPSTASH_VECTOR_TOKEN: str | None = Field(
+        description="Token for authenticating with the upstash server",
+        default=None,
+    )

dify/api/configs/middleware/vdb/vastbase_vector_config.py

@@ -0,0 +1,43 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class VastbaseVectorConfig(BaseSettings):
+    """
+    Configuration settings for Vector (Vastbase with vector extension)
+    """
+
+    VASTBASE_HOST: str | None = Field(
+        description="Hostname or IP address of the Vastbase server with Vector extension (e.g., 'localhost')",
+        default=None,
+    )
+
+    VASTBASE_PORT: PositiveInt = Field(
+        description="Port number on which the Vastbase server is listening (default is 5432)",
+        default=5432,
+    )
+
+    VASTBASE_USER: str | None = Field(
+        description="Username for authenticating with the Vastbase database",
+        default=None,
+    )
+
+    VASTBASE_PASSWORD: str | None = Field(
+        description="Password for authenticating with the Vastbase database",
+        default=None,
+    )
+
+    VASTBASE_DATABASE: str | None = Field(
+        description="Name of the Vastbase database to connect to",
+        default=None,
+    )
+
+    VASTBASE_MIN_CONNECTION: PositiveInt = Field(
+        description="Min connection of the Vastbase database",
+        default=1,
+    )
+
+    VASTBASE_MAX_CONNECTION: PositiveInt = Field(
+        description="Max connection of the Vastbase database",
+        default=5,
+    )

dify/api/configs/middleware/vdb/vikingdb_config.py

@@ -0,0 +1,48 @@
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class VikingDBConfig(BaseSettings):
+    """
+    Configuration for connecting to Volcengine VikingDB.
+    Refer to the following documentation for details on obtaining credentials:
+    https://www.volcengine.com/docs/6291/65568
+    """
+
+    VIKINGDB_ACCESS_KEY: str | None = Field(
+        description="The Access Key provided by Volcengine VikingDB for API authentication."
+        "Refer to the following documentation for details on obtaining credentials:"
+        "https://www.volcengine.com/docs/6291/65568",
+        default=None,
+    )
+
+    VIKINGDB_SECRET_KEY: str | None = Field(
+        description="The Secret Key provided by Volcengine VikingDB for API authentication.",
+        default=None,
+    )
+
+    VIKINGDB_REGION: str = Field(
+        description="The region of the Volcengine VikingDB service.(e.g., 'cn-shanghai', 'cn-beijing').",
+        default="cn-shanghai",
+    )
+
+    VIKINGDB_HOST: str = Field(
+        description="The host of the Volcengine VikingDB service.(e.g., 'api-vikingdb.volces.com', \
+            'api-vikingdb.mlp.cn-shanghai.volces.com')",
+        default="api-vikingdb.mlp.cn-shanghai.volces.com",
+    )
+
+    VIKINGDB_SCHEME: str = Field(
+        description="The scheme of the Volcengine VikingDB service.(e.g., 'http', 'https').",
+        default="http",
+    )
+
+    VIKINGDB_CONNECTION_TIMEOUT: int = Field(
+        description="The connection timeout of the Volcengine VikingDB service.",
+        default=30,
+    )
+
+    VIKINGDB_SOCKET_TIMEOUT: int = Field(
+        description="The socket timeout of the Volcengine VikingDB service.",
+        default=30,
+    )

dify/api/configs/middleware/vdb/weaviate_config.py

@@ -0,0 +1,38 @@
+from pydantic import Field, PositiveInt
+from pydantic_settings import BaseSettings
+
+
+class WeaviateConfig(BaseSettings):
+    """
+    Configuration settings for Weaviate vector database
+    """
+
+    WEAVIATE_ENDPOINT: str | None = Field(
+        description="URL of the Weaviate server (e.g., 'http://localhost:8080' or 'https://weaviate.example.com')",
+        default=None,
+    )
+
+    WEAVIATE_API_KEY: str | None = Field(
+        description="API key for authenticating with the Weaviate server",
+        default=None,
+    )
+
+    WEAVIATE_GRPC_ENABLED: bool = Field(
+        description="Whether to enable gRPC for Weaviate connection (True for gRPC, False for HTTP)",
+        default=True,
+    )
+
+    WEAVIATE_GRPC_ENDPOINT: str | None = Field(
+        description="URL of the Weaviate gRPC server (e.g., 'grpc://localhost:50051' or 'grpcs://weaviate.example.com:443')",
+        default=None,
+    )
+
+    WEAVIATE_BATCH_SIZE: PositiveInt = Field(
+        description="Number of objects to be processed in a single batch operation (default is 100)",
+        default=100,
+    )
+
+    WEAVIATE_TOKENIZATION: str | None = Field(
+        description="Tokenization for Weaviate (default is word)",
+        default="word",
+    )