diff --git a/backend/agents/create_agent_info.py b/backend/agents/create_agent_info.py
index 0e1ed4d96..d6d79dcf1 100644
--- a/backend/agents/create_agent_info.py
+++ b/backend/agents/create_agent_info.py
@@ -353,6 +353,7 @@ async def create_tool_config_list(agent_id, tenant_id, user_id, version_no: int
 
         # special logic for search tools that may use reranking models
         if tool_config.class_name == "KnowledgeBaseSearchTool":
+            is_multimodal = tool_config.params.pop("multimodal", False)
             rerank = param_dict.get("rerank", False)
             rerank_model_name = param_dict.get("rerank_model_name", "")
             rerank_model = None
@@ -363,7 +364,7 @@ async def create_tool_config_list(agent_id, tenant_id, user_id, version_no: int
 
             tool_config.metadata = {
                 "vdb_core": get_vector_db_core(),
-                "embedding_model": get_embedding_model(tenant_id=tenant_id),
+                "embedding_model": get_embedding_model(tenant_id=tenant_id, is_multimodal=is_multimodal),
                 "rerank_model": rerank_model,
             }
         elif tool_config.class_name in ["DifySearchTool", "DataMateSearchTool"]:
diff --git a/backend/apps/file_management_app.py b/backend/apps/file_management_app.py
index 5b7c7bc3c..e0321237d 100644
--- a/backend/apps/file_management_app.py
+++ b/backend/apps/file_management_app.py
@@ -2,7 +2,7 @@
 import re
 import base64
 from http import HTTPStatus
-from typing import List, Optional
+from typing import Annotated, List, Optional
 from urllib.parse import urlparse, urlunparse, unquote, quote
 
 import httpx
@@ -115,12 +115,13 @@ async def upload_files(
 
 @file_management_config_router.post("/process")
 async def process_files(
-        files: List[dict] = Body(
-            ..., description="List of file details to process, including path_or_url and filename"),
-        chunking_strategy: Optional[str] = Body("basic"),
-        index_name: str = Body(...),
-        destination: str = Body(...),
-        authorization: Optional[str] = Header(None)
+        files: Annotated[List[dict], Body(
+            ..., description="List of file details to process, including path_or_url and filename")],
+        index_name: Annotated[str, Body(...)],
+        destination: Annotated[str, Body(...)],
+        chunking_strategy: Annotated[Optional[str], Body(...)] = "basic",
+        is_multimodal: Annotated[Optional[bool], Body(...)] = False,
+        authorization: Annotated[Optional[str], Header()] = None
 ):
     """
     Trigger data processing for a list of uploaded files.
@@ -133,7 +134,8 @@ async def process_files(
         chunking_strategy=chunking_strategy,
         source_type=destination,
         index_name=index_name,
-        authorization=authorization
+        authorization=authorization,
+        is_multimodal=is_multimodal
     )
 
     process_result = await trigger_data_process(files, process_params)
@@ -639,4 +641,4 @@ async def preview_file(
         raise HTTPException(
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             detail=f"Failed to preview file: {str(e)}"
-        )
\ No newline at end of file
+        )
diff --git a/backend/apps/model_managment_app.py b/backend/apps/model_managment_app.py
index 0a5a04139..c04c577f5 100644
--- a/backend/apps/model_managment_app.py
+++ b/backend/apps/model_managment_app.py
@@ -33,7 +33,7 @@
 from fastapi.responses import JSONResponse
 from fastapi.encoders import jsonable_encoder
 from http import HTTPStatus
-from typing import List, Optional
+from typing import Annotated, List, Optional
 from services.model_health_service import (
     check_model_connectivity,
     verify_model_config_connectivity,
@@ -297,7 +297,8 @@ async def get_llm_model_list(authorization: Optional[str] = Header(None)):
 
 @router.post("/healthcheck")
 async def check_model_health(
-        display_name: str = Query(..., description="Display name to check"),
+        display_name: Annotated[str, Query(..., description="Display name to check")],
+        model_type: Annotated[str, Query(..., description="...")],
         authorization: Optional[str] = Header(None)
 ):
     """Check and update model connectivity, returning the latest status.
@@ -308,7 +309,7 @@ async def check_model_health(
     """
     try:
         _, tenant_id = get_current_user_id(authorization)
-        result = await check_model_connectivity(display_name, tenant_id)
+        result = await check_model_connectivity(display_name, tenant_id, model_type)
         return JSONResponse(status_code=HTTPStatus.OK, content={
             "message": "Successfully checked model connectivity",
             "data": result
diff --git a/backend/apps/vectordatabase_app.py b/backend/apps/vectordatabase_app.py
index 872b5387b..2dba4559b 100644
--- a/backend/apps/vectordatabase_app.py
+++ b/backend/apps/vectordatabase_app.py
@@ -65,11 +65,15 @@ def create_new_index(
         # Extract optional fields from request body
         ingroup_permission = None
         group_ids = None
-        embedding_model_name = None
+        is_multimodal = False
+        embedding_model_name: Optional[str] = None
         if request:
             ingroup_permission = request.get("ingroup_permission")
             group_ids = request.get("group_ids")
-            embedding_model_name = request.get("embedding_model_name")
+            is_multimodal = request.get("is_multimodal")
+            embedding_model_name = request.get("embeddingModel") or request.get("embedding_model")
+            if isinstance(embedding_model_name, str):
+                embedding_model_name = embedding_model_name.strip() or None
 
         # Treat path parameter as user-facing knowledge base name for new creations
         return ElasticSearchService.create_knowledge_base(
@@ -80,7 +84,7 @@ def create_new_index(
             tenant_id=tenant_id,
             ingroup_permission=ingroup_permission,
             group_ids=group_ids,
-            embedding_model_name=embedding_model_name,
+            is_multimodal=is_multimodal,
         )
     except Exception as e:
         raise HTTPException(
@@ -124,6 +128,7 @@ async def update_index(
         knowledge_name = request.get("knowledge_name")
         ingroup_permission = request.get("ingroup_permission")
         group_ids = request.get("group_ids")
+        is_multimodal = request.get("is_multimodal")
 
         # Call service layer to update knowledge base
         result = ElasticSearchService.update_knowledge_base(
@@ -131,6 +136,7 @@ async def update_index(
             knowledge_name=knowledge_name,
             ingroup_permission=ingroup_permission,
             group_ids=group_ids,
+            is_multimodal=is_multimodal,
             tenant_id=tenant_id,
             user_id=user_id,
         )
@@ -199,15 +205,10 @@ def create_index_documents(
     try:
         user_id, tenant_id = get_current_user_id(authorization)
         
-        # Get the knowledge base record to retrieve the saved embedding model
         knowledge_record = get_knowledge_record({'index_name': index_name})
-        saved_embedding_model_name = None
-        if knowledge_record:
-            saved_embedding_model_name = knowledge_record.get('embedding_model_name')
-        
-        # Use the saved model from knowledge base, fallback to tenant default if not set
-        embedding_model = get_embedding_model(tenant_id, saved_embedding_model_name)
-        
+        is_multimodal = True if knowledge_record.get(
+            'is_multimodal') == 'Y' else False
+        embedding_model = get_embedding_model(tenant_id, is_multimodal)
         return ElasticSearchService.index_documents(
             embedding_model=embedding_model,
             index_name=index_name,
diff --git a/backend/consts/const.py b/backend/consts/const.py
index 5bfd012ff..8c75d7afd 100644
--- a/backend/consts/const.py
+++ b/backend/consts/const.py
@@ -27,6 +27,10 @@ class VectorDatabaseType(str, Enum):
 # Data Processing Service Configuration
 DATA_PROCESS_SERVICE = os.getenv("DATA_PROCESS_SERVICE")
 CLIP_MODEL_PATH = os.getenv("CLIP_MODEL_PATH")
+TABLE_TRANSFORMER_MODEL_PATH = os.getenv("TABLE_TRANSFORMER_MODEL_PATH")
+UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH = os.getenv(
+    "UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH"
+)
 
 
 # Upload Configuration
@@ -109,6 +113,7 @@ class VectorDatabaseType(str, Enum):
 MINIO_SECRET_KEY = os.getenv("MINIO_SECRET_KEY")
 MINIO_REGION = os.getenv("MINIO_REGION")
 MINIO_DEFAULT_BUCKET = os.getenv("MINIO_DEFAULT_BUCKET")
+S3_URL_PREFIX = "s3://"
 
 
 # Postgres Configuration
diff --git a/backend/consts/model.py b/backend/consts/model.py
index 2728d95ca..128fe81d4 100644
--- a/backend/consts/model.py
+++ b/backend/consts/model.py
@@ -234,6 +234,7 @@ class ProcessParams(BaseModel):
     source_type: str
     index_name: str
     authorization: Optional[str] = None
+    is_multimodal: Optional[bool] = False
 
 
 class OpinionRequest(BaseModel):
diff --git a/backend/data_process/ray_actors.py b/backend/data_process/ray_actors.py
index 2fa590bec..b9fd982ae 100644
--- a/backend/data_process/ray_actors.py
+++ b/backend/data_process/ray_actors.py
@@ -1,11 +1,19 @@
+from io import BytesIO
 import logging
 import json
 from typing import Any, Dict, List, Optional
 
 import ray
 
-from consts.const import RAY_ACTOR_NUM_CPUS, REDIS_BACKEND_URL, DEFAULT_EXPECTED_CHUNK_SIZE, DEFAULT_MAXIMUM_CHUNK_SIZE
-from database.attachment_db import get_file_stream
+from consts.const import (
+    RAY_ACTOR_NUM_CPUS,
+    REDIS_BACKEND_URL,
+    DEFAULT_EXPECTED_CHUNK_SIZE,
+    DEFAULT_MAXIMUM_CHUNK_SIZE,
+    TABLE_TRANSFORMER_MODEL_PATH,
+    UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH,
+)
+from database.attachment_db import build_s3_url, get_file_stream, upload_fileobj
 from database.model_management_db import get_model_by_model_id
 from nexent.data_process import DataProcessCore
 
@@ -58,50 +66,137 @@ def process_file(
         if task_id:
             params['task_id'] = task_id
 
-        # Get chunk size parameters from embedding model if model_id is provided
-        if model_id and tenant_id:
-            try:
-                # Get embedding model details directly by model_id
-                model_record = get_model_by_model_id(
-                    model_id=model_id, tenant_id=tenant_id)
-                if model_record:
-                    expected_chunk_size = model_record.get(
-                        'expected_chunk_size', DEFAULT_EXPECTED_CHUNK_SIZE)
-                    maximum_chunk_size = model_record.get(
-                        'maximum_chunk_size', DEFAULT_MAXIMUM_CHUNK_SIZE)
-                    model_name = model_record.get('display_name')
-
-                    # Pass chunk sizes to processing parameters
-                    params['max_characters'] = maximum_chunk_size
-                    params['new_after_n_chars'] = expected_chunk_size
-
-                    logger.info(
-                        f"[RayActor] Using chunk sizes from embedding model '{model_name}' (ID: {model_id}): "
-                        f"max_characters={maximum_chunk_size}, new_after_n_chars={expected_chunk_size}")
-                else:
-                    logger.warning(
-                        f"[RayActor] Embedding model with ID {model_id} not found for tenant '{tenant_id}', using default chunk sizes")
-            except Exception as e:
+        self._apply_model_chunk_sizes(
+            model_id=model_id, tenant_id=tenant_id, params=params)
+        self._apply_model_paths(params)
+        file_data = self._read_file_bytes(source)
+
+        result = self._processor.file_process(
+            file_data=file_data,
+            filename=source,
+            chunking_strategy=chunking_strategy,
+            **params
+        )
+        chunks, images_info = self._normalize_processor_result(result)
+        if images_info:
+            self._append_image_chunks(
+                source=source, chunks=chunks, images_info=images_info)
+
+        chunks = self._validate_chunks(chunks, source)
+        if not chunks:
+            return []
+
+        logger.info(
+            f"[RayActor] Processing done: produced {len(chunks)} chunks for source='{source}'")
+        return chunks
+
+    def _apply_model_paths(self, params: Dict[str, Any]) -> None:
+        params["table_transformer_model_path"] = TABLE_TRANSFORMER_MODEL_PATH
+        params[
+            "unstructured_default_model_initialize_params_json_path"
+        ] = UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH
+
+    def _apply_model_chunk_sizes(
+        self,
+        model_id: Optional[int],
+        tenant_id: Optional[str],
+        params: Dict[str, Any],
+    ) -> None:
+        if not (model_id and tenant_id):
+            return
+
+        try:
+            model_record = get_model_by_model_id(
+                model_id=model_id, tenant_id=tenant_id)
+            if not model_record:
                 logger.warning(
-                    f"[RayActor] Failed to retrieve chunk sizes from embedding model ID {model_id}: {e}. Using default chunk sizes")
+                    f"[RayActor] Embedding model with ID {model_id} not found for tenant '{tenant_id}', using default chunk sizes")
+                return
+
+            expected_chunk_size = model_record.get(
+                'expected_chunk_size', DEFAULT_EXPECTED_CHUNK_SIZE)
+            maximum_chunk_size = model_record.get(
+                'maximum_chunk_size', DEFAULT_MAXIMUM_CHUNK_SIZE)
+            model_name = model_record.get('display_name')
+            model_type = model_record.get('model_type')
 
+            params['max_characters'] = maximum_chunk_size
+            params['new_after_n_chars'] = expected_chunk_size
+            if model_type:
+                params['model_type'] = model_type
+
+            logger.info(
+                f"[RayActor] Using chunk sizes from embedding model '{model_name}' (ID: {model_id}): "
+                f"max_characters={maximum_chunk_size}, new_after_n_chars={expected_chunk_size}")
+        except Exception as e:
+            logger.warning(
+                f"[RayActor] Failed to retrieve chunk sizes from embedding model ID {model_id}: {e}. Using default chunk sizes")
+
+    def _read_file_bytes(self, source: str) -> bytes:
         try:
             file_stream = get_file_stream(source)
             if file_stream is None:
                 raise FileNotFoundError(
                     f"Unable to fetch file from URL: {source}")
-            file_data = file_stream.read()
+            return file_stream.read()
         except Exception as e:
             logger.error(f"Failed to fetch file from {source}: {e}")
             raise
 
-        chunks = self._processor.file_process(
-            file_data=file_data,
-            filename=source,
-            chunking_strategy=chunking_strategy,
-            **params
-        )
+    def _normalize_processor_result(
+        self, result: Any
+    ) -> tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+        if isinstance(result, tuple) and len(result) == 2:
+            chunks, images_info = result
+            return chunks or [], images_info or []
+        return result or [], []
+
+    def _append_image_chunks(
+        self,
+        source: str,
+        chunks: List[Dict[str, Any]],
+        images_info: List[Dict[str, Any]],
+    ) -> None:
+        folder = "images_in_attachments"
+        for index, image_data in enumerate(images_info):
+            if not isinstance(image_data, dict):
+                logger.warning(
+                    f"[RayActor] Skipping image entry at index {index}: unexpected type {type(image_data)}"
+                )
+                continue
+            if "image_bytes" not in image_data:
+                logger.warning(
+                    f"[RayActor] Skipping image entry at index {index}: missing image_bytes"
+                )
+                continue
+
+            img_obj = BytesIO(image_data["image_bytes"])
+            result = upload_fileobj(
+                file_obj=img_obj,
+                file_name=f"{index}.{image_data['image_format']}",
+                prefix=folder)
+            image_url = build_s3_url(result.get("object_name", ""))
+
+            image_data["source_file"] = source
+            image_data["image_url"] = image_url
 
+            chunks.append({
+                "content": json.dumps({
+                    "source_file": source,
+                    "position": image_data["position"],
+                    "image_url": image_url,
+                }),
+                "filename": source,
+                "metadata": {
+                    "chunk_index": len(chunks) + index,
+                    "process_source": "UniversalImageExtractor",
+                    "image_url": image_url,
+                }
+            })
+
+    def _validate_chunks(
+        self, chunks: Any, source: str
+    ) -> List[Dict[str, Any]]:
         if chunks is None:
             logger.warning(
                 f"[RayActor] file_process returned None for source='{source}'")
@@ -114,9 +209,6 @@ def process_file(
             logger.warning(
                 f"[RayActor] file_process returned empty list for source='{source}'")
             return []
-
-        logger.info(
-            f"[RayActor] Processing done: produced {len(chunks)} chunks for source='{source}'")
         return chunks
 
     def store_chunks_in_redis(self, redis_key: str, chunks: List[Dict[str, Any]]) -> bool:
diff --git a/backend/database/attachment_db.py b/backend/database/attachment_db.py
index 2e6249468..a9ecf00f6 100644
--- a/backend/database/attachment_db.py
+++ b/backend/database/attachment_db.py
@@ -2,9 +2,62 @@
 import os
 import uuid
 from datetime import datetime
-from typing import Any, BinaryIO, Dict, List, Optional
+from typing import Any, BinaryIO, Dict, List, Optional, Tuple
 
 from .client import minio_client
+from consts.const import S3_URL_PREFIX
+
+
+def _normalize_object_and_bucket(object_name: str, bucket: Optional[str] = None) -> Tuple[str, Optional[str]]:
+    """
+    Normalize object_name + bucket from supported URL styles.
+
+    Supports:
+    - s3://bucket/key
+    - /bucket/key
+    - key (uses provided bucket or default bucket)
+    """
+    if not object_name:
+        return object_name, bucket
+
+    if object_name.startswith(S3_URL_PREFIX):
+        s3_path = object_name[len(S3_URL_PREFIX) :]
+        parts = s3_path.split("/", 1)
+        parsed_bucket = parts[0] if parts[0] else None
+        parsed_key = parts[1] if len(parts) > 1 else ""
+        return parsed_key, parsed_bucket or bucket
+
+    if object_name.startswith("/"):
+        path = object_name.lstrip("/")
+        parts = path.split("/", 1)
+        parsed_bucket = parts[0] if parts[0] else None
+        parsed_key = parts[1] if len(parts) > 1 else ""
+        return parsed_key, parsed_bucket or bucket
+
+    return object_name, bucket
+
+
+def build_s3_url(object_name: str, bucket: Optional[str] = None) -> str:
+    """
+    Build an s3://bucket/key style URL from an object name (or passthrough if already s3://).
+    """
+    if not object_name:
+        return ""
+
+    if object_name.startswith(S3_URL_PREFIX):
+        return object_name
+
+    if object_name.startswith("/"):
+        path = object_name.lstrip("/")
+        parts = path.split("/", 1)
+        if len(parts) == 2:
+            return f"{S3_URL_PREFIX}{parts[0]}/{parts[1]}"
+        return f"{S3_URL_PREFIX}{parts[0]}/"
+
+    resolved_bucket = bucket or minio_client.storage_config.default_bucket
+    if resolved_bucket:
+        return f"{S3_URL_PREFIX}{resolved_bucket}/{object_name}"
+    return f"{S3_URL_PREFIX}{object_name}"
 
 
 def generate_object_name(file_name: str, prefix: str = "attachments") -> str:
@@ -165,6 +218,7 @@ def get_file_size_from_minio(object_name: str, bucket: Optional[str] = None) ->
     """
     Get file size by object name
     """
+    object_name, bucket = _normalize_object_and_bucket(object_name, bucket)
     bucket = bucket or minio_client.storage_config.default_bucket
     return minio_client.get_file_size(object_name, bucket)
 
@@ -181,6 +235,7 @@ def file_exists(object_name: str, bucket: Optional[str] = None) -> bool:
         bool: True if file exists, False otherwise
     """
     try:
+        object_name, bucket = _normalize_object_and_bucket(object_name, bucket)
         return minio_client.file_exists(object_name, bucket)
     except Exception:
         return False
@@ -198,6 +253,8 @@ def copy_file(source_object: str, dest_object: str, bucket: Optional[str] = None
     Returns:
         Dict[str, Any]: Result containing success flag and error message (if any)
     """
+    source_object, bucket = _normalize_object_and_bucket(source_object, bucket)
+    dest_object, bucket = _normalize_object_and_bucket(dest_object, bucket)
     success, result = minio_client.copy_file(source_object, dest_object, bucket)
     if success:
         return {"success": True, "object_name": result}
@@ -242,6 +299,7 @@ def delete_file(object_name: str, bucket: Optional[str] = None) -> Dict[str, Any
     Returns:
         Dict[str, Any]: Delete result, containing success flag and error message (if any)
     """
+    object_name, bucket = _normalize_object_and_bucket(object_name, bucket)
     if not bucket:
         bucket = minio_client.storage_config.default_bucket
     success, result = minio_client.delete_file(object_name, bucket)
@@ -265,6 +323,7 @@ def get_file_stream(object_name: str, bucket: Optional[str] = None) -> Optional[
     Returns:
         Optional[BinaryIO]: Standard BinaryIO stream object, or None if failed
     """
+    object_name, bucket = _normalize_object_and_bucket(object_name, bucket)
     success, result = minio_client.get_file_stream(object_name, bucket)
     if not success:
         return None
diff --git a/backend/database/db_models.py b/backend/database/db_models.py
index a1b28334c..faf58fce4 100644
--- a/backend/database/db_models.py
+++ b/backend/database/db_models.py
@@ -271,6 +271,7 @@ class KnowledgeRecord(TableBase):
     group_ids = Column(String, doc="Knowledge base group IDs list")
     ingroup_permission = Column(
         String(30), doc="In-group permission: EDIT, READ_ONLY, PRIVATE")
+    is_multimodal = Column(String(1), default="N",  doc="Whether it is multimodal. Optional values: Y/N")
 
 
 class TenantConfig(TableBase):
diff --git a/backend/database/knowledge_db.py b/backend/database/knowledge_db.py
index df42e1888..40f4ca718 100644
--- a/backend/database/knowledge_db.py
+++ b/backend/database/knowledge_db.py
@@ -52,6 +52,7 @@ def create_knowledge_record(query: Dict[str, Any]) -> Dict[str, Any]:
                 "knowledge_name": knowledge_name,
                 "group_ids": convert_list_to_string(group_ids) if isinstance(group_ids, list) else group_ids,
                 "ingroup_permission": query.get("ingroup_permission"),
+                "is_multimodal": 'Y' if query.get("is_multimodal") else 'N'
             }
 
             # For backward compatibility: if caller explicitly provides index_name,
@@ -178,6 +179,9 @@ def update_knowledge_record(query: Dict[str, Any]) -> bool:
             if query.get("group_ids") is not None:
                 record.group_ids = query["group_ids"]
 
+            if query.get("is_multimodal"):
+                record.is_multimodal = 'Y' if query["is_multimodal"] else 'N'
+            
             # Update timestamp and user
             if query.get("user_id"):
                 record.updated_by = query["user_id"]
@@ -254,6 +258,11 @@ def get_knowledge_record(query: Optional[Dict[str, Any]] = None) -> Dict[str, An
                 db_query = db_query.filter(
                     KnowledgeRecord.tenant_id == query['tenant_id'])
 
+            if 'is_multimodal' in query:
+                db_query = db_query.filter(
+                    KnowledgeRecord.is_multimodal == query['is_multimodal']
+                )
+            
             result = db_query.first()
 
             if result:
diff --git a/backend/database/model_management_db.py b/backend/database/model_management_db.py
index cb1c6c69f..61753f52f 100644
--- a/backend/database/model_management_db.py
+++ b/backend/database/model_management_db.py
@@ -170,7 +170,7 @@ def get_model_records(filters: Optional[Dict[str, Any]], tenant_id: str) -> List
         return result_list
 
 
-def get_model_by_display_name(display_name: str, tenant_id: str) -> Optional[Dict[str, Any]]:
+def get_model_by_display_name(display_name: str, tenant_id: str, model_type: str = None) -> Optional[Dict[str, Any]]:
     """
     Get a model record by display name
 
@@ -179,6 +179,11 @@ def get_model_by_display_name(display_name: str, tenant_id: str) -> Optional[Dic
         tenant_id:
     """
     filters = {'display_name': display_name}
+    
+    if model_type in ["multiEmbedding", "multi_embedding"]:
+        filters['model_type'] = "multi_embedding"
+    elif model_type == "embedding":
+        filters['model_type'] = "embedding"
 
     records = get_model_records(filters, tenant_id)
     if not records:
@@ -203,7 +208,7 @@ def get_models_by_display_name(display_name: str, tenant_id: str) -> List[Dict[s
     return get_model_records(filters, tenant_id)
 
 
-def get_model_id_by_display_name(display_name: str, tenant_id: str) -> Optional[int]:
+def get_model_id_by_display_name(display_name: str, tenant_id: str, model_type: str = None) -> Optional[int]:
     """
     Get a model ID by display name
 
@@ -214,7 +219,7 @@ def get_model_id_by_display_name(display_name: str, tenant_id: str) -> Optional[
     Returns:
         Optional[int]: Model ID
     """
-    model = get_model_by_display_name(display_name, tenant_id)
+    model = get_model_by_display_name(display_name, tenant_id, model_type)
     return model["model_id"] if model else None
 
 
diff --git a/backend/services/config_sync_service.py b/backend/services/config_sync_service.py
index 9fe50813a..c484ca23f 100644
--- a/backend/services/config_sync_service.py
+++ b/backend/services/config_sync_service.py
@@ -99,7 +99,7 @@ async def save_config_impl(config, tenant_id, user_id):
 
         config_key = get_env_key(model_type) + "_ID"
         model_id = get_model_id_by_display_name(
-            model_display_name, tenant_id)
+            model_display_name, tenant_id, model_type=model_type)
 
         handle_model_config(tenant_id, user_id, config_key,
                             model_id, tenant_config_dict)
diff --git a/backend/services/data_process_service.py b/backend/services/data_process_service.py
index 8c44c15e6..dcd80424d 100644
--- a/backend/services/data_process_service.py
+++ b/backend/services/data_process_service.py
@@ -255,6 +255,17 @@ async def load_image(self, image_url: str) -> Optional[Image.Image]:
     async def _load_image(self, session: aiohttp.ClientSession, path: str) -> Optional[Image.Image]:
         """Internal method to load an image from various sources"""
         try:
+            if path.startswith('s3://'):
+                # Fetch from MinIO using s3://bucket/key
+                file_stream = get_file_stream(object_name=path)
+                if file_stream is None:
+                    raise FileNotFoundError(
+                        f"Unable to fetch file from URL: {path}")
+                file_data = file_stream.read()
+                image_based64_str = base64.b64encode(
+                    file_data).decode('utf-8')
+                path = f"data:image/jpeg;base64,{image_based64_str}"
+
             # Check if input is base64 encoded
             if path.startswith('data:image'):
                 # Extract the base64 data after the comma
@@ -463,6 +474,8 @@ async def create_batch_tasks_impl(self, authorization: Optional[str], request: B
             chunking_strategy = source_config.get('chunking_strategy')
             index_name = source_config.get('index_name')
             original_filename = source_config.get('original_filename')
+            embedding_model_id = source_config.get('embedding_model_id')
+            tenant_id = source_config.get('tenant_id')
 
             # Validate required fields
             if not source:
@@ -481,7 +494,9 @@ async def create_batch_tasks_impl(self, authorization: Optional[str], request: B
                     source_type=source_type,
                     chunking_strategy=chunking_strategy,
                     index_name=index_name,
-                    original_filename=original_filename
+                    original_filename=original_filename,
+                    embedding_model_id=embedding_model_id,
+                    tenant_id=tenant_id
                 ).set(queue='process_q'),
                 forward.s(
                     index_name=index_name,
@@ -559,7 +574,7 @@ async def process_uploaded_text_file(self, file_content: bytes, filename: str, c
         }
 
     async def convert_office_to_pdf_impl(self, object_name: str, pdf_object_name: str) -> None:
-        """Full conversion pipeline: download → convert → upload → validate → cleanup.
+        """Full conversion pipeline: download -> convert -> upload -> validate -> cleanup.
 
         All five steps run inside data-process so that LibreOffice only needs to be
         installed in this container.
diff --git a/backend/services/datamate_service.py b/backend/services/datamate_service.py
index 776e0eb1d..26e777eba 100644
--- a/backend/services/datamate_service.py
+++ b/backend/services/datamate_service.py
@@ -51,7 +51,8 @@ async def _create_datamate_knowledge_records(knowledge_base_ids: List[str],
                 "tenant_id": tenant_id,
                 "user_id": user_id,
                 # Use datamate as embedding model name
-                "embedding_model_name": embedding_model_names[i]
+                "embedding_model_name": embedding_model_names[i],
+                "is_multimodal": False,
             }
 
             # Run synchronous database operation in executor to avoid blocking
diff --git a/backend/services/model_health_service.py b/backend/services/model_health_service.py
index 9214a1ffa..5b8e27f07 100644
--- a/backend/services/model_health_service.py
+++ b/backend/services/model_health_service.py
@@ -128,10 +128,10 @@ async def _perform_connectivity_check(
     return connectivity
 
 
-async def check_model_connectivity(display_name: str, tenant_id: str) -> dict:
+async def check_model_connectivity(display_name: str, tenant_id: str, model_type: str = None) -> dict:
     try:
         # Query the database using display_name and tenant context from app layer
-        model = get_model_by_display_name(display_name, tenant_id=tenant_id)
+        model = get_model_by_display_name(display_name, tenant_id=tenant_id, model_type=model_type)
         if not model:
             raise LookupError(f"Model configuration not found for {display_name}")
 
diff --git a/backend/services/tool_configuration_service.py b/backend/services/tool_configuration_service.py
index 9653b2e10..22e9dd1b7 100644
--- a/backend/services/tool_configuration_service.py
+++ b/backend/services/tool_configuration_service.py
@@ -140,6 +140,10 @@ def get_local_tools() -> List[ToolInfo]:
             else:
                 param_info["default"] = param.default.default
                 param_info["optional"] = True
+            if getattr(param.default, "json_schema_extra", None):
+                optional_override = param.default.json_schema_extra.get("optional")
+                if optional_override is not None:
+                    param_info["optional"] = optional_override
 
             init_params_list.append(param_info)
 
@@ -692,7 +696,8 @@ def _validate_local_tool(
                     instantiation_params[param_name] = param.default
 
         if tool_name == "knowledge_base_search":
-            embedding_model = get_embedding_model(tenant_id=tenant_id)
+            is_multimodal = instantiation_params.pop("multimodal", False)
+            embedding_model = get_embedding_model(tenant_id=tenant_id, is_multimodal=is_multimodal)
             vdb_core = get_vector_db_core()
 
             # Get rerank configuration
diff --git a/backend/services/vectordatabase_service.py b/backend/services/vectordatabase_service.py
index cf8f7f98c..2e1a881b7 100644
--- a/backend/services/vectordatabase_service.py
+++ b/backend/services/vectordatabase_service.py
@@ -28,7 +28,7 @@
 
 from consts.const import DATAMATE_URL, ES_API_KEY, ES_HOST, LANGUAGE, VectorDatabaseType, IS_SPEED_MODE, PERMISSION_EDIT, PERMISSION_READ
 from consts.model import ChunkCreateRequest, ChunkUpdateRequest
-from database.attachment_db import delete_file
+from database.attachment_db import delete_file, get_file_stream
 from database.knowledge_db import (
     create_knowledge_record,
     delete_knowledge_record,
@@ -176,7 +176,76 @@ def check_knowledge_base_exist_impl(knowledge_name: str, vdb_core: VectorDatabas
     return {"status": "available"}
 
 
-def get_embedding_model(tenant_id: str, model_name: Optional[str] = None):
+def _build_embedding_from_config(model_config: Dict[str, Any]) -> Optional[BaseEmbedding]:
+    model_type = model_config.get("model_type", "")
+    if model_type == "embedding":
+        return OpenAICompatibleEmbedding(
+            api_key=model_config.get("api_key", ""),
+            base_url=model_config.get("base_url", ""),
+            model_name=get_model_name_from_config(model_config) or "",
+            embedding_dim=model_config.get("max_tokens", 1024),
+            ssl_verify=model_config.get("ssl_verify", True),
+        )
+    if model_type == "multi_embedding":
+        return JinaEmbedding(
+            api_key=model_config.get("api_key", ""),
+            base_url=model_config.get("base_url", ""),
+            model_name=get_model_name_from_config(model_config) or "",
+            embedding_dim=model_config.get("max_tokens", 1024),
+            ssl_verify=model_config.get("ssl_verify", True),
+        )
+    return None
+
+
+def _find_model_record(
+    tenant_id: str,
+    is_multimodal: bool,
+    model_name: str,
+) -> Optional[Dict[str, Any]]:
+    model_type = "multi_embedding" if is_multimodal else "embedding"
+    models = get_model_records({"model_type": model_type}, tenant_id)
+    for model in models:
+        model_display_name = (
+            f"{model.get('model_repo')}/{model['model_name']}"
+            if model.get("model_repo")
+            else model["model_name"]
+        )
+        if model_display_name == model_name:
+            return model
+    return None
+
+
+def _build_embedding_from_record(
+    model_record: Dict[str, Any],
+    is_multimodal: bool,
+) -> BaseEmbedding:
+    model_config = {
+        "model_repo": model_record.get("model_repo", ""),
+        "model_name": model_record["model_name"],
+        "api_key": model_record.get("api_key", ""),
+        "base_url": model_record.get("base_url", ""),
+        "model_type": "embedding",
+        "max_tokens": model_record.get("max_tokens", 1024),
+        "ssl_verify": model_record.get("ssl_verify", True),
+    }
+    if not is_multimodal:
+        return OpenAICompatibleEmbedding(
+            api_key=model_config.get("api_key", ""),
+            base_url=model_config.get("base_url", ""),
+            model_name=get_model_name_from_config(model_config) or "",
+            embedding_dim=model_config.get("max_tokens", 1024),
+            ssl_verify=model_config.get("ssl_verify", True),
+        )
+    return JinaEmbedding(
+        api_key=model_config.get("api_key", ""),
+        base_url=model_config.get("base_url", ""),
+        model_name=get_model_name_from_config(model_config) or "",
+        embedding_dim=model_config.get("max_tokens", 1024),
+        ssl_verify=model_config.get("ssl_verify", True),
+    )
+
+
+def get_embedding_model(tenant_id: str, is_multimodal: bool = False, model_name: Optional[str] = None):
     """
     Get the embedding model for the tenant, optionally using a specific model name.
 
@@ -188,58 +257,46 @@ def get_embedding_model(tenant_id: str, model_name: Optional[str] = None):
     Returns:
         Embedding model instance or None
     """
+    if model_name is None and (isinstance(is_multimodal, str) or is_multimodal is None):
+        model_name = is_multimodal
+        is_multimodal = False
     # If model_name is provided, try to find it in the tenant's models
     if model_name:
         try:
-            models = get_model_records({"model_type": "embedding"}, tenant_id)
-            for model in models:
-                model_display_name = model.get("model_repo") + "/" + model["model_name"] if model.get("model_repo") else model["model_name"]
-                if model_display_name == model_name:
-                    # Found the model, create embedding instance
-                    model_config = {
-                        "model_repo": model.get("model_repo", ""),
-                        "model_name": model["model_name"],
-                        "api_key": model.get("api_key", ""),
-                        "base_url": model.get("base_url", ""),
-                        "model_type": "embedding",
-                        "max_tokens": model.get("max_tokens", 1024),
-                        "ssl_verify": model.get("ssl_verify", True),
-                    }
-                    return OpenAICompatibleEmbedding(
-                        api_key=model_config.get("api_key", ""),
-                        base_url=model_config.get("base_url", ""),
-                        model_name=get_model_name_from_config(model_config) or "",
-                        embedding_dim=model_config.get("max_tokens", 1024),
-                        ssl_verify=model_config.get("ssl_verify", True),
-                    )
+            model_record = _find_model_record(
+                tenant_id=tenant_id,
+                is_multimodal=is_multimodal,
+                model_name=model_name,
+            )
+            if model_record:
+                return _build_embedding_from_record(
+                    model_record=model_record,
+                    is_multimodal=is_multimodal,
+                )
         except Exception as e:
-            logger.warning(f"Failed to get embedding model by name {model_name}: {e}")
+            logger.warning(
+                f"Failed to get embedding model by name {model_name}: {e}")
 
     # Fall back to default embedding model (current behavior)
     model_config = tenant_config_manager.get_model_config(
-        key="EMBEDDING_ID", tenant_id=tenant_id)
-
-    model_type = model_config.get("model_type", "")
-
-    if model_type == "embedding":
-        # Get the es core
-        return OpenAICompatibleEmbedding(
-            api_key=model_config.get("api_key", ""),
-            base_url=model_config.get("base_url", ""),
-            model_name=get_model_name_from_config(model_config) or "",
-            embedding_dim=model_config.get("max_tokens", 1024),
-            ssl_verify=model_config.get("ssl_verify", True),
-        )
-    elif model_type == "multi_embedding":
-        return JinaEmbedding(
-            api_key=model_config.get("api_key", ""),
-            base_url=model_config.get("base_url", ""),
-            model_name=get_model_name_from_config(model_config) or "",
-            embedding_dim=model_config.get("max_tokens", 1024),
-            ssl_verify=model_config.get("ssl_verify", True),
+        key="MULTI_EMBEDDING_ID" if is_multimodal else "EMBEDDING_ID",
+        tenant_id=tenant_id,
+    )
+    return _build_embedding_from_config(model_config)
+
+
+def _resolve_embedding_model(
+    tenant_id: str,
+    is_multimodal: bool,
+    embedding_model_name: Optional[str],
+) -> Optional[BaseEmbedding]:
+    if embedding_model_name:
+        return get_embedding_model(
+            tenant_id,
+            is_multimodal=is_multimodal,
+            model_name=embedding_model_name,
         )
-    else:
-        return None
+    return get_embedding_model(tenant_id, is_multimodal=is_multimodal)
 
 
 def get_rerank_model(tenant_id: str, model_name: Optional[str] = None):
@@ -406,6 +463,7 @@ async def full_delete_knowledge_base(index_name: str, vdb_core: VectorDatabaseCo
 
     @staticmethod
     def create_index(
+            embedding_model: BaseEmbedding,
             index_name: str = Path(...,
                                    description="Name of the index to create"),
             embedding_dim: Optional[int] = Query(
@@ -419,15 +477,22 @@ def create_index(
         try:
             if vdb_core.check_index_exists(index_name):
                 raise Exception(f"Index {index_name} already exists")
-            embedding_model = get_embedding_model(tenant_id)
+            
             success = vdb_core.create_index(index_name, embedding_dim=embedding_dim or (
                 embedding_model.embedding_dim if embedding_model else 1024))
             if not success:
                 raise Exception(f"Failed to create index {index_name}")
-            knowledge_data = {"index_name": index_name,
-                              "created_by": user_id,
-                              "tenant_id": tenant_id,
-                              "embedding_model_name": embedding_model.model}
+            is_multimodal = (
+                True
+                if embedding_model and getattr(embedding_model, "model_type", None) == "multimodal"
+                else False
+            )
+            knowledge_data = {
+                "index_name": index_name,
+                "created_by": user_id,
+                "tenant_id": tenant_id,
+                "is_multimodal": is_multimodal,
+            }
             create_knowledge_record(knowledge_data)
             return {"status": "success", "message": f"Index {index_name} created successfully"}
         except Exception as e:
@@ -443,6 +508,7 @@ def create_knowledge_base(
             ingroup_permission: Optional[str] = None,
             group_ids: Optional[List[int]] = None,
             embedding_model_name: Optional[str] = None,
+            is_multimodal: bool = False,
     ):
         """
         Create a new knowledge base with a user-facing name and an internal Elasticsearch index name.
@@ -467,14 +533,14 @@ def create_knowledge_base(
         with an explicit index_name.
         """
         try:
-            # Get embedding model - use user-selected model if provided, otherwise use tenant default
-            embedding_model = get_embedding_model(tenant_id, embedding_model_name)
-
-            # Determine the embedding model name to save: use user-provided name if available,
-            # otherwise use the model's display name
-            saved_embedding_model_name = embedding_model_name
-            if not saved_embedding_model_name and embedding_model:
-                saved_embedding_model_name = embedding_model.model
+            embedding_model = _resolve_embedding_model(
+                tenant_id=tenant_id,
+                is_multimodal=is_multimodal,
+                embedding_model_name=embedding_model_name,
+            )
+            resolved_embedding_model_name = embedding_model_name
+            if resolved_embedding_model_name is None and embedding_model:
+                resolved_embedding_model_name = getattr(embedding_model, "model", None)
 
             # Create knowledge record first to obtain knowledge_id and generated index_name
             knowledge_data = {
@@ -482,7 +548,8 @@ def create_knowledge_base(
                 "knowledge_describe": "",
                 "user_id": user_id,
                 "tenant_id": tenant_id,
-                "embedding_model_name": saved_embedding_model_name,
+                "embedding_model_name": resolved_embedding_model_name,
+                "is_multimodal": is_multimodal,
             }
 
             # Add group permission and group IDs if provided
@@ -519,6 +586,7 @@ def update_knowledge_base(
             knowledge_name: Optional[str] = None,
             ingroup_permission: Optional[str] = None,
             group_ids: Optional[List[int]] = None,
+            is_multimodal: bool = False,
             tenant_id: Optional[str] = None,
             user_id: Optional[str] = None,
     ) -> bool:
@@ -549,6 +617,7 @@ def update_knowledge_base(
         update_data = {
             "index_name": index_name,
             "updated_by": user_id,
+            "is_multimodal": is_multimodal,
         }
 
         if knowledge_name is not None:
@@ -781,6 +850,7 @@ def list_indices(
                         "display_name": record.get("knowledge_name", index_name),
                         "permission": record["permission"],
                         "group_ids": record["group_ids"],
+                        "is_multimodal": True if record.get("is_multimodal") == "Y" else False,
                         # knowledge source and ingroup permission from DB record
                         "knowledge_sources": record["knowledge_sources"],
                         "ingroup_permission": record["ingroup_permission"],
@@ -882,15 +952,30 @@ def index_documents(
                     "author": author,
                     "date": date,
                     "content": text,
-                    "process_source": "Unstructured",
+                    "process_source": metadata.get("process_source", "Unstructured"),
                     "file_size": file_size,
                     "create_time": create_time,
                     "languages": metadata.get("languages", []),
                     "embedding_model_name": embedding_model_name
                 }
 
+                image_url = metadata.get("image_url", "")
+                if len(image_url) > 0:
+                    # Fetch image bytes from MinIO (supports s3://bucket/key or /bucket/key)
+                    try:
+                        file_stream = get_file_stream(
+                            object_name=image_url)
+                        if file_stream is None:
+                            raise FileNotFoundError(
+                                f"Unable to fetch file from URL: {image_url}")
+                        document["image_bytes"] = file_stream.read()
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to fetch file from {image_url}: {e}")
+                        raise
                 documents.append(document)
 
+
             total_submitted = len(documents)
             if total_submitted == 0:
                 return {
@@ -908,8 +993,9 @@ def index_documents(
                 'tenant_id') if knowledge_record else None
 
             if tenant_id:
+                model_type = "EMBEDDING_ID" if embedding_model.model_type == "text" else "MULTI_EMBEDDING_ID"
                 model_config = tenant_config_manager.get_model_config(
-                    key="EMBEDDING_ID", tenant_id=tenant_id)
+                    key=model_type, tenant_id=tenant_id)
                 embedding_batch_size = model_config.get("chunk_batch", 10)
                 if embedding_batch_size is None:
                     embedding_batch_size = 10
diff --git a/backend/utils/file_management_utils.py b/backend/utils/file_management_utils.py
index 57025e350..4103770f3 100644
--- a/backend/utils/file_management_utils.py
+++ b/backend/utils/file_management_utils.py
@@ -40,11 +40,13 @@ async def trigger_data_process(files: List[dict], process_params: ProcessParams)
         # Get chunking size according to the embedding model
         embedding_model_id = None
         tenant_id = None
+        is_multimodal = process_params.is_multimodal
         try:
             _, tenant_id = get_current_user_id(process_params.authorization)
             # Get embedding model ID from tenant config
             tenant_config = tenant_config_manager.load_config(tenant_id)
-            embedding_model_id_str = tenant_config.get("EMBEDDING_ID") if tenant_config else None
+            embedding_id_key = "MULTI_EMBEDDING_ID" if is_multimodal else "EMBEDDING_ID"
+            embedding_model_id_str = tenant_config.get(embedding_id_key) if tenant_config else None
             if embedding_model_id_str:
                 embedding_model_id = int(embedding_model_id_str)
         except Exception as e:
@@ -66,6 +68,7 @@ async def trigger_data_process(files: List[dict], process_params: ProcessParams)
                 "index_name": process_params.index_name,
                 "original_filename": file_details.get("filename"),
                 "embedding_model_id": embedding_model_id,
+                "is_multimodal": is_multimodal,
                 "tenant_id": tenant_id
             }
 
@@ -97,6 +100,7 @@ async def trigger_data_process(files: List[dict], process_params: ProcessParams)
                     "index_name": process_params.index_name,
                     "original_filename": file_details.get("filename"),
                     "embedding_model_id": embedding_model_id,
+                    "is_multimodal": is_multimodal,
                     "tenant_id": tenant_id
                 }
                 sources.append(source)
diff --git a/docker/deploy.sh b/docker/deploy.sh
index e30e6e75a..233c14604 100755
--- a/docker/deploy.sh
+++ b/docker/deploy.sh
@@ -17,6 +17,7 @@ DEPLOY_OPTIONS_FILE="$SCRIPT_DIR/deploy.options"
 MODE_CHOICE_SAVED=""
 VERSION_CHOICE_SAVED=""
 IS_MAINLAND_SAVED=""
+DOWNLOAD_MODELS="N"
 ENABLE_TERMINAL_SAVED="N"
 TERMINAL_MOUNT_DIR_SAVED="${TERMINAL_MOUNT_DIR:-}"
 APP_VERSION=""
@@ -79,6 +80,58 @@ is_windows_env() {
   return 1
 }
 
+detect_os_type() {
+  # Return: windows | mac | linux | unknown
+  local os_name
+  os_name=$(uname -s 2>/dev/null | tr '[:upper:]' '[:lower:]')
+  case "$os_name" in
+    mingw*|msys*|cygwin*)
+      echo "windows"
+      ;;
+    darwin*)
+      echo "mac"
+      ;;
+    linux*)
+      echo "linux"
+      ;;
+    *)
+      echo "unknown"
+      ;;
+  esac
+  return 0
+}
+
+format_path_for_env() {
+  # Convert path to OS-specific format for .env values
+  local input_path="$1"
+  local os_type
+  os_type=$(detect_os_type)
+
+  if [[ "$os_type" = "windows" ]]; then
+    if command -v cygpath >/dev/null 2>&1; then
+      cygpath -w "$input_path"
+      return 0
+    fi
+
+    if [[ "$input_path" =~ ^/([a-zA-Z])/(.*)$ ]]; then
+      local drive="${BASH_REMATCH[1]}"
+      local rest="${BASH_REMATCH[2]}"
+      rest="${rest//\//\\}"
+      printf "%s:\\%s" "$(echo "$drive" | tr '[:lower:]' '[:upper:]')" "$rest"
+      return 0
+    fi
+  fi
+
+  printf "%s" "$input_path"
+}
+
+escape_backslashes() {
+  # Escape backslashes for safe writing into .env or JSON
+  local input_path="$1"
+  printf "%s" "$input_path" | sed 's/\\/\\\\/g'
+  return 0
+}
+
 is_port_in_use() {
   # Check if a TCP port is already in use (Linux/macOS/Windows Git Bash)
   local port="$1"
@@ -266,6 +319,7 @@ persist_deploy_options() {
     echo "MODE_CHOICE=\"${MODE_CHOICE_SAVED}\""
     echo "VERSION_CHOICE=\"${VERSION_CHOICE_SAVED}\""
     echo "IS_MAINLAND=\"${IS_MAINLAND_SAVED}\""
+    echo "DOWNLOAD_MODELS=\"${DOWNLOAD_MODELS}\""
     echo "ENABLE_TERMINAL=\"${ENABLE_TERMINAL_SAVED}\""
     echo "TERMINAL_MOUNT_DIR=\"${TERMINAL_MOUNT_DIR_SAVED}\""
   } > "$DEPLOY_OPTIONS_FILE"
@@ -528,6 +582,229 @@ select_deployment_mode() {
   echo ""
 }
 
+
+# Model download selection
+select_model_download() {
+  echo ""
+
+  local input_choice=""
+  read -r -p "Do you want to download AI model files (table-transformer and yolox)? [Y/N] (default: N): " input_choice
+  echo ""
+
+  if [[ $input_choice =~ ^[Yy]$ ]]; then
+    DOWNLOAD_MODELS="Y"
+    echo "INFO: Model download will be performed."
+  else
+    DOWNLOAD_MODELS="N"
+    echo "INFO: Skipping model download."
+  fi
+  echo "----------------------------------------"
+  echo ""
+  return 0
+}
+
+# kerry
+
+download_and_config_models() {
+  if [[ "$DOWNLOAD_MODELS" != "Y" ]]; then
+    echo "INFO: Model download skipped by user choice."
+    return 0
+  fi
+
+  echo "INFO: Downloading AI model files (this may take a while)..."
+
+  local env_file_dir="$SCRIPT_DIR"
+  local env_file_path="$env_file_dir/.env"
+  local original_dir="$(pwd)"
+
+  MODEL_ROOT="$ROOT_DIR/model"
+  mkdir -p "$MODEL_ROOT"
+  echo "INFO: Model directory: $MODEL_ROOT"
+
+  export HF_ENDPOINT="https://hf-mirror.com"
+
+  command -v git >/dev/null || { echo "ERROR: git is required but not found." >&2; return 1; }
+
+  # ==========================================
+  # 1. Table Transformer (table-structure recognition)
+  echo "INFO: Downloading table-transformer-structure-recognition..."
+
+  TT_MODEL_DIR_NAME="table-transformer-structure-recognition"
+  TT_MODEL_DIR_PATH="$MODEL_ROOT/$TT_MODEL_DIR_NAME"
+  MODEL_SAFETENSORS_FILE="model.safetensors"
+  TT_MODEL_FILE_CHECK="$TT_MODEL_DIR_PATH/$MODEL_SAFETENSORS_FILE"
+
+  cd "$MODEL_ROOT" || return 1
+
+  if [[ -d "$TT_MODEL_DIR_PATH" ]] && [[ -f "$TT_MODEL_FILE_CHECK" ]]; then
+      FILE_SIZE=$(stat -c%s "$TT_MODEL_FILE_CHECK" 2>/dev/null || stat -f%z "$TT_MODEL_FILE_CHECK" 2>/dev/null)
+      if [[ "$FILE_SIZE" -gt 1000000 ]]; then
+          echo "INFO: Table Transformer already exists."
+      else
+          echo "WARN: Existing model file looks incomplete, re-downloading..."
+          rm -rf "$TT_MODEL_DIR_NAME"
+      fi
+  fi
+
+  if [[ ! -f "$TT_MODEL_FILE_CHECK" ]]; then
+      if [[ -d "$TT_MODEL_DIR_NAME" ]]; then
+          echo "WARN: Removing existing directory before re-download..."
+          rm -rf "$TT_MODEL_DIR_NAME"
+      fi
+
+      echo "INFO: Step 1/2: Clone repo (skip LFS files)..."
+      if ! GIT_LFS_SKIP_SMUDGE=1 git clone "$HF_ENDPOINT/microsoft/$TT_MODEL_DIR_NAME" "$TT_MODEL_DIR_NAME"; then
+          echo "ERROR: Failed to clone repository." >&2
+          cd "$original_dir"
+          return 1
+      fi
+
+      cd "$TT_MODEL_DIR_NAME" || return 1
+
+      echo "INFO: Step 2/2: Download model.safetensors..."
+      LARGE_FILE_URL="$HF_ENDPOINT/microsoft/$TT_MODEL_DIR_NAME/resolve/main/$MODEL_SAFETENSORS_FILE"
+
+      if command -v curl &> /dev/null; then
+          curl -L -o "$MODEL_SAFETENSORS_FILE" "$LARGE_FILE_URL" --progress-bar
+      elif command -v wget &> /dev/null; then
+          wget "$LARGE_FILE_URL" -O "$MODEL_SAFETENSORS_FILE"
+      else
+          echo "ERROR: curl or wget is required to download model files." >&2
+          cd "$MODEL_ROOT"; rm -rf "$TT_MODEL_DIR_NAME"; cd "$original_dir"; return 1
+      fi
+
+      if [[ ! -f "$MODEL_SAFETENSORS_FILE" ]]; then
+          echo "ERROR: $MODEL_SAFETENSORS_FILE download failed." >&2
+          cd "$MODEL_ROOT"; rm -rf "$TT_MODEL_DIR_NAME"; cd "$original_dir"; return 1
+      fi
+
+      FILE_SIZE=$(stat -c%s "$MODEL_SAFETENSORS_FILE" 2>/dev/null || stat -f%z "$MODEL_SAFETENSORS_FILE" 2>/dev/null)
+      if [[ "$FILE_SIZE" -lt 1000000 ]]; then
+          echo "ERROR: $MODEL_SAFETENSORS_FILE seems too small (size: $FILE_SIZE bytes)." >&2
+          cd "$MODEL_ROOT"; rm -rf "$TT_MODEL_DIR_NAME"; cd "$original_dir"; return 1
+      fi
+
+      echo "INFO: $MODEL_SAFETENSORS_FILE downloaded (size: $(du -h "$MODEL_SAFETENSORS_FILE" | cut -f1))"
+      cd "$MODEL_ROOT"
+  fi
+
+  echo "INFO: Table Transformer OK"
+
+  # ==========================================
+  # 2. YOLOX (layout detection model)
+  echo "INFO: Downloading yolox_l0.05.onnx"
+
+  YOLOX_MODEL_FILE="$MODEL_ROOT/yolox_l0.05.onnx"
+  MIN_YOLOX_SIZE=50000000
+
+  NEED_DOWNLOAD=false
+
+  if [[ -f "$YOLOX_MODEL_FILE" ]]; then
+      CURRENT_SIZE=$(stat -c%s "$YOLOX_MODEL_FILE" 2>/dev/null || stat -f%z "$YOLOX_MODEL_FILE" 2>/dev/null)
+      if [[ "$CURRENT_SIZE" -lt "$MIN_YOLOX_SIZE" ]]; then
+          echo "WARN: Existing YOLOX file looks incomplete (size: $(numfmt --to=iec-i --suffix=B $CURRENT_SIZE 2>/dev/null || echo $CURRENT_SIZE)). Re-downloading..."
+          NEED_DOWNLOAD=true
+      else
+          echo "INFO: YOLOX already exists."
+      fi
+  else
+      NEED_DOWNLOAD=true
+  fi
+
+  if [[ "$NEED_DOWNLOAD" = true ]]; then
+      ONNX_URL="$HF_ENDPOINT/unstructuredio/yolo_x_layout/resolve/main/yolox_l0.05.onnx"
+
+      if command -v curl &> /dev/null; then
+          echo "INFO: Downloading with curl (supports resume -C -)..."
+          if curl -L -C - -o "$YOLOX_MODEL_FILE" "$ONNX_URL" --progress-bar; then
+              echo "INFO: curl download completed"
+          else
+              echo "ERROR: curl download failed." >&2
+              cd "$original_dir"
+              return 1
+          fi
+      elif command -v wget &> /dev/null; then
+          echo "INFO: Downloading with wget (supports resume -c)..."
+          wget -c "$ONNX_URL" -O "$YOLOX_MODEL_FILE"
+      else
+          echo "ERROR: curl or wget is required to download model files." >&2
+          cd "$original_dir"
+          return 1
+      fi
+
+      if [[ -f "$YOLOX_MODEL_FILE" ]]; then
+          FINAL_SIZE=$(stat -c%s "$YOLOX_MODEL_FILE" 2>/dev/null || stat -f%z "$YOLOX_MODEL_FILE" 2>/dev/null)
+          if [[ "$FINAL_SIZE" -lt "$MIN_YOLOX_SIZE" ]]; then
+              echo "ERROR: YOLOX file seems too small (size: $FINAL_SIZE bytes)." >&2
+              cd "$original_dir"
+              return 1
+          else
+              echo "INFO: YOLOX downloaded (size: $(numfmt --to=iec-i --suffix=B $FINAL_SIZE 2>/dev/null || echo $FINAL_SIZE))"
+          fi
+      else
+          echo "ERROR: YOLOX download failed: file not found." >&2
+          cd "$original_dir"
+          return 1
+      fi
+  fi
+
+  echo "INFO: YOLOX OK"
+
+  # ==========================================
+  # 3. config.json
+  CONFIG_FILE="$MODEL_ROOT/config.json"
+  YOLOX_ABS_PATH=$(cd "$(dirname "$YOLOX_MODEL_FILE")" && pwd)/$(basename "$YOLOX_MODEL_FILE")
+  YOLOX_OS_PATH=$(format_path_for_env "$YOLOX_ABS_PATH")
+  YOLOX_CONFIG_PATH=$(escape_backslashes "$YOLOX_OS_PATH")
+
+  cat > "$CONFIG_FILE" <<EOF
+{
+    "model_path": "$YOLOX_CONFIG_PATH",
+    "label_map": {
+        "0": "Caption",
+        "1": "Footnote",
+        "2": "Formula",
+        "3": "List-item",
+        "4": "Page-footer",
+        "5": "Page-header",
+        "6": "Picture",
+        "7": "Section-header",
+        "8": "Table",
+        "9": "Text",
+        "10": "Title"
+    }
+}
+EOF
+  echo "INFO: config.json generated"
+
+  # ==========================================
+  # 4. Update .env
+  cd "$env_file_dir" || return 1
+  touch "$env_file_path"
+
+  TT_MODEL_DIR_ABS_PATH=$(cd "$TT_MODEL_DIR_PATH" && pwd)
+  CONFIG_FILE_ABS_PATH=$(cd "$(dirname "$CONFIG_FILE")" && pwd)/$(basename "$CONFIG_FILE")
+  TT_MODEL_DIR_ENV_PATH=$(format_path_for_env "$TT_MODEL_DIR_ABS_PATH")
+  CONFIG_FILE_ENV_PATH=$(format_path_for_env "$CONFIG_FILE_ABS_PATH")
+  TT_MODEL_DIR_ENV_PATH=$(escape_backslashes "$TT_MODEL_DIR_ENV_PATH")
+  CONFIG_FILE_ENV_PATH=$(escape_backslashes "$CONFIG_FILE_ENV_PATH")
+
+  if declare -f update_env_var > /dev/null; then
+      update_env_var "TABLE_TRANSFORMER_MODEL_PATH" "$TT_MODEL_DIR_ENV_PATH"
+      update_env_var "UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH" "$CONFIG_FILE_ENV_PATH"
+  else
+      sed -i.bak "/^TABLE_TRANSFORMER_MODEL_PATH=/d" "$env_file_path" 2>/dev/null || true
+      echo "TABLE_TRANSFORMER_MODEL_PATH="$TT_MODEL_DIR_ENV_PATH"" >> "$env_file_path"
+
+      sed -i.bak "/^UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH=/d" "$env_file_path" 2>/dev/null || true
+      echo "UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH="$CONFIG_FILE_ENV_PATH"" >> "$env_file_path"
+      rm -f "$env_file_path.bak" 2>/dev/null
+  fi
+
+  echo "INFO: Environment file updated"
+  cd "$original_dir"
+}
+
 clean() {
   export MINIO_ACCESS_KEY=
   export MINIO_SECRET_KEY=
@@ -600,6 +877,13 @@ prepare_directory_and_data() {
   create_dir_with_permission "$ROOT_DIR/minio" 775
   create_dir_with_permission "$ROOT_DIR/redis" 775
 
+  echo "📦 Check the status of model configuration..."
+  download_and_config_models || { 
+    echo "⚠️  A warning occurred during the model configuration step, but subsequent deployment will proceed..." 
+    # Do not exit here; the user may choose N or prefer to continue after a download failure.
+  }
+  echo ""
+
   cp -rn volumes $ROOT_DIR
   chmod -R 775 $ROOT_DIR/volumes
   echo "   📁 Directory $ROOT_DIR/volumes has been created and permissions set to 775."
@@ -1057,6 +1341,8 @@ main_deploy() {
   select_terminal_tool || { echo "❌ Terminal tool container configuration failed"; exit 1; }
   choose_image_env || { echo "❌ Image environment setup failed"; exit 1; }
 
+  select_model_download || { echo "❌ Model download failed"; exit 1;}
+
   # Set NEXENT_MCP_DOCKER_IMAGE in .env file
   if [ -n "${NEXENT_MCP_DOCKER_IMAGE:-}" ]; then
     update_env_var "NEXENT_MCP_DOCKER_IMAGE" "${NEXENT_MCP_DOCKER_IMAGE}"
@@ -1142,7 +1428,7 @@ docker_compose_command=""
 case $version_type in
     "v1")
         echo "Detected Docker Compose V1, version: $version_number"
-        # The version ​​v1.28.0​​ is the minimum requirement in Docker Compose v1 that explicitly supports interpolation syntax with default values like ${VAR:-default}
+        # The version 1.28.0 is the minimum requirement in Docker Compose v1 for default interpolation syntax.
         if [[ $version_number < "1.28.0" ]]; then
             echo "Warning: V1 version is too old, consider upgrading to V2"
             exit 1
diff --git a/docker/init.sql b/docker/init.sql
index 75e9a818f..f808d9c06 100644
--- a/docker/init.sql
+++ b/docker/init.sql
@@ -213,6 +213,7 @@ CREATE TABLE IF NOT EXISTS "knowledge_record_t" (
   "embedding_model_name" varchar(200) COLLATE "pg_catalog"."default",
   "group_ids" varchar,
   "ingroup_permission" varchar(30),
+  "is_multimodal" varchar(1) COLLATE "pg_catalog"."default" DEFAULT 'N'::character varying,
   "create_time" timestamp(0) DEFAULT CURRENT_TIMESTAMP,
   "update_time" timestamp(0) DEFAULT CURRENT_TIMESTAMP,
   "delete_flag" varchar(1) COLLATE "pg_catalog"."default" DEFAULT 'N'::character varying,
@@ -230,6 +231,7 @@ COMMENT ON COLUMN "knowledge_record_t"."knowledge_sources" IS 'Knowledge base so
 COMMENT ON COLUMN "knowledge_record_t"."embedding_model_name" IS 'Embedding model name, used to record the embedding model used by the knowledge base';
 COMMENT ON COLUMN "knowledge_record_t"."group_ids" IS 'Knowledge base group IDs list';
 COMMENT ON COLUMN "knowledge_record_t"."ingroup_permission" IS 'In-group permission: EDIT, READ_ONLY, PRIVATE';
+COMMENT ON COLUMN "knowledge_record_t"."is_multimodal" IS 'whether it is multimodal';
 COMMENT ON COLUMN "knowledge_record_t"."create_time" IS 'Creation time, audit field';
 COMMENT ON COLUMN "knowledge_record_t"."update_time" IS 'Update time, audit field';
 COMMENT ON COLUMN "knowledge_record_t"."delete_flag" IS 'When deleted by user frontend, delete flag will be set to true, achieving soft delete effect. Optional values Y/N';
diff --git a/docker/sql/v1.8.1_0306_add_is_multimodal_to_knowledge_record_t.sql b/docker/sql/v1.8.1_0306_add_is_multimodal_to_knowledge_record_t.sql
new file mode 100644
index 000000000..d5b14bfbb
--- /dev/null
+++ b/docker/sql/v1.8.1_0306_add_is_multimodal_to_knowledge_record_t.sql
@@ -0,0 +1,5 @@
+-- Add is_multimodal column to knowledge_record_t table
+ALTER TABLE nexent.knowledge_record_t
+ADD COLUMN IF NOT EXISTS is_multimodal varchar(1) DEFAULT 'N';
+
+COMMENT ON COLUMN nexent.knowledge_record_t.is_multimodal IS 'whether it is multimodal';
diff --git a/frontend/app/[locale]/agents/components/agentConfig/ToolManagement.tsx b/frontend/app/[locale]/agents/components/agentConfig/ToolManagement.tsx
index c97536b92..481d71920 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/ToolManagement.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/ToolManagement.tsx
@@ -100,7 +100,8 @@ export default function ToolManagement({
   // Use tool list hook for data management
   const { availableTools } = useToolList();
 
-  const { isVlmAvailable, isEmbeddingAvailable } = useConfig();
+  const { isVlmAvailable, isEmbeddingAvailable, isMultiEmbeddingAvailable } = useConfig();
+  const isEmbeddingOrMultiAvailable = isEmbeddingAvailable || isMultiEmbeddingAvailable;
 
   // Prefetch knowledge bases for KB tools
   const { prefetchKnowledgeBases } = usePrefetchKnowledgeBases();
@@ -363,7 +364,10 @@ export default function ToolManagement({
                             tool.id
                           );
                           const isDisabledDueToVlm = isToolDisabledDueToVlm(tool.name, isVlmAvailable);
-                          const isDisabledDueToEmbedding = isToolDisabledDueToEmbedding(tool.name, isEmbeddingAvailable);
+                          const isDisabledDueToEmbedding = isToolDisabledDueToEmbedding(
+                            tool.name,
+                            isEmbeddingOrMultiAvailable
+                          );
                           const isDisabled = isDisabledDueToVlm || isDisabledDueToEmbedding || isReadOnly;
                           // Tooltip priority: permission > VLM > Embedding
                           const tooltipTitle = isReadOnly
@@ -468,7 +472,10 @@ export default function ToolManagement({
               {group.tools.map((tool) => {
                 const isSelected = originalSelectedToolIdsSet.has(tool.id);
                 const isDisabledDueToVlm = isToolDisabledDueToVlm(tool.name, isVlmAvailable);
-                const isDisabledDueToEmbedding = isToolDisabledDueToEmbedding(tool.name, isEmbeddingAvailable);
+                const isDisabledDueToEmbedding = isToolDisabledDueToEmbedding(
+                  tool.name,
+                  isEmbeddingOrMultiAvailable
+                );
                 const isDisabled = isDisabledDueToVlm || isDisabledDueToEmbedding || isReadOnly;
                 // Tooltip priority: permission > VLM > Embedding
                 const tooltipTitle = isReadOnly
diff --git a/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx b/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx
index 4808bd765..d67a5a901 100644
--- a/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx
+++ b/frontend/app/[locale]/agents/components/agentConfig/tool/ToolConfigModal.tsx
@@ -30,6 +30,10 @@ import { API_ENDPOINTS } from "@/services/api";
 import knowledgeBaseService from "@/services/knowledgeBaseService";
 import log from "@/lib/logger";
 import { isZhLocale, getLocalizedDescription } from "@/lib/utils";
+import {
+  isEmbeddingModelCompatible as isEmbeddingModelCompatibleBase,
+  isMultimodalConstraintMismatch as isMultimodalConstraintMismatchBase,
+} from "@/lib/knowledgeBaseCompatibility";
 
 export interface ToolConfigModalProps {
   isOpen: boolean;
@@ -459,6 +463,89 @@ export default function ToolConfigModal({
     }
   }, [configData]);
 
+  const currentMultiEmbeddingModel = useMemo(() => {
+    try {
+      const modelConfig = configData?.models;
+      return (
+        modelConfig?.multiEmbedding?.modelName ||
+        modelConfig?.multiEmbedding?.displayName ||
+        null
+      );
+    } catch {
+      return null;
+    }
+  }, [configData]);
+
+  const hasEmbeddingModel = Boolean(currentEmbeddingModel);
+  const hasMultiEmbeddingModel = Boolean(currentMultiEmbeddingModel);
+  const canToggleMultimodalParam = hasEmbeddingModel && hasMultiEmbeddingModel;
+  const forcedMultimodalValue = useMemo(() => {
+    if (!hasEmbeddingModel && hasMultiEmbeddingModel) {
+      return true;
+    }
+    if (hasEmbeddingModel && !hasMultiEmbeddingModel) {
+      return false;
+    }
+    return null;
+  }, [hasEmbeddingModel, hasMultiEmbeddingModel]);
+
+  const toolMultimodal = useMemo(() => {
+    const multimodalParam = currentParams.find(
+      (param) => param.name === "multimodal"
+    );
+    const value = multimodalParam?.value;
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return value === 1;
+    }
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "true") return true;
+      if (normalized === "false") return false;
+    }
+    return null;
+  }, [currentParams]);
+
+  useEffect(() => {
+    if (tool?.name !== "knowledge_base_search") return;
+    if (forcedMultimodalValue === null) return;
+
+    const index = currentParams.findIndex(
+      (param) => param.name === "multimodal"
+    );
+    if (index < 0) return;
+
+    const param = currentParams[index];
+    if (param.value === forcedMultimodalValue) return;
+
+    const updatedParams = [...currentParams];
+    updatedParams[index] = { ...param, value: forcedMultimodalValue };
+    setCurrentParams(updatedParams);
+
+    const fieldName = `param_${index}`;
+    form.setFieldValue(fieldName, forcedMultimodalValue);
+  }, [tool?.name, forcedMultimodalValue, currentParams, form]);
+
+  const isMultimodalConstraintMismatch = useCallback(
+    (kb: KnowledgeBase) => {
+      return isMultimodalConstraintMismatchBase(kb, toolMultimodal);
+    },
+    [toolMultimodal]
+  );
+
+  const isEmbeddingModelCompatible = useCallback(
+    (kb: KnowledgeBase) => {
+      return isEmbeddingModelCompatibleBase(
+        kb,
+        currentEmbeddingModel,
+        currentMultiEmbeddingModel
+      );
+    },
+    [currentEmbeddingModel, currentMultiEmbeddingModel]
+  );
+
   // Check if a knowledge base can be selected
   const canSelectKnowledgeBase = useCallback(
     (kb: KnowledgeBase): boolean => {
@@ -469,9 +556,17 @@ export default function ToolConfigModal({
         return false;
       }
 
+      // For nexent source, check model matching
+      if (kb.source === "nexent") {
+        if (isMultimodalConstraintMismatch(kb)) {
+          return false;
+        }
+        return isEmbeddingModelCompatible(kb);
+      }
+
       return true;
     },
-    [currentEmbeddingModel]
+    [isEmbeddingModelCompatible, isMultimodalConstraintMismatch]
   );
 
   // Track whether this is the first time opening the modal (reset when modal closes)
@@ -1290,7 +1385,7 @@ export default function ToolConfigModal({
             })}
             options={options.map((option) => ({
               value: option,
-              label: option,
+              label: String(option),
             }))}
           />
         );
@@ -1306,8 +1401,13 @@ export default function ToolConfigModal({
             />
           );
 
-        case TOOL_PARAM_TYPES.BOOLEAN:
-          return <Switch />;
+        case TOOL_PARAM_TYPES.BOOLEAN: {
+          const isMultimodalParam =
+            tool.name === "knowledge_base_search" && param.name === "multimodal";
+          return (
+            <Switch disabled={isMultimodalParam && !canToggleMultimodalParam} />
+          );
+        }
 
         case TOOL_PARAM_TYPES.STRING:
         case TOOL_PARAM_TYPES.ARRAY:
@@ -1662,6 +1762,8 @@ export default function ToolConfigModal({
         syncLoading={kbLoading}
         isSelectable={canSelectKnowledgeBase}
         currentEmbeddingModel={currentEmbeddingModel}
+        currentMultiEmbeddingModel={currentMultiEmbeddingModel}
+        toolMultimodal={toolMultimodal}
         difyConfig={
           toolKbType === "dify_search"
             ? difyConfig
diff --git a/frontend/app/[locale]/knowledges/KnowledgeBaseConfiguration.tsx b/frontend/app/[locale]/knowledges/KnowledgeBaseConfiguration.tsx
index a5e7d52d1..954c3b82e 100644
--- a/frontend/app/[locale]/knowledges/KnowledgeBaseConfiguration.tsx
+++ b/frontend/app/[locale]/knowledges/KnowledgeBaseConfiguration.tsx
@@ -26,7 +26,6 @@ import knowledgeBaseService from "@/services/knowledgeBaseService";
 import knowledgeBasePollingService from "@/services/knowledgeBasePollingService";
 import { KnowledgeBase } from "@/types/knowledgeBase";
 import { useConfig } from "@/hooks/useConfig";
-import { useModelList } from "@/hooks/model/useModelList";
 import {
   SETUP_PAGE_CONTAINER,
   TWO_COLUMN_LAYOUT,
@@ -128,9 +127,6 @@ function DataConfig({ isActive }: DataConfigProps) {
   const { modelConfig, data: configData, invalidateConfig, config, updateConfig, saveConfig } = useConfig();
   const { token } = theme.useToken();
 
-  // Get available embedding models for knowledge base creation
-  const { availableEmbeddingModels } = useModelList({ enabled: true });
-
   // Clear cache when component initializes
   useEffect(() => {
     localStorage.removeItem("preloaded_kb_data");
@@ -184,7 +180,7 @@ function DataConfig({ isActive }: DataConfigProps) {
   const [newKbName, setNewKbName] = useState("");
   const [newKbIngroupPermission, setNewKbIngroupPermission] = useState<string>("READ_ONLY");
   const [newKbGroupIds, setNewKbGroupIds] = useState<number[]>([]);
-  const [newKbEmbeddingModel, setNewKbEmbeddingModel] = useState<string>(""); // Selected embedding model for new KB
+  const [isMultimodal, setIsMultimodal] = useState(false);
   const [uploadFiles, setUploadFiles] = useState<File[]>([]);
   const [hasClickedUpload, setHasClickedUpload] = useState(false);
   const [showEmbeddingWarning, setShowEmbeddingWarning] = useState(false);
@@ -197,11 +193,28 @@ function DataConfig({ isActive }: DataConfigProps) {
   const [modelFilter, setModelFilter] = useState<string[]>([]);
   const contentRef = useRef<HTMLDivElement | null>(null);
 
+  const hasEmbeddingModel = Boolean(
+    modelConfig?.embedding?.modelName?.trim()
+  );
+  const hasMultiEmbeddingModel = Boolean(
+    modelConfig?.multiEmbedding?.modelName?.trim()
+  );
+  const canToggleMultimodal = hasEmbeddingModel && hasMultiEmbeddingModel;
+
   // Open warning modal when single Embedding model is not configured (ignore multi-embedding)
   useEffect(() => {
-    const singleEmbeddingModelName = modelConfig?.embedding?.modelName;
-    setShowEmbeddingWarning(!singleEmbeddingModelName);
-  }, [modelConfig?.embedding?.modelName]);
+    setShowEmbeddingWarning(!hasEmbeddingModel && !hasMultiEmbeddingModel);
+  }, [hasEmbeddingModel, hasMultiEmbeddingModel]);
+
+  useEffect(() => {
+    if (hasMultiEmbeddingModel && !hasEmbeddingModel) {
+      setIsMultimodal(true);
+      return;
+    }
+    if (hasEmbeddingModel && !hasMultiEmbeddingModel) {
+      setIsMultimodal(false);
+    }
+  }, [hasEmbeddingModel, hasMultiEmbeddingModel]);
 
   // Add event listener for selecting new knowledge base
   useEffect(() => {
@@ -618,15 +631,11 @@ function DataConfig({ isActive }: DataConfigProps) {
     setNewKbName(defaultName);
     setNewKbIngroupPermission("READ_ONLY");
     setNewKbGroupIds([]);
-    // Set default embedding model - prioritize config's default model, fall back to first available model
-    const configModel = modelConfig?.embedding?.modelName;
-    const defaultModel = configModel || (availableEmbeddingModels.length > 0
-      ? availableEmbeddingModels[0].displayName
-      : "");
-    setNewKbEmbeddingModel(defaultModel);
     setIsCreatingMode(true);
     setHasClickedUpload(false); // Reset upload button click state
     setUploadFiles([]); // Reset upload files array, clear all pending upload files
+
+    setIsMultimodal(hasMultiEmbeddingModel && !hasEmbeddingModel)
   };
 
   // Handle document deletion
@@ -687,7 +696,7 @@ function DataConfig({ isActive }: DataConfigProps) {
           "elasticsearch",
           newKbIngroupPermission,
           newKbGroupIds,
-          newKbEmbeddingModel
+          isMultimodal
         );
 
         if (!newKB) {
@@ -702,7 +711,7 @@ function DataConfig({ isActive }: DataConfigProps) {
         setHasClickedUpload(false);
         setNewlyCreatedKbId(newKB.id); // Mark this KB as newly created
 
-        await uploadDocuments(newKB.id, filesToUpload);
+        await uploadDocuments(newKB.id, filesToUpload, isMultimodal);
         setUploadFiles([]);
 
         knowledgeBasePollingService
@@ -738,7 +747,11 @@ function DataConfig({ isActive }: DataConfigProps) {
     }
 
     try {
-      await uploadDocuments(kbId, filesToUpload);
+      await uploadDocuments(
+        kbId,
+        filesToUpload,
+        kbState.activeKnowledgeBase?.is_multimodal
+      );
       setUploadFiles([]);
 
       knowledgeBasePollingService.triggerKnowledgeBaseListUpdate(true);
@@ -828,6 +841,11 @@ function DataConfig({ isActive }: DataConfigProps) {
     setNewKbName(name);
   };
 
+  const handleSetMultimodal = (is_multimodal: boolean) => {
+      if (!canToggleMultimodal) return;
+      setIsMultimodal(is_multimodal)
+    }
+
   // If Embedding model is not configured, show warning container instead of content
   if (showEmbeddingWarning) {
     return (
@@ -888,6 +906,9 @@ function DataConfig({ isActive }: DataConfigProps) {
               knowledgeBases={kbState.knowledgeBases}
               activeKnowledgeBase={kbState.activeKnowledgeBase}
               currentEmbeddingModel={kbState.currentEmbeddingModel}
+              currentMultiEmbeddingModel={
+                modelConfig?.multiEmbedding?.modelName?.trim() || null
+              }
               isLoading={kbState.isLoading}
               syncLoading={kbState.syncLoading}
               onClick={handleKnowledgeBaseClick}
@@ -948,10 +969,9 @@ function DataConfig({ isActive }: DataConfigProps) {
                 onIngroupPermissionChange={setNewKbIngroupPermission}
                 selectedGroupIds={newKbGroupIds}
                 onSelectedGroupIdsChange={setNewKbGroupIds}
-                // Embedding model for create mode
-                availableEmbeddingModels={availableEmbeddingModels}
-                selectedEmbeddingModel={newKbEmbeddingModel}
-                onEmbeddingModelChange={setNewKbEmbeddingModel}
+                isMultimodal={isMultimodal}
+                onMultimodalChange={handleSetMultimodal}
+                canToggleMultimodal={canToggleMultimodal}
                 // Upload related props
                 isDragging={uiState.isDragging}
                 onDragOver={handleDragOver}
@@ -972,15 +992,31 @@ function DataConfig({ isActive }: DataConfigProps) {
                 modelMismatch={hasKnowledgeBaseModelMismatch(
                   kbState.activeKnowledgeBase
                 )}
-                currentModel={kbState.currentEmbeddingModel || ""}
+                currentModel={
+                  kbState.activeKnowledgeBase.is_multimodal
+                    ? modelConfig?.multiEmbedding?.modelName?.trim() || ""
+                    : kbState.currentEmbeddingModel || ""
+                }
                 knowledgeBaseModel={kbState.activeKnowledgeBase.embeddingModel}
                 embeddingModelInfo={
                   hasKnowledgeBaseModelMismatch(kbState.activeKnowledgeBase)
-                    ? t("document.modelMismatch.withModels", {
-                        currentModel: kbState.currentEmbeddingModel || "",
-                        knowledgeBaseModel:
-                          kbState.activeKnowledgeBase.embeddingModel,
-                      })
+                    ? (() => {
+                        const currentModelName = kbState.activeKnowledgeBase.is_multimodal
+                          ? modelConfig?.multiEmbedding?.modelName?.trim() || ""
+                          : kbState.currentEmbeddingModel || "";
+                        const knowledgeBaseModel =
+                          kbState.activeKnowledgeBase.embeddingModel;
+                        if (!currentModelName) {
+                          return t("document.chunk.tooltip.disabledDueToModelMismatch", {
+                            currentModel: t("embedding.model.notConfigured"),
+                            knowledgeBaseModel,
+                          });
+                        }
+                        return t("document.modelMismatch.withModels", {
+                          currentModel: currentModelName,
+                          knowledgeBaseModel,
+                        });
+                      })()
                     : undefined
                 }
                 containerHeight={SETUP_PAGE_CONTAINER.MAIN_CONTENT_HEIGHT}
diff --git a/frontend/app/[locale]/knowledges/components/document/DocumentChunk.tsx b/frontend/app/[locale]/knowledges/components/document/DocumentChunk.tsx
index 5e963c545..2c8bcd4af 100644
--- a/frontend/app/[locale]/knowledges/components/document/DocumentChunk.tsx
+++ b/frontend/app/[locale]/knowledges/components/document/DocumentChunk.tsx
@@ -128,16 +128,25 @@ const DocumentChunk: React.FC<DocumentChunkProps> = ({
     setTooltipResetKey((prev) => prev + 1);
   }, []);
 
+  const hasKnowledgeBaseModel =
+    Boolean(knowledgeBaseEmbeddingModel) &&
+    knowledgeBaseEmbeddingModel !== "unknown";
+  const hasCurrentModel = Boolean(currentEmbeddingModel);
+  const currentModelLabel =
+    currentEmbeddingModel ?? t("embedding.model.notConfigured");
+
   // Determine if embedding models mismatch (specific condition for tooltip)
   const isEmbeddingModelMismatch = React.useMemo(() => {
-    if (!currentEmbeddingModel || !knowledgeBaseEmbeddingModel) {
-      return false;
-    }
-    if (knowledgeBaseEmbeddingModel === "unknown") {
+    if (!hasKnowledgeBaseModel) {
       return false;
     }
-    return currentEmbeddingModel !== knowledgeBaseEmbeddingModel;
-  }, [currentEmbeddingModel, knowledgeBaseEmbeddingModel]);
+    return !hasCurrentModel || currentEmbeddingModel !== knowledgeBaseEmbeddingModel;
+  }, [
+    currentEmbeddingModel,
+    hasCurrentModel,
+    hasKnowledgeBaseModel,
+    knowledgeBaseEmbeddingModel,
+  ]);
 
   // Determine if in read-only mode (embedding model mismatch OR user has READ_ONLY permission)
   // Note: isReadOnlyMode is broader, includes model mismatch and other conditions
@@ -146,37 +155,48 @@ const DocumentChunk: React.FC<DocumentChunkProps> = ({
     if (permission === "READ_ONLY") {
       return true;
     }
-    if (!currentEmbeddingModel || !knowledgeBaseEmbeddingModel) {
+    if (!hasKnowledgeBaseModel) {
       return false;
     }
-    if (knowledgeBaseEmbeddingModel === "unknown") {
-      return false;
-    }
-    return currentEmbeddingModel !== knowledgeBaseEmbeddingModel;
-  }, [currentEmbeddingModel, knowledgeBaseEmbeddingModel, permission]);
+    return !hasCurrentModel || currentEmbeddingModel !== knowledgeBaseEmbeddingModel;
+  }, [
+    currentEmbeddingModel,
+    hasCurrentModel,
+    hasKnowledgeBaseModel,
+    knowledgeBaseEmbeddingModel,
+    permission,
+  ]);
 
   // Determine if search should be disabled (only when embedding model mismatch, NOT for READ_ONLY permission)
   // This allows READ_ONLY users to still perform search
   const isSearchDisabled = React.useMemo(() => {
-    if (!currentEmbeddingModel || !knowledgeBaseEmbeddingModel) {
-      return false;
-    }
-    if (knowledgeBaseEmbeddingModel === "unknown") {
+    if (!hasKnowledgeBaseModel) {
       return false;
     }
-    return currentEmbeddingModel !== knowledgeBaseEmbeddingModel;
-  }, [currentEmbeddingModel, knowledgeBaseEmbeddingModel]);
+    return !hasCurrentModel || currentEmbeddingModel !== knowledgeBaseEmbeddingModel;
+  }, [
+    currentEmbeddingModel,
+    hasCurrentModel,
+    hasKnowledgeBaseModel,
+    knowledgeBaseEmbeddingModel,
+  ]);
 
   // Disabled tooltip message when embedding model mismatch
   const disabledTooltipMessage = React.useMemo(() => {
-    if (isEmbeddingModelMismatch && currentEmbeddingModel && knowledgeBaseEmbeddingModel && knowledgeBaseEmbeddingModel !== "unknown") {
+    if (isEmbeddingModelMismatch && hasKnowledgeBaseModel) {
       return t("document.chunk.tooltip.disabledDueToModelMismatch", {
-        currentModel: currentEmbeddingModel,
+        currentModel: currentModelLabel,
         knowledgeBaseModel: knowledgeBaseEmbeddingModel
       });
     }
     return "";
-  }, [isEmbeddingModelMismatch, currentEmbeddingModel, knowledgeBaseEmbeddingModel, t]);
+  }, [
+    currentModelLabel,
+    hasKnowledgeBaseModel,
+    isEmbeddingModelMismatch,
+    knowledgeBaseEmbeddingModel,
+    t,
+  ]);
 
   // Set active document when documents change
   useEffect(() => {
@@ -322,11 +342,13 @@ const DocumentChunk: React.FC<DocumentChunkProps> = ({
     }
 
     // Check embedding model consistency before searching
-    if (isEmbeddingModelMismatch && currentEmbeddingModel && knowledgeBaseEmbeddingModel && knowledgeBaseEmbeddingModel !== "unknown") {
-      message.error(t("document.chunk.error.searchFailed", {
-        currentModel: currentEmbeddingModel,
-        knowledgeBaseModel: knowledgeBaseEmbeddingModel
-      }));
+    if (isEmbeddingModelMismatch && hasKnowledgeBaseModel) {
+      message.error(
+        t("document.chunk.tooltip.disabledDueToModelMismatch", {
+          currentModel: currentModelLabel,
+          knowledgeBaseModel: knowledgeBaseEmbeddingModel,
+        })
+      );
       return;
     }
 
@@ -380,8 +402,9 @@ const DocumentChunk: React.FC<DocumentChunkProps> = ({
     resetChunkSearch,
     searchValue,
     t,
+    currentModelLabel,
+    hasKnowledgeBaseModel,
     isEmbeddingModelMismatch,
-    currentEmbeddingModel,
     knowledgeBaseEmbeddingModel,
   ]);
 
@@ -465,14 +488,13 @@ const DocumentChunk: React.FC<DocumentChunkProps> = ({
 
     // Check embedding model consistency before creating chunk
     if (chunkModalMode === "create") {
-      if (knowledgeBaseEmbeddingModel &&
-        knowledgeBaseEmbeddingModel !== "unknown" &&
-        currentEmbeddingModel &&
-        currentEmbeddingModel !== knowledgeBaseEmbeddingModel) {
-        message.error(t("document.chunk.error.createFailed", {
-          currentModel: currentEmbeddingModel,
-          knowledgeBaseModel: knowledgeBaseEmbeddingModel
-        }));
+      if (isEmbeddingModelMismatch && hasKnowledgeBaseModel) {
+        message.error(
+          t("document.chunk.tooltip.disabledDueToModelMismatch", {
+            currentModel: currentModelLabel,
+            knowledgeBaseModel: knowledgeBaseEmbeddingModel,
+          })
+        );
         return;
       }
     }
diff --git a/frontend/app/[locale]/knowledges/components/document/DocumentList.tsx b/frontend/app/[locale]/knowledges/components/document/DocumentList.tsx
index bf0925369..256917d77 100644
--- a/frontend/app/[locale]/knowledges/components/document/DocumentList.tsx
+++ b/frontend/app/[locale]/knowledges/components/document/DocumentList.tsx
@@ -79,6 +79,10 @@ interface DocumentListProps {
   onEmbeddingModelChange?: (value: string) => void;
   permission?: string; // User's permission for this knowledge base (READ_ONLY, EDIT, etc.)
 
+  isMultimodal?: boolean;
+  onMultimodalChange?: (is_nultimodal: boolean) => void;  
+  canToggleMultimodal?: boolean;
+
   // Upload related props
   isDragging?: boolean;
   onDragOver?: (e: React.DragEvent) => void;
@@ -122,6 +126,10 @@ const DocumentListContainer = forwardRef<DocumentListRef, DocumentListProps>(
       onEmbeddingModelChange,
       permission,
 
+      isMultimodal = false,
+      onMultimodalChange,
+      canToggleMultimodal = true,
+
       // Upload related props
       isDragging = false,
       onDragOver,
@@ -524,6 +532,39 @@ const DocumentListContainer = forwardRef<DocumentListRef, DocumentListProps>(
                         options={permissionOptions}
                       />
                     </Can>
+                    <Can permission="kb.groups:update">
+                      <button
+                        type="button"
+                        onClick={() => {
+                          if (canToggleMultimodal) {
+                            onMultimodalChange?.(!isMultimodal);
+                          }
+                        }}
+                        aria-pressed={isMultimodal}
+                        disabled={!canToggleMultimodal}
+                        style={{
+                          width: 80, // Keep width aligned with adjacent controls
+                          display: "inline-block",
+                          textAlign: "center",
+                          cursor: canToggleMultimodal ? "pointer" : "default",
+                          color: isMultimodal ? "#52c41a" : "#000000", // Success green when enabled, black when disabled
+                          fontWeight: isMultimodal ? 500 : 400, // Slightly bolder when enabled
+                          userSelect: "none", // Prevent text selection on double-click
+                          lineHeight: "32px", // Align with Select height
+                          outline: "none",
+                          background: "transparent",
+                          border: "none",
+                          padding: 0,
+                        }}
+                        title={
+                          isMultimodal
+                            ? "Multimodal: Enabled"
+                            : "Multimodal: Disabled"
+                        }
+                      >
+                        Multimodal
+                      </button>
+                    </Can>
                   </div>
                 </div>
               ) : (
diff --git a/frontend/app/[locale]/knowledges/components/knowledge/KnowledgeBaseList.tsx b/frontend/app/[locale]/knowledges/components/knowledge/KnowledgeBaseList.tsx
index cbff0297b..20bb76161 100644
--- a/frontend/app/[locale]/knowledges/components/knowledge/KnowledgeBaseList.tsx
+++ b/frontend/app/[locale]/knowledges/components/knowledge/KnowledgeBaseList.tsx
@@ -32,6 +32,7 @@ interface KnowledgeBaseListProps {
   knowledgeBases: KnowledgeBase[];
   activeKnowledgeBase: KnowledgeBase | null;
   currentEmbeddingModel: string | null;
+  currentMultiEmbeddingModel: string | null;
   isLoading?: boolean;
   syncLoading?: boolean;
   onClick: (kb: KnowledgeBase) => void;
@@ -57,6 +58,7 @@ const KnowledgeBaseList: React.FC<KnowledgeBaseListProps> = ({
   knowledgeBases,
   activeKnowledgeBase,
   currentEmbeddingModel,
+  currentMultiEmbeddingModel,
   isLoading = false,
   syncLoading = false,
   onClick,
@@ -127,6 +129,19 @@ const KnowledgeBaseList: React.FC<KnowledgeBaseListProps> = ({
     return `knowledgeBase.ingroup.permission.${permission || "DEFAULT"}`;
   };
 
+  const isModelMismatch = (kb: KnowledgeBase) => {
+    if (kb.embeddingModel === "unknown") return false;
+    if (kb.source === "datamate") return false;
+
+    if (kb.is_multimodal) {
+      if (!currentMultiEmbeddingModel) return true;
+      return kb.embeddingModel !== currentMultiEmbeddingModel;
+    }
+
+    if (!currentEmbeddingModel) return false;
+    return kb.embeddingModel !== currentEmbeddingModel;
+  };
+
   // Search and filter states
   const [searchKeyword, setSearchKeyword] = useState("");
   const [selectedSources, setSelectedSources] = useState<string[]>([]);
@@ -579,6 +594,13 @@ const KnowledgeBaseList: React.FC<KnowledgeBaseListProps> = ({
                                 })}
                               </span>
                             )}
+                            {isModelMismatch(kb) && (
+                                <span
+                                  className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_LAYOUT.SECOND_ROW_TAG_MARGIN} ${KB_TAG_VARIANTS.warning} mr-1`}
+                                >
+                                  {t("knowledgeBase.tag.modelMismatch")}
+                                </span>
+                              )}
 
                             {/* User group tags - only show when not PRIVATE */}
                             <Can permission="group:read">
@@ -592,6 +614,13 @@ const KnowledgeBaseList: React.FC<KnowledgeBaseListProps> = ({
                                   </span>
                                 ))}
                             </Can>
+                            {kb.is_multimodal && (
+                              <span
+                                className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_LAYOUT.SECOND_ROW_TAG_MARGIN} ${KB_TAG_VARIANTS.red} mr-1`}
+                              >
+                                multimodal
+                              </span>
+                            )}
                           </>
                         )}
                       </div>
diff --git a/frontend/app/[locale]/knowledges/contexts/DocumentContext.tsx b/frontend/app/[locale]/knowledges/contexts/DocumentContext.tsx
index b956dd919..7a2dcfb2e 100644
--- a/frontend/app/[locale]/knowledges/contexts/DocumentContext.tsx
+++ b/frontend/app/[locale]/knowledges/contexts/DocumentContext.tsx
@@ -112,7 +112,7 @@ export const DocumentContext = createContext<{
   state: DocumentState;
   dispatch: React.Dispatch<DocumentAction>;
   fetchDocuments: (kbId: string, forceRefresh?: boolean, kbSource?: string) => Promise<void>;
-  uploadDocuments: (kbId: string, files: File[]) => Promise<void>;
+  uploadDocuments: (kbId: string, files: File[], isMultimodal?: boolean) => Promise<void>;
   deleteDocument: (kbId: string, docId: string) => Promise<void>;
 }>({
   state: {
@@ -202,11 +202,11 @@ export const DocumentProvider: React.FC<DocumentProviderProps> = ({ children })
   }, [state.loadingKbIds, state.documentsMap, t]);
 
   // Upload documents to a knowledge base
-  const uploadDocuments = useCallback(async (kbId: string, files: File[]) => {
+  const uploadDocuments = useCallback(async (kbId: string, files: File[], isMultimodal?: boolean) => {
     dispatch({ type: DOCUMENT_ACTION_TYPES.SET_UPLOADING, payload: true });
     
     try {
-      await knowledgeBaseService.uploadDocuments(kbId, files);
+      await knowledgeBaseService.uploadDocuments(kbId, files, undefined, isMultimodal);
       
       // Set loading state before fetching latest documents
       dispatch({ type: DOCUMENT_ACTION_TYPES.SET_LOADING_DOCUMENTS, payload: true });
@@ -265,4 +265,4 @@ export const DocumentProvider: React.FC<DocumentProviderProps> = ({ children })
       {children}
     </DocumentContext.Provider>
   );
-}; 
\ No newline at end of file
+}; 
diff --git a/frontend/app/[locale]/knowledges/contexts/KnowledgeBaseContext.tsx b/frontend/app/[locale]/knowledges/contexts/KnowledgeBaseContext.tsx
index 5985c4b08..0aa397863 100644
--- a/frontend/app/[locale]/knowledges/contexts/KnowledgeBaseContext.tsx
+++ b/frontend/app/[locale]/knowledges/contexts/KnowledgeBaseContext.tsx
@@ -110,7 +110,7 @@ export const KnowledgeBaseContext = createContext<{
     source?: string,
     ingroup_permission?: string,
     group_ids?: number[],
-    embeddingModel?: string
+    is_multimodal?: boolean,
   ) => Promise<KnowledgeBase | null>;
   deleteKnowledgeBase: (id: string) => Promise<boolean>;
   selectKnowledgeBase: (id: string) => void;
@@ -125,6 +125,7 @@ export const KnowledgeBaseContext = createContext<{
     selectedIds: [],
     activeKnowledgeBase: null,
     currentEmbeddingModel: null,
+    currentMultiEmbeddingModel: null,
     isLoading: false,
     syncLoading: false,
     error: null,
@@ -159,6 +160,7 @@ export const KnowledgeBaseProvider: React.FC<KnowledgeBaseProviderProps> = ({
     selectedIds: [],
     activeKnowledgeBase: null,
     currentEmbeddingModel: null,
+    currentMultiEmbeddingModel: null,
     isLoading: false,
     syncLoading: false,
     error: null,
@@ -200,9 +202,29 @@ export const KnowledgeBaseProvider: React.FC<KnowledgeBaseProviderProps> = ({
   // Note: Always return false to remove model mismatch restrictions
   const hasKnowledgeBaseModelMismatch = useCallback(
     (kb: KnowledgeBase): boolean => {
-      return false;
+      if (kb.embeddingModel === "unknown") {
+        return false;
+      }
+      // DataMate knowledge bases don't report model mismatch (they are always selectable)
+      if (kb.source === "datamate") {
+        return false;
+      }
+
+      if (kb.is_multimodal) {
+        const multiEmbeddingModel =
+          modelConfig?.multiEmbedding?.modelName?.trim() || "";
+        if (!multiEmbeddingModel) {
+          return true;
+        }
+        return kb.embeddingModel !== multiEmbeddingModel;
+      }
+
+      if (!state.currentEmbeddingModel) {
+        return false;
+      }
+      return kb.embeddingModel !== state.currentEmbeddingModel;
     },
-    []
+    [modelConfig?.multiEmbedding?.modelName, state.currentEmbeddingModel]
   );
 
   // Load knowledge base data (supports force fetch from server and load selected status) - optimized with useCallback
@@ -311,17 +333,22 @@ export const KnowledgeBaseProvider: React.FC<KnowledgeBaseProviderProps> = ({
       source: string = "elasticsearch",
       ingroup_permission?: string,
       group_ids?: number[],
-      embeddingModel?: string
+      is_multimodal?: boolean
     ) => {
       try {
+        const multiEmbeddingModel =
+          modelConfig?.multiEmbedding?.modelName?.trim() || "";
+        const embeddingModel = is_multimodal
+          ? multiEmbeddingModel
+          : state.currentEmbeddingModel || "text-embedding-3-small";
         const newKB = await knowledgeBaseService.createKnowledgeBase({
           name,
           description,
           source,
-          // Use provided embeddingModel if available, otherwise fall back to current model or default
-          embeddingModel: embeddingModel || state.currentEmbeddingModel || "",
+          embeddingModel,
           ingroup_permission,
           group_ids,
+          is_multimodal,
         });
         return newKB;
       } catch (error) {
@@ -333,7 +360,7 @@ export const KnowledgeBaseProvider: React.FC<KnowledgeBaseProviderProps> = ({
         return null;
       }
     },
-    [state.currentEmbeddingModel, t]
+    [modelConfig?.multiEmbedding?.modelName, state.currentEmbeddingModel, t]
   );
 
   // Delete knowledge base - memoized with useCallback
diff --git a/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx b/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx
index 4c26da19d..8545e7658 100644
--- a/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx
+++ b/frontend/app/[locale]/models/components/model/ModelAddDialog.tsx
@@ -277,7 +277,7 @@ export const ModelAddDialog = ({
   let getModelList;
   let getProviderSelectedModalList;
 
-// 2. 根据条件赋值
+  // 2. Select provider-specific hooks
   if (form.provider === "silicon") {
     ({ getModelList, getProviderSelectedModalList } = siliconHook);
   } else if (form.provider === "dashscope") {
@@ -454,7 +454,8 @@ export const ModelAddDialog = ({
         // Call backend healthcheck API for tenant management
         const result = await modelService.checkManageTenantModelConnectivity(
           tenantId,
-          form.displayName || form.name
+          form.displayName || form.name,
+          modelType,
         );
 
         // Set connectivity status
diff --git a/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx b/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx
index eeddec04f..75b8e2809 100644
--- a/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx
+++ b/frontend/app/[locale]/models/components/model/ModelEditDialog.tsx
@@ -113,7 +113,8 @@ export const ModelEditDialog = ({
         // Call backend healthcheck API for tenant management
         const result = await modelService.checkManageTenantModelConnectivity(
           tenantId,
-          form.displayName || form.name
+          form.displayName || form.name,
+          modelType,
         );
 
         // Set connectivity status
diff --git a/frontend/app/[locale]/models/components/modelConfig.tsx b/frontend/app/[locale]/models/components/modelConfig.tsx
index e20e74876..5e91f71f1 100644
--- a/frontend/app/[locale]/models/components/modelConfig.tsx
+++ b/frontend/app/[locale]/models/components/modelConfig.tsx
@@ -527,6 +527,7 @@ export const ModelConfigSection = forwardRef<
           try {
             const isConnected = await modelService.verifyCustomModel(
               modelName,
+              modelType,
               signal
             );
 
@@ -603,7 +604,7 @@ export const ModelConfigSection = forwardRef<
     throttleTimerRef.current = setTimeout(async () => {
       try {
         // Use modelService to verify model
-        const isConnected = await modelService.verifyCustomModel(displayName);
+        const isConnected = await modelService.verifyCustomModel(displayName, modelType);
 
         // Update model status
         updateModelStatus(
diff --git a/frontend/app/[locale]/tenant-resources/components/resources/ModelList.tsx b/frontend/app/[locale]/tenant-resources/components/resources/ModelList.tsx
index 6de719127..e06ea0f58 100644
--- a/frontend/app/[locale]/tenant-resources/components/resources/ModelList.tsx
+++ b/frontend/app/[locale]/tenant-resources/components/resources/ModelList.tsx
@@ -92,7 +92,7 @@ export default function ModelList({ tenantId }: { tenantId: string | null }) {
   };
 
   // Handle checking model connectivity
-  const handleCheckConnectivity = async (displayName: string) => {
+  const handleCheckConnectivity = async (displayName: string, modelType: string) => {
     if (!tenantId) {
       message.error(t("tenantResources.tenants.tenantIdRequired"));
       return;
@@ -102,7 +102,8 @@ export default function ModelList({ tenantId }: { tenantId: string | null }) {
     try {
       const isConnected = await modelService.checkManageTenantModelConnectivity(
         tenantId,
-        displayName
+        displayName,
+        modelType
       );
       if (isConnected) {
         message.success(t("tenantResources.models.connectivitySuccess"));
@@ -197,7 +198,7 @@ export default function ModelList({ tenantId }: { tenantId: string | null }) {
             <Button
               type="text"
               icon={checkingConnectivity.has(record.displayName) ? <RefreshCw className="h-4 w-4 animate-spin" /> : <RefreshCw className="h-4 w-4" />}
-              onClick={() => handleCheckConnectivity(record.displayName)}
+              onClick={() => handleCheckConnectivity(record.displayName, record.type)}
               size="small"
               loading={checkingConnectivity.has(record.displayName)}
             />
diff --git a/frontend/components/tool-config/KnowledgeBaseSelectorModal.tsx b/frontend/components/tool-config/KnowledgeBaseSelectorModal.tsx
index 995df088f..a3c72e804 100644
--- a/frontend/components/tool-config/KnowledgeBaseSelectorModal.tsx
+++ b/frontend/components/tool-config/KnowledgeBaseSelectorModal.tsx
@@ -20,6 +20,10 @@ import {
 
 import { KnowledgeBase } from "@/types/knowledgeBase";
 import { KB_LAYOUT, KB_TAG_VARIANTS } from "@/const/knowledgeBaseLayout";
+import {
+  isEmbeddingModelCompatible as isEmbeddingModelCompatibleBase,
+  isMultimodalConstraintMismatch as isMultimodalConstraintMismatchBase,
+} from "@/lib/knowledgeBaseCompatibility";
 
 interface KnowledgeBaseSelectorProps {
   isOpen: boolean;
@@ -72,6 +76,8 @@ interface KnowledgeBaseSelectorModalProps extends KnowledgeBaseSelectorProps {
   // Selection validation props
   isSelectable?: (kb: KnowledgeBase) => boolean;
   currentEmbeddingModel?: string | null;
+  currentMultiEmbeddingModel?: string | null;
+  toolMultimodal?: boolean | null;
   // Dify/iData configuration for fetching knowledge bases
   difyConfig?: {
     serverUrl?: string;
@@ -98,6 +104,8 @@ export default function KnowledgeBaseSelectorModal({
   syncLoading = false,
   isSelectable,
   currentEmbeddingModel = null,
+  currentMultiEmbeddingModel = null,
+  toolMultimodal = null,
   difyConfig,
 }: KnowledgeBaseSelectorModalProps) {
   const { t } = useTranslation("common");
@@ -182,6 +190,24 @@ export default function KnowledgeBaseSelectorModal({
     }
   }, []);
 
+  const isMultimodalConstraintMismatch = useCallback(
+    (kb: KnowledgeBase) => {
+      return isMultimodalConstraintMismatchBase(kb, toolMultimodal);
+    },
+    [toolMultimodal]
+  );
+
+  const isEmbeddingModelCompatible = useCallback(
+    (kb: KnowledgeBase) => {
+      return isEmbeddingModelCompatibleBase(
+        kb,
+        currentEmbeddingModel,
+        currentMultiEmbeddingModel
+      );
+    },
+    [currentEmbeddingModel, currentMultiEmbeddingModel]
+  );
+
   // Check if a knowledge base can be selected
   const checkCanSelect = useCallback(
     (kb: KnowledgeBase): boolean => {
@@ -198,9 +224,53 @@ export default function KnowledgeBaseSelectorModal({
         return false;
       }
 
+      // 2. For nexent source, check model matching
+      if (kb.source === "nexent") {
+        if (isMultimodalConstraintMismatch(kb)) {
+          return false;
+        }
+        return isEmbeddingModelCompatible(kb);
+      }
+
       return true;
     },
-    [isSelectable]
+    [
+      isSelectable,
+      isEmbeddingModelCompatible,
+      isMultimodalConstraintMismatch,
+    ]
+  );
+
+  const getModelMismatch = useCallback(
+    (kb: KnowledgeBase): boolean => {
+      if (kb.source !== "nexent") {
+        return false;
+      }
+
+      const hasMultimodalConstraintMismatch =
+        isMultimodalConstraintMismatchBase(kb, toolMultimodal);
+      if (hasMultimodalConstraintMismatch) {
+        return true;
+      }
+
+      const embeddingModel = kb.embeddingModel;
+      if (!embeddingModel || embeddingModel === "unknown") {
+        return false;
+      }
+
+      if (kb.is_multimodal) {
+        if (!currentMultiEmbeddingModel) {
+          return true;
+        }
+        return embeddingModel !== currentMultiEmbeddingModel;
+      }
+
+      if (!currentEmbeddingModel) {
+        return false;
+      }
+      return embeddingModel !== currentEmbeddingModel;
+    },
+    [currentEmbeddingModel, currentMultiEmbeddingModel, toolMultimodal]
   );
 
   // Filter knowledge bases based on tool type, search, and filters
@@ -622,6 +692,7 @@ export default function KnowledgeBaseSelectorModal({
                   String(selectedId).trim() === String(kb.id).trim()
               );
               const canSelect = checkCanSelect(kb);
+              const hasModelMismatch = getModelMismatch(kb);
 
               return (
                 <div
@@ -685,71 +756,85 @@ export default function KnowledgeBaseSelectorModal({
                         </p>
                       </div>
 
-                      {/* First row: Basic info tags */}
-                      <div
-                        className={`flex flex-wrap items-center ${KB_LAYOUT.TAG_MARGIN} ${KB_LAYOUT.TAG_SPACING}`}
-                      >
-                        {/* Document count tag */}
-                        <span
-                          className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
-                        >
-                          {t("knowledgeBase.tag.documents", {
-                            count: kb.documentCount || 0,
-                          })}
-                        </span>
-
-                        {/* Chunk count tag */}
-                        <span
-                          className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
-                        >
-                          {t("knowledgeBase.tag.chunks", {
-                            count: kb.chunkCount || 0,
-                          })}
-                        </span>
-
-                        {/* Source tag */}
-                        <span
-                          className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
-                        >
-                          {t("knowledgeBase.tag.source", {
-                            source: t(`knowledgeBase.source.${kb.source}`, {
-                              defaultValue: kb.source,
-                            }),
-                          })}
-                        </span>
-
-                        {/* Creation date - only show when there are documents or chunks */}
-                        {((kb.documentCount || 0) > 0 ||
-                          (kb.chunkCount || 0) > 0) && (
-                          <span
-                            className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
+                      { (kb.chunkCount || 0) > 0 && (
+                        <>
+                          {/* First row: Basic info tags */}
+                          <div
+                            className={`flex flex-wrap items-center ${KB_LAYOUT.TAG_MARGIN} ${KB_LAYOUT.TAG_SPACING}`}
                           >
-                            {t("knowledgeBase.tag.createdAt", {
-                              date: formatDate(kb.createdAt),
-                            })}
-                          </span>
-                        )}
-                      </div>
+                            {/* Document count tag */}
+                            <span
+                              className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
+                            >
+                              {t("knowledgeBase.tag.documents", {
+                                count: kb.documentCount || 0,
+                              })}
+                            </span>
 
-                      {/* Second row: Model tags */}
-                      <div
-                        className={`flex flex-wrap items-center ${KB_LAYOUT.SECOND_ROW_TAG_MARGIN} ${KB_LAYOUT.TAG_SPACING}`}
-                      >
-                        {/* Model tag - only show when model is not "unknown" and there are documents or chunks */}
-                        {((kb.documentCount || 0) > 0 ||
-                          (kb.chunkCount || 0) > 0) &&
-                          kb.embeddingModel &&
-                          kb.embeddingModel !== "unknown" && (
+                            {/* Chunk count tag */}
                             <span
-                              className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.model} mr-1`}
+                              className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
                             >
-                              {getModelDisplayName(kb.embeddingModel)}
-                              {t("knowledgeBase.tag.model", {
-                                model: "",
+                              {t("knowledgeBase.tag.chunks", {
+                                count: kb.chunkCount || 0,
                               })}
                             </span>
-                          )}
-                      </div>
+
+                            {/* Source tag */}
+                            <span
+                              className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
+                            >
+                              {t("knowledgeBase.tag.source", {
+                                source: t(`knowledgeBase.source.${kb.source}`, {
+                                  defaultValue: kb.source,
+                                }),
+                              })}
+                            </span>
+
+                            {/* Creation date */}
+                            <span
+                              className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.default} mr-1`}
+                            >
+                              {t("knowledgeBase.tag.createdAt", {
+                                date: formatDate(kb.createdAt),
+                              })}
+                            </span>
+                          </div>
+
+                          {/* Second row: Model tags */}
+                          <div
+                            className={`flex flex-wrap items-center ${KB_LAYOUT.SECOND_ROW_TAG_MARGIN} ${KB_LAYOUT.TAG_SPACING}`}
+                          >
+                            {/* Model tag - only show when model is not "unknown" */}
+                            {kb.embeddingModel &&
+                              kb.embeddingModel !== "unknown" && (
+                                <span
+                                  className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.model} mr-1`}
+                                >
+                                  {getModelDisplayName(kb.embeddingModel)}
+                                  {t("knowledgeBase.tag.model", {
+                                    model: "",
+                                  })}
+                                </span>
+                              )}
+                            {kb.documentCount > 0 && kb.is_multimodal && (
+                              <span
+                                className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.red} mr-1`}
+                              >
+                                multimodal
+                              </span>
+                            )}
+                            {/* Model mismatch tag - only for nexent source */}
+                            {hasModelMismatch && (
+                              <span
+                                className={`inline-flex items-center ${KB_LAYOUT.TAG_PADDING} ${KB_LAYOUT.TAG_ROUNDED} ${KB_LAYOUT.TAG_TEXT} ${KB_TAG_VARIANTS.warning} mr-1`}
+                              >
+                                {t("knowledgeBase.tag.modelMismatch")}
+                              </span>
+                            )}
+                          </div>
+                        </>
+                      )}
                     </div>
                   </div>
                 </div>
diff --git a/frontend/const/agentConfig.ts b/frontend/const/agentConfig.ts
index d1ac5ffd5..78d155641 100644
--- a/frontend/const/agentConfig.ts
+++ b/frontend/const/agentConfig.ts
@@ -97,6 +97,7 @@ export const TOOL_PARAM_OPTIONS = {
   // Knowledge base search tool
   knowledge_base_search: {
     search_mode: ["hybrid", "accurate", "semantic"],
+    multimodal: [true, false],
   },
   // Dify search tool
   dify_search: {
@@ -117,11 +118,12 @@ export const TOOL_PARAM_OPTIONS = {
 export function getToolParamOptions(
   toolName: string,
   paramName: string
-): string[] | undefined {
+): string[] | boolean[] | undefined {
   const toolOptions =
     TOOL_PARAM_OPTIONS[toolName as keyof typeof TOOL_PARAM_OPTIONS];
   if (!toolOptions) return undefined;
   return toolOptions[paramName as keyof typeof toolOptions] as
     | string[]
+    | boolean[]
     | undefined;
 }
diff --git a/frontend/const/knowledgeBaseLayout.ts b/frontend/const/knowledgeBaseLayout.ts
index 082c40be5..550ee6dc1 100644
--- a/frontend/const/knowledgeBaseLayout.ts
+++ b/frontend/const/knowledgeBaseLayout.ts
@@ -56,4 +56,6 @@ export const KB_TAG_VARIANTS = {
   model: "bg-green-50 text-green-700 border border-green-200",
   // Yellow tag for model mismatch
   warning: "bg-yellow-100 text-yellow-800 border border-yellow-200",
+  // Red tag for multimodal models
+  red: "bg-red-50 text-red-700 border border-red-200",
 } as const;
diff --git a/frontend/hooks/useConfig.ts b/frontend/hooks/useConfig.ts
index 70aee0df2..94cb3e36f 100644
--- a/frontend/hooks/useConfig.ts
+++ b/frontend/hooks/useConfig.ts
@@ -269,6 +269,9 @@ export function useConfig() {
   // Whether config has selected an Embedding model
   const isEmbeddingAvailable = !!(config?.models?.embedding?.modelName || config?.models?.embedding?.displayName);
 
+  // Whether config has selected a Multi-Embedding model
+  const isMultiEmbeddingAvailable = !!(config?.models?.multiEmbedding?.modelName || config?.models?.multiEmbedding?.displayName);
+
   // Default LLM model name from config (modelName or displayName)
   const defaultLlmModelName = config?.models?.llm?.modelName || config?.models?.llm?.displayName || "";
 
@@ -348,6 +351,7 @@ export function useConfig() {
     modelConfig: config?.models,
     isVlmAvailable,
     isEmbeddingAvailable,
+    isMultiEmbeddingAvailable,
     defaultLlmModelName,
     updateAppConfig,
     updateModelConfig,
diff --git a/frontend/lib/knowledgeBaseCompatibility.ts b/frontend/lib/knowledgeBaseCompatibility.ts
new file mode 100644
index 000000000..37381c048
--- /dev/null
+++ b/frontend/lib/knowledgeBaseCompatibility.ts
@@ -0,0 +1,46 @@
+import { KnowledgeBase } from "@/types/knowledgeBase";
+
+export const isMultimodalConstraintMismatch = (
+  kb: KnowledgeBase,
+  toolMultimodal: boolean | null
+): boolean => {
+  return (
+    toolMultimodal !== null &&
+    ((toolMultimodal && !kb.is_multimodal) ||
+      (!toolMultimodal && kb.is_multimodal))
+  );
+};
+
+export const isEmbeddingModelCompatible = (
+  kb: KnowledgeBase,
+  currentEmbeddingModel: string | null,
+  currentMultiEmbeddingModel: string | null
+): boolean => {
+  if (kb.is_multimodal) {
+    if (!currentMultiEmbeddingModel) {
+      return false;
+    }
+    if (
+      kb.embeddingModel &&
+      kb.embeddingModel !== "unknown" &&
+      kb.embeddingModel !== currentMultiEmbeddingModel
+    ) {
+      return false;
+    }
+    return true;
+  }
+
+  if (!currentEmbeddingModel) {
+    return true;
+  }
+
+  if (
+    kb.embeddingModel &&
+    kb.embeddingModel !== "unknown" &&
+    kb.embeddingModel !== currentEmbeddingModel
+  ) {
+    return false;
+  }
+
+  return true;
+};
diff --git a/frontend/public/locales/en/common.json b/frontend/public/locales/en/common.json
index fa135936b..11dac1fcb 100644
--- a/frontend/public/locales/en/common.json
+++ b/frontend/public/locales/en/common.json
@@ -642,7 +642,7 @@
   "document.chunk.error.updateFailed": "Failed to update chunk",
   "document.chunk.error.deleteFailed": "Failed to delete chunk",
   "document.chunk.error.missingChunkId": "Chunk identifier is missing",
-  "document.chunk.tooltip.disabledDueToModelMismatch": "The currently configured embedding model ({{currentModel}}) does not match the knowledge base model ({{knowledgeBaseModel}}). You cannot create chunks or perform retrieval until you use the same embedding model as the knowledge base.",
+  "document.chunk.tooltip.disabledDueToModelMismatch": "The currently configured embedding model ({{currentModel}}) does not match the knowledge base model ({{knowledgeBaseModel}}).",
   "document.chunk.form.createTitle": "Create chunk",
   "document.chunk.form.editTitle": "Edit chunk",
   "document.chunk.form.documentName": "Document",
@@ -2059,4 +2059,6 @@
   "errorCode.990105": "Internal server error. Please try again later.",
   "errorCode.990201": "Configuration not found.",
   "errorCode.990202": "Configuration update failed."
+,
+  "embedding.model.notConfigured": "Not configured"
 }
diff --git a/frontend/public/locales/zh/common.json b/frontend/public/locales/zh/common.json
index d233a9b4d..d4861e57d 100644
--- a/frontend/public/locales/zh/common.json
+++ b/frontend/public/locales/zh/common.json
@@ -644,7 +644,7 @@
   "document.chunk.error.updateFailed": "分片更新失败",
   "document.chunk.error.deleteFailed": "分片删除失败",
   "document.chunk.error.missingChunkId": "缺少分片 ID",
-  "document.chunk.tooltip.disabledDueToModelMismatch": "当前配置的向量模型 ({{currentModel}}) 与创建知识库所用模型 ({{knowledgeBaseModel}}) 不一致，无法创建分片或召回检索。",
+  "document.chunk.tooltip.disabledDueToModelMismatch": "当前配置的向量模型 ({{currentModel}}) 与创建知识库所用模型 ({{knowledgeBaseModel}}) 不一致",
   "document.chunk.form.createTitle": "新建分片",
   "document.chunk.form.editTitle": "编辑分片",
   "document.chunk.form.documentName": "所属文档",
@@ -2076,4 +2076,6 @@
   "errorCode.990105": "服务器内部错误，请稍后重试",
   "errorCode.990201": "配置不存在",
   "errorCode.990202": "配置更新失败"
+,
+  "embedding.model.notConfigured": "未配置"
 }
diff --git a/frontend/services/api.ts b/frontend/services/api.ts
index ba7c3a230..02925c326 100644
--- a/frontend/services/api.ts
+++ b/frontend/services/api.ts
@@ -130,10 +130,10 @@ export const API_ENDPOINTS = {
       `${API_BASE_URL}/model/delete?display_name=${encodeURIComponent(
         displayName
       )}`,
-    customModelHealthcheck: (displayName: string) =>
+    customModelHealthcheck: (displayName: string, modelType: string) =>
       `${API_BASE_URL}/model/healthcheck?display_name=${encodeURIComponent(
         displayName
-      )}`,
+      )}&model_type=${encodeURIComponent(modelType)}`,
     verifyModelConfig: `${API_BASE_URL}/model/temporary_healthcheck`,
     updateSingleModel: (displayName: string) =>
       `${API_BASE_URL}/model/update?display_name=${encodeURIComponent(displayName)}`,
diff --git a/frontend/services/knowledgeBaseService.ts b/frontend/services/knowledgeBaseService.ts
index fca77e72d..b2cc4fce3 100644
--- a/frontend/services/knowledgeBaseService.ts
+++ b/frontend/services/knowledgeBaseService.ts
@@ -19,6 +19,20 @@ import log from "@/lib/logger";
 // @ts-ignore
 const fetch: typeof fetchWithAuth = fetchWithAuth;
 
+const normalizeIsMultimodal = (value: unknown): boolean => {
+  if (value === true) return true;
+  if (value === false || value == null) return false;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "y" || normalized === "true" || normalized === "yes";
+  }
+  if (typeof value === "number") return value === 1;
+  return false;
+};
+
+const resolveIsMultimodal = (indexInfo: any, stats: any): boolean =>
+  normalizeIsMultimodal(indexInfo.is_multimodal ?? stats.is_multimodal);
+
 // Knowledge base service class
 class KnowledgeBaseService {
   // Check Elasticsearch health (force refresh, no caching for setup page)
@@ -488,6 +502,7 @@ class KnowledgeBaseService {
                       stats.creation_date ||
                       null,
                     embeddingModel: stats.embedding_model || "unknown",
+                    is_multimodal: resolveIsMultimodal(indexInfo, stats),
                     knowledge_sources:
                       indexInfo.knowledge_sources || "elasticsearch",
                     ingroup_permission: indexInfo.ingroup_permission || "",
@@ -555,6 +570,7 @@ class KnowledgeBaseService {
                     createdAt: stats.creation_date || null,
                     updatedAt: stats.update_date || stats.creation_date || null,
                     embeddingModel: stats.embedding_model || "unknown",
+                    is_multimodal: resolveIsMultimodal(indexInfo, stats),
                     knowledge_sources:
                       indexInfo.knowledge_sources || "datamate",
                     ingroup_permission: indexInfo.ingroup_permission || "",
@@ -680,10 +696,12 @@ class KnowledgeBaseService {
         embedding_model_name?: string;
         ingroup_permission?: string;
         group_ids?: number[];
+        is_multimodal?: boolean;
       } = {
         name: params.name,
         description: params.description || "",
         embedding_model_name: params.embeddingModel || "",
+        is_multimodal: params.is_multimodal || false
       };
 
       // Include group permission and user groups if provided
@@ -718,6 +736,7 @@ class KnowledgeBaseService {
         chunkCount: 0,
         createdAt: new Date().toISOString(),
         embeddingModel: params.embeddingModel || "",
+        is_multimodal: params.is_multimodal || false,
         avatar: "",
         chunkNum: 0,
         language: "",
@@ -827,7 +846,8 @@ class KnowledgeBaseService {
   async uploadDocuments(
     kbId: string,
     files: File[],
-    chunkingStrategy?: string
+    chunkingStrategy?: string,
+    isMultimodal?: boolean
   ): Promise<void> {
     try {
       // Create FormData object
@@ -889,6 +909,7 @@ class KnowledgeBaseService {
           files: filesToProcess,
           chunking_strategy: chunkingStrategy,
           destination: "minio",
+          is_multimodal: isMultimodal ?? false,
         }),
       });
 
diff --git a/frontend/services/modelService.ts b/frontend/services/modelService.ts
index a52b29b75..b72cae78c 100644
--- a/frontend/services/modelService.ts
+++ b/frontend/services/modelService.ts
@@ -397,12 +397,13 @@ export const modelService = {
   // Verify custom model connection
   verifyCustomModel: async (
     displayName: string,
+    modelType: string,
     signal?: AbortSignal
   ): Promise<boolean> => {
     try {
       if (!displayName) return false;
       const response = await fetch(
-        API_ENDPOINTS.model.customModelHealthcheck(displayName),
+        API_ENDPOINTS.model.customModelHealthcheck(displayName, modelType),
         {
           method: "POST",
           headers: getAuthHeaders(),
@@ -428,6 +429,7 @@ export const modelService = {
   checkManageTenantModelConnectivity: async (
     tenantId: string,
     displayName: string,
+    modelType: string,
     signal?: AbortSignal
   ): Promise<boolean> => {
     try {
@@ -441,6 +443,7 @@ export const modelService = {
         body: JSON.stringify({
           tenant_id: tenantId,
           display_name: displayName,
+          model_type: modelType
         }),
         signal,
       });
diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json
index d61634fac..75f792957 100644
--- a/frontend/tsconfig.json
+++ b/frontend/tsconfig.json
@@ -8,7 +8,7 @@
     "noEmit": true,
     "esModuleInterop": true,
     "module": "esnext",
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
     "resolveJsonModule": true,
     "isolatedModules": true,
     "jsx": "preserve",
diff --git a/frontend/types/knowledgeBase.ts b/frontend/types/knowledgeBase.ts
index e28d60fff..54da5a280 100644
--- a/frontend/types/knowledgeBase.ts
+++ b/frontend/types/knowledgeBase.ts
@@ -19,6 +19,7 @@ export interface KnowledgeBase {
   // Last update time of the knowledge base/index (may fall back to createdAt)
   updatedAt?: any;
   embeddingModel: string;
+  is_multimodal?: boolean;
   knowledge_sources?: string;
   ingroup_permission?: string;
   group_ids?: number[];
@@ -44,6 +45,7 @@ export interface KnowledgeBaseCreateParams {
   // Group permission and user groups for new knowledge bases
   ingroup_permission?: string;
   group_ids?: number[];
+  is_multimodal?: boolean;
 }
 
 // Document type
@@ -111,6 +113,7 @@ export interface KnowledgeBaseState {
   selectedIds: string[];
   activeKnowledgeBase: KnowledgeBase | null;
   currentEmbeddingModel: string | null;
+  currentMultiEmbeddingModel: string | null;
   isLoading: boolean;
   syncLoading: boolean;
   error: string | null;
diff --git a/sdk/nexent/core/models/embedding_model.py b/sdk/nexent/core/models/embedding_model.py
index 9e6dff427..80f897b89 100644
--- a/sdk/nexent/core/models/embedding_model.py
+++ b/sdk/nexent/core/models/embedding_model.py
@@ -19,6 +19,7 @@ def __init__(
         api_key: str = None,
         embedding_dim: int = None,
         ssl_verify: bool = True,
+        model_type: str = None
     ):
         """
         Initialize the embedding model.
@@ -84,6 +85,7 @@ def __init__(
         api_key: str = None,
         embedding_dim: int = None,
         ssl_verify: bool = True,
+        model_type: str = None
     ):
         super().__init__(model_name, base_url, api_key, embedding_dim, ssl_verify=ssl_verify)
 
@@ -126,6 +128,7 @@ def __init__(
         api_key: str = None,
         embedding_dim: int = None,
         ssl_verify: bool = True,
+        model_type: str = None
     ):
         super().__init__(model_name, base_url, api_key, embedding_dim, ssl_verify=ssl_verify)
 
@@ -162,6 +165,7 @@ def __init__(
         model_name: str = "jina-clip-v2",
         embedding_dim: int = 1024,
         ssl_verify: bool = True,
+        model_type: str = "multimodal"
     ):
         """Initialize JinaEmbedding with configuration."""
         self.api_key = api_key
@@ -169,6 +173,7 @@ def __init__(
         self.model = model_name
         self.embedding_dim = embedding_dim
         self.ssl_verify = ssl_verify
+        self.model_type = model_type
 
         self.headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"}
 
@@ -319,13 +324,14 @@ async def dimension_check(self, timeout: float = 5.0) -> List[List[float]]:
 
 
 class OpenAICompatibleEmbedding(TextEmbedding):
-    def __init__(self, model_name: str, base_url: str, api_key: str, embedding_dim: int, ssl_verify: bool = True):
+    def __init__(self, model_name: str, base_url: str, api_key: str, embedding_dim: int, model_type: str = "text", ssl_verify: bool = True):
         """Initialize OpenAICompatibleEmbedding with configuration from environment variables or provided parameters."""
         self.api_key = api_key
         self.api_url = base_url
         self.model = model_name
         self.embedding_dim = embedding_dim
         self.ssl_verify = ssl_verify
+        self.model_type=model_type
 
         self.headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"}
 
diff --git a/sdk/nexent/core/tools/knowledge_base_search_tool.py b/sdk/nexent/core/tools/knowledge_base_search_tool.py
index a8863caaf..830dbefb8 100644
--- a/sdk/nexent/core/tools/knowledge_base_search_tool.py
+++ b/sdk/nexent/core/tools/knowledge_base_search_tool.py
@@ -1,15 +1,17 @@
 import json
 import logging
+import os
 from typing import List, Optional
 
 from pydantic import Field
-from smolagents.tools import Tool
 from pydantic.fields import FieldInfo
+from smolagents.tools import Tool
+
 from ...vector_database.base import VectorDatabaseCore
 from ..models.embedding_model import BaseEmbedding
 from ..models.rerank_model import BaseRerank
-from ..utils.observer import MessageObserver, ProcessType
 from ..utils.constants import RERANK_OVERSEARCH_MULTIPLIER
+from ..utils.observer import MessageObserver, ProcessType
 from ..utils.tools_common_message import SearchResultTextMessage, ToolCategory, ToolSign
 
 
@@ -29,32 +31,35 @@ class KnowledgeBaseSearchTool(Tool):
         "Suitable for queries requiring access to stored knowledge that may not be publicly available."
     )
 
-    description_zh = "基于你的查询词在本地知识库中进行搜索，返回最相关的搜索结果。适用于检索本地知识库中存储的领域专业知识、文档和信息。当用户询问与专业知识、技术文档、领域专长、个人笔记或任何已在知识库中建立索引的信息相关的问题时，请使用此工具。适合需要访问非公开存储知识的查询。"
+    description_zh = (
+        "基于你的查询词在本地知识库中进行搜索，返回最相关的搜索结果。适用于检索本地知识库中存储的领域专业知识、文档和信息。"
+        "当用户询问与专业知识、技术文档、领域专长、个人笔记或任何已在知识库中建立索引的信息相关的问题时，请使用此工具。"
+        "适合需要访问非公开存储知识的查询。"
+    )
 
     inputs = {
         "query": {
             "type": "string",
             "description": "The search query to perform.",
-            "description_zh": "要执行的搜索查询词"
+            "description_zh": "要执行的搜索查询词",
         },
         "index_names": {
             "type": "array",
             "description": "The list of index names to search",
             "description_zh": "要索引的知识库",
-            "nullable": True
+            "nullable": True,
         },
     }
 
     init_param_descriptions = {
         "top_k": {
             "description": "Maximum number of search results",
-            "description_zh": "返回搜索结果的最大数量"
+            "description_zh": "返回搜索结果的最大数量",
         },
-
         "search_mode": {
             "description": "The search mode, optional values: hybrid, accurate, semantic",
-            "description_zh": "搜索模式，可选值：hybrid（混合）、accurate（精确）、semantic（语义）"
-        }
+            "description_zh": "搜索模式，可选值：hybrid（混合）、accurate（精确）、semantic（语义）",
+        },
     }
     output_type = "string"
     category = ToolCategory.SEARCH.value
@@ -64,28 +69,35 @@ class KnowledgeBaseSearchTool(Tool):
 
     def __init__(
         self,
-        top_k: int = Field(
-            description="Maximum number of search results", default=3),
-        index_names: List[str] = Field(
-            description="The list of index names to search"),
+        top_k: int = Field(description="Maximum number of search results", default=3),
+        multimodal: bool = Field(
+            description="Whether it is multimodal",
+            default=False,
+            json_schema_extra={"optional": False},
+        ),
+        index_names: List[str] = Field(description="The list of index names to search"),
         search_mode: str = Field(
             description="the search mode, optional values: hybrid, accurate, semantic",
             default="hybrid",
         ),
         rerank: bool = Field(
-            description="Whether to enable reranking for search results",
-            default=False),
+            description="Whether to enable reranking for search results", default=False
+        ),
         rerank_model_name: str = Field(
-            description="The name of the rerank model to use",
-            default=""),
+            description="The name of the rerank model to use", default=""
+        ),
         observer: MessageObserver = Field(
-            description="Message observer", default=None, exclude=True),
+            description="Message observer", default=None, exclude=True
+        ),
         embedding_model: BaseEmbedding = Field(
-            description="The embedding model to use", default=None, exclude=True),
+            description="The embedding model to use", default=None, exclude=True
+        ),
         rerank_model: BaseRerank = Field(
-            description="The rerank model to use", default=None, exclude=True),
+            description="The rerank model to use", default=None, exclude=True
+        ),
         vdb_core: VectorDatabaseCore = Field(
-            description="Vector database client", default=None, exclude=True),
+            description="Vector database client", default=None, exclude=True
+        ),
     ):
         """Initialize the KBSearchTool.
 
@@ -98,11 +110,13 @@ def __init__(
         """
         super().__init__()
         self.top_k = top_k
+        self.multimodal = multimodal
         self.observer = observer
         self.vdb_core = vdb_core
         self.index_names = [] if index_names is None else index_names
         self.search_mode = search_mode
         self.embedding_model = embedding_model
+        self.data_process_service = os.getenv("DATA_PROCESS_SERVICE")
         self.rerank = rerank
         self.rerank_model_name = rerank_model_name
         self.rerank_model = rerank_model
@@ -111,105 +125,156 @@ def __init__(
         self.running_prompt_zh = "知识库检索中..."
         self.running_prompt_en = "Searching the knowledge base..."
 
-
-    def forward(self, query: str, index_names: Optional[List[str]] = None) -> str:
-        # Parse index_names from string (always required)
-        search_index_names = index_names if index_names is not None else self.index_names
+    @staticmethod
+    def _resolve_field_value(value):
+        return value.default if isinstance(value, FieldInfo) else value
+
+    def forward(self, query: str, index_names: List[str] | str | None = None) -> str:
+        # Parse index_names from string (optional)
+        if index_names is None:
+            search_index_names = self.index_names
+        elif isinstance(index_names, str):
+            search_index_names = [
+                name.strip() for name in index_names.split(",") if name.strip()
+            ]
+        else:
+            search_index_names = index_names
 
         # Use the instance search_mode
         search_mode = self.search_mode
 
         # Send tool run message
-        if self.observer:
-            running_prompt = self.running_prompt_zh if self.observer.lang == "zh" else self.running_prompt_en
-            self.observer.add_message("", ProcessType.TOOL, running_prompt)
-            card_content = [{"icon": "search", "text": query}]
-            self.observer.add_message("", ProcessType.CARD, json.dumps(
-                card_content, ensure_ascii=False))
+        self._notify_search_start(query)
 
         # Log the index_names being used for this search
         logger.info(
-            f"KnowledgeBaseSearchTool called with query: '{query}', search_mode: '{search_mode}', index_names: {search_index_names}"
+            "KnowledgeBaseSearchTool called with query: '%s', search_mode: '%s', index_names: %s",
+            query,
+            search_mode,
+            search_index_names,
         )
 
+        if not search_index_names:
+            return json.dumps(
+                "No knowledge base selected. No relevant information found.",
+                ensure_ascii=False,
+            )
+
         # Compute effective top_k for initial search:
         # When rerank is enabled, retrieve more candidates to allow rerank to select the best ones.
-        # Note: smolagents Tool may not expand Field defaults, so use getattr with FieldInfo fallback.
-        effective_top_k = self.top_k
-        is_rerank = self.rerank
-        if isinstance(effective_top_k, FieldInfo):
-            effective_top_k = effective_top_k.default
-        if isinstance(is_rerank, FieldInfo):
-            is_rerank = is_rerank.default
+        # Note: smolagents Tool may not expand Field defaults, so use FieldInfo fallback.
+        effective_top_k = self._resolve_field_value(self.top_k)
+        is_rerank = self._resolve_field_value(self.rerank)
         if is_rerank:
             effective_top_k = effective_top_k * RERANK_OVERSEARCH_MULTIPLIER
 
-        if len(search_index_names) == 0:
-            return json.dumps("No knowledge base selected. No relevant information found.", ensure_ascii=False)
-
-        if search_mode == "hybrid":
-            kb_search_data = self.search_hybrid(
-                query=query, index_names=search_index_names, top_k=effective_top_k)
-        elif search_mode == "accurate":
-            kb_search_data = self.search_accurate(
-                query=query, index_names=search_index_names, top_k=effective_top_k)
-        elif search_mode == "semantic":
-            kb_search_data = self.search_semantic(
-                query=query, index_names=search_index_names, top_k=effective_top_k)
-        else:
-            raise Exception(
-                f"Invalid search mode: {search_mode}, only support: hybrid, accurate, semantic")
-
+        kb_search_data = self._run_search(
+            query=query,
+            index_names=search_index_names,
+            search_mode=search_mode,
+            top_k=effective_top_k,
+        )
         kb_search_results = kb_search_data["results"]
 
         if not kb_search_results:
             raise Exception(
-                "No results found! Try a less restrictive/shorter query.")
+                "No results found! Try a less restrictive/shorter query."
+            )
 
-        # Apply reranking if enabled
-        if self.rerank and self.rerank_model and kb_search_results:
-            try:
-                # Extract document contents for reranking
-                documents = [
-                    result.get("content", "") for result in kb_search_results
-                ]
-                # Perform reranking on all retrieved candidates
-                reranked_results = self.rerank_model.rerank(
-                    query=query,
-                    documents=documents,
-                    top_n=len(documents)
-                )
-                # Reorder and trim to top_k after reranking
-                if reranked_results:
-                    original_results_map = {
-                        i: kb_search_results[i] for i in range(len(kb_search_results))
-                    }
-                    kb_search_results = []
-                    for reranked_item in reranked_results[: self.top_k]:
-                        orig_idx = reranked_item.get("index")
-                        if orig_idx is not None and orig_idx in original_results_map:
-                            result = original_results_map[orig_idx]
-                            result["score"] = reranked_item.get(
-                                "relevance_score", result.get("score", 0)
-                            )
-                            kb_search_results.append(result)
-                    logger.info(
-                        f"Reranking applied: selected top {self.top_k} from "
-                        f"{len(documents)} candidates"
+        if is_rerank and self.rerank_model and kb_search_results:
+            kb_search_results = self._apply_rerank(query, kb_search_results)
+
+        (
+            search_results_json,
+            search_results_return,
+            images_list_url,
+        ) = self._build_search_results(kb_search_results)
+
+        self.record_ops += len(search_results_return)
+
+        self._record_search_results(
+            search_results_json=search_results_json,
+            images_list_url=images_list_url,
+            query=query,
+        )
+
+        return json.dumps(search_results_return, ensure_ascii=False)
+
+    def _notify_search_start(self, query: str) -> None:
+        if not self.observer:
+            return
+        running_prompt = (
+            self.running_prompt_zh
+            if self.observer.lang == "zh"
+            else self.running_prompt_en
+        )
+        self.observer.add_message("", ProcessType.TOOL, running_prompt)
+        card_content = [{"icon": "search", "text": query}]
+        self.observer.add_message(
+            "", ProcessType.CARD, json.dumps(card_content, ensure_ascii=False)
+        )
+
+    def _run_search(self, query: str, index_names: List[str], search_mode: str, top_k: int):
+        search_handlers = {
+            "hybrid": self.search_hybrid,
+            "accurate": self.search_accurate,
+            "semantic": self.search_semantic,
+        }
+        handler = search_handlers.get(search_mode)
+        if not handler:
+            raise Exception(
+                f"Invalid search mode: {search_mode}, only support: hybrid, accurate, semantic"
+            )
+        return handler(query=query, index_names=index_names, top_k=top_k)
+
+    def _apply_rerank(self, query: str, kb_search_results: List[dict]) -> List[dict]:
+        try:
+            documents = [result.get("content", "") for result in kb_search_results]
+            reranked_results = self.rerank_model.rerank(
+                query=query, documents=documents, top_n=len(documents)
+            )
+            if not reranked_results:
+                return kb_search_results
+
+            original_results_map = {
+                i: kb_search_results[i] for i in range(len(kb_search_results))
+            }
+            top_k = self._resolve_field_value(self.top_k)
+            reranked_kb_results = []
+            for reranked_item in reranked_results[:top_k]:
+                orig_idx = reranked_item.get("index")
+                if orig_idx is not None and orig_idx in original_results_map:
+                    result = original_results_map[orig_idx]
+                    result["score"] = reranked_item.get(
+                        "relevance_score", result.get("score", 0)
                     )
-            except Exception as e:
-                logger.warning(f"Reranking failed, using original results: {str(e)}")
+                    reranked_kb_results.append(result)
+            logger.info(
+                "Reranking applied: selected top %s from %s candidates",
+                top_k,
+                len(documents),
+            )
+            return reranked_kb_results
+        except Exception as e:
+            logger.warning("Reranking failed, using original results: %s", str(e))
+            return kb_search_results
+
+    @staticmethod
+    def _normalize_source_type(source_type: str) -> str:
+        return "file" if source_type in ["local", "minio"] else source_type
+
+    def _build_search_results(self, kb_search_results):
+        search_results_json = []
+        search_results_return = []
+        images_list_url = []
 
-        search_results_json = []  # Organize search results into a unified format
-        search_results_return = []  # Format for input to the large model
         for index, single_search_result in enumerate(kb_search_results):
-            # Temporarily correct the source_type stored in the knowledge base
-            source_type = single_search_result.get("source_type", "")
-            source_type = "file" if source_type in [
-                "local", "minio"] else source_type
-            title = single_search_result.get("title")
-            if not title:
-                title = single_search_result.get("filename", "")
+            source_type = self._normalize_source_type(
+                single_search_result.get("source_type", "")
+            )
+            title = single_search_result.get("title") or single_search_result.get(
+                "filename", ""
+            )
             search_result_message = SearchResultTextMessage(
                 title=title,
                 text=single_search_result.get("content", ""),
@@ -224,80 +289,193 @@ def forward(self, query: str, index_names: Optional[List[str]] = None) -> str:
                 tool_sign=self.tool_sign,
             )
 
+            image_url = self._extract_image_url(single_search_result)
+            if image_url:
+                images_list_url.append(image_url)
+
             search_results_json.append(search_result_message.to_dict())
             search_results_return.append(search_result_message.to_model_dict())
 
-        self.record_ops += len(search_results_return)
+        return search_results_json, search_results_return, images_list_url
 
-        # Record the detailed content of this search
-        if self.observer:
-            search_results_data = json.dumps(
-                search_results_json, ensure_ascii=False)
+    @staticmethod
+    def _extract_image_url(single_search_result):
+        if single_search_result.get("process_source") != "UniversalImageExtractor":
+            return None
+        try:
+            meta_data = json.loads(single_search_result.get("content"))
+        except (json.JSONDecodeError, TypeError):
+            logger.error("Failed to parse image metadata")
+            return None
+        return meta_data.get("image_url", None)
+
+    def _record_search_results(
+        self,
+        search_results_json: List[dict],
+        images_list_url: List[str],
+        query: str,
+    ) -> None:
+        if not self.observer:
+            return
+
+        search_results_data = json.dumps(search_results_json, ensure_ascii=False)
+        self.observer.add_message("", ProcessType.SEARCH_CONTENT, search_results_data)
+
+        if not images_list_url:
+            return
+
+        print("img list: ", images_list_url)
+        final_filtered_images = self._filter_images(images_list_url, query)
+        print("final_list: ", final_filtered_images)
+        if final_filtered_images:
+            search_images_list_json = json.dumps(
+                {"images_url": images_list_url}, ensure_ascii=False
+            )
             self.observer.add_message(
-                "", ProcessType.SEARCH_CONTENT, search_results_data)
-        return json.dumps(search_results_return, ensure_ascii=False)
+                "", ProcessType.PICTURE_WEB, search_images_list_json
+            )
 
-    def search_hybrid(self, query, index_names, top_k):
+    @staticmethod
+    def _format_vdb_results(results):
+        formatted_results = []
+        for result in results:
+            doc = result["document"]
+            doc["score"] = result["score"]
+            # Include source index in results
+            doc["index"] = result["index"]
+            if "content" in result:
+                doc["content"] = result["content"]
+            if "process_source" in result:
+                doc["process_source"] = result["process_source"]
+            formatted_results.append(doc)
+        return formatted_results
+
+    def _search_with(self, search_fn, query, index_names, label, top_k=None, **kwargs):
         try:
-            results = self.vdb_core.hybrid_search(
-                index_names=index_names, query_text=query, embedding_model=self.embedding_model, top_k=top_k
+            resolved_top_k = self._resolve_field_value(
+                self.top_k if top_k is None else top_k
             )
-
-            # Format results
-            formatted_results = []
-            for result in results:
-                doc = result["document"]
-                doc["score"] = result["score"]
-                # Include source index in results
-                doc["index"] = result["index"]
-                formatted_results.append(doc)
-
+            results = search_fn(
+                index_names=index_names,
+                query_text=query,
+                top_k=resolved_top_k,
+                **kwargs,
+            )
+            formatted_results = self._format_vdb_results(results)
             return {
                 "results": formatted_results,
                 "total": len(formatted_results),
             }
         except Exception as e:
-            raise Exception(f"Error during semantic search: {str(e)}")
+            raise Exception(f"Error during {label} search: {str(e)}")
+
+    def search_hybrid(self, query, index_names, top_k: Optional[int] = None):
+        return self._search_with(
+            self.vdb_core.hybrid_search,
+            query,
+            index_names,
+            "hybrid",
+            top_k=top_k,
+            embedding_model=self.embedding_model,
+        )
 
-    def search_accurate(self, query, index_names, top_k):
-        try:
-            results = self.vdb_core.accurate_search(
-                index_names=index_names, query_text=query, top_k=top_k)
-
-            # Format results
-            formatted_results = []
-            for result in results:
-                doc = result["document"]
-                doc["score"] = result["score"]
-                # Include source index in results
-                doc["index"] = result["index"]
-                formatted_results.append(doc)
+    def search_accurate(self, query, index_names, top_k: Optional[int] = None):
+        return self._search_with(
+            self.vdb_core.accurate_search,
+            query,
+            index_names,
+            "accurate",
+            top_k=top_k,
+        )
 
-            return {
-                "results": formatted_results,
-                "total": len(formatted_results),
-            }
-        except Exception as e:
-            raise Exception(detail=f"Error during accurate search: {str(e)}")
+    def search_semantic(self, query, index_names, top_k: Optional[int] = None):
+        return self._search_with(
+            self.vdb_core.semantic_search,
+            query,
+            index_names,
+            "semantic",
+            top_k=top_k,
+            embedding_model=self.embedding_model,
+        )
 
-    def search_semantic(self, query, index_names, top_k):
+    def _filter_images(self, images_list_url, query) -> list:
+        # kerry
+        """
+        Execute image filtering operation directly using the data processing service
+        :param images_list_url: List of image URLs to filter
+        :param query: Search query, used to filter images related to the query
+        """
+        import asyncio
+        import aiohttp
+
+        final_filtered_images = []
         try:
-            results = self.vdb_core.semantic_search(
-                index_names=index_names, query_text=query, embedding_model=self.embedding_model, top_k=top_k
+            # Define positive and negative prompts
+            positive_prompt = query
+            negative_prompt = (
+                "logo or banner or background or advertisement or icon or avatar"
             )
 
-            # Format results
-            formatted_results = []
-            for result in results:
-                doc = result["document"]
-                doc["score"] = result["score"]
-                # Include source index in results
-                doc["index"] = result["index"]
-                formatted_results.append(doc)
-
-            return {
-                "results": formatted_results,
-                "total": len(formatted_results),
-            }
+            # Define the async function to perform the filtering
+            async def process_images():
+                # Maximum number of concurrent requests
+                semaphore = asyncio.Semaphore(10)  # Limit concurrent requests
+
+                # Create a ClientSession
+                connector = aiohttp.TCPConnector(limit=0)
+                timeout = aiohttp.ClientTimeout(total=2)
+
+                async with aiohttp.ClientSession(
+                    connector=connector, timeout=timeout
+                ) as session:
+                    # Create a function to process a single image
+                    async def process_single_image(img_url):
+                        async with semaphore:
+                            try:
+                                api_url = (
+                                    f"{self.data_process_service}/tasks/filter_important_image"
+                                )
+                                data = {
+                                    "image_url": img_url,
+                                    "positive_prompt": positive_prompt,
+                                    "negative_prompt": negative_prompt,
+                                }
+                                async with session.post(api_url, data=data) as response:
+                                    if response.status != 200:
+                                        logger.info(
+                                            "API error for %s: %s",
+                                            img_url,
+                                            response.status,
+                                        )
+                                        return None
+                                    result = await response.json()
+                                    if result.get("is_important", False):
+                                        logger.info("Important image: %s", img_url)
+                                        return img_url
+                                    return None
+                            except Exception as e:
+                                logger.info(
+                                    "Error processing image %s: %s", img_url, str(e)
+                                )
+                                return None
+
+                    tasks = [process_single_image(url) for url in images_list_url]
+                    results = await asyncio.gather(*tasks)
+                    filtered_images = [url for url in results if url is not None]
+
+                    # Return the filtered list from the inner async function
+                    return filtered_images
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                # Capture the return value from the async execution
+                final_filtered_images = loop.run_until_complete(process_images())
+            finally:
+                loop.close()
         except Exception as e:
-            raise Exception(detail=f"Error during semantic search: {str(e)}")
+            logger.info("Image filtering error: %s", str(e))
+            return []
+
+        # Return the final list to the caller
+        return final_filtered_images
diff --git a/sdk/nexent/core/utils/favicon_extractor.py b/sdk/nexent/core/utils/favicon_extractor.py
index 31bbce145..f68cc6d16 100644
--- a/sdk/nexent/core/utils/favicon_extractor.py
+++ b/sdk/nexent/core/utils/favicon_extractor.py
@@ -1,38 +1,34 @@
 import requests
 from urllib.parse import urlparse
 
-def get_favicon_url(page_url):
-    """
-    从给定网页URL提取favicon图标地址
 
-    参数:
-        page_url (str): 要分析的网页URL
+def get_favicon_url(page_url: str) -> str:
+    """Build the default favicon URL for a given page URL.
 
-    返回:
-        str: favicon图标的完整URL，如果找不到则返回None
-    """
+    Args:
+        page_url: Target page URL.
 
-    # 解析输入URL
+    Returns:
+        Default favicon URL.
+    """
     parsed_url = urlparse(page_url)
     base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-    default_favicon = f"{base_url}/favicon.ico"
-    return default_favicon
+    return f"{base_url}/favicon.ico"
 
 
-def check_favicon_exists(url):
-    """
-    检查给定的favicon URL是否有效
+def check_favicon_exists(url: str) -> bool:
+    """Check whether a favicon URL exists.
 
-    参数:
-        url (str): 要检查的favicon URL
+    Args:
+        url: Favicon URL to check.
 
-    返回:
-        bool: 如果URL存在且返回200状态码则为True
+    Returns:
+        True if the favicon exists, otherwise False.
     """
     try:
         response = requests.head(url, timeout=3, allow_redirects=True)
         return response.status_code == 200
-    except:
+    except Exception:
         return False
 
 
@@ -40,17 +36,5 @@ def check_favicon_exists(url):
     url = "https://www.travelking.com.tw/zh-cn/tourguide/scenery100577.html"
     # url = "https://apps.apple.com/cn/app/wemeeting/id1480497919"
 
-    # 获取favicon URL
-    import time
-    start = time.time()
-    favicon_url = get_favicon_url(url)
-
-    if favicon_url:
-        print(f"找到favicon: {favicon_url}")
-    else:
-        print("未找到favicon")
-    end = time.time()
-    print(str(end - start))
-
-    print(check_favicon_exists(favicon_url))
-
+    # Manual smoke check for favicon existence.
+    _ = check_favicon_exists(get_favicon_url(url))
diff --git a/sdk/nexent/data_process/core.py b/sdk/nexent/data_process/core.py
index 554d4d47a..b58e6fe03 100644
--- a/sdk/nexent/data_process/core.py
+++ b/sdk/nexent/data_process/core.py
@@ -1,6 +1,8 @@
 import logging
 import os
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
+
+from .extract_image import UniversalImageExtractor
 
 from .base import FileProcessor
 from .openpyxl_processor import OpenPyxlProcessor
@@ -28,9 +30,12 @@ class DataProcessCore:
 
     # Supported chunking strategies
     CHUNKING_STRATEGIES = {"basic", "by_title", "none"}
+    
+    EXTRACT_IMAGE_EXTENSIONS = {".pdf", ".doc",
+                                ".docx", ".xls", ".xlsx", "ppt", "pptx"}
 
     # Supported processors
-    PROCESSORS = {"Unstructured", "OpenPyxl"}
+    PROCESSORS = {"Unstructured", "OpenPyxl", "UniversalImageExtractor"}
 
     def __init__(self):
         """
@@ -39,6 +44,7 @@ def __init__(self):
         self.processors: Dict[str, FileProcessor] = {
             "Unstructured": UnstructuredProcessor(),
             "OpenPyxl": OpenPyxlProcessor(),
+            "UniversalImageExtractor": UniversalImageExtractor(),
         }
         logger.debug("DataProcessCore initialization completed")
 
@@ -49,7 +55,7 @@ def file_process(
         chunking_strategy: str = "basic",
         processor: Optional[str] = None,
         **params,
-    ) -> List[Dict]:
+    ) -> Tuple[List[Dict], List[Dict]]:
         """
         Facade pattern that automatically detects file type and processes files
 
@@ -62,11 +68,13 @@ def file_process(
             **params: Additional processing parameters
 
         Returns:
-            List of processed chunks, each dictionary contains the following fields:
+            Tuple[List[Dict], List[Dict]]: (chunks, images_info)
+            chunks: List of processed chunks, each dictionary contains the following fields:
             - content: Text content
             - filename: Filename
             - metadata: Metadata (optional, includes chunk_index, source_type, etc.)
             - language: Language identifier (optional)
+            images_info: List of extracted image metadata dicts (may be empty)
 
         Raises:
             ValueError: Invalid parameters
@@ -76,18 +84,32 @@ def file_process(
         self._validate_parameters(chunking_strategy, processor)
 
         # Select appropriate processor
-        processor_name = processor or self._select_processor_by_filename(
-            filename)
+        if processor:
+            processor_name = processor
+            _, extractor = self._select_processor_by_filename(filename, params)
+        else:
+            processor_name, extractor = self._select_processor_by_filename(
+                filename, params)
+
         processor_instance = self.processors.get(processor_name)
+        extract_image_processor_instance = (
+            self.processors.get(extractor) if extractor else None
+        )
 
         if not processor_instance:
             raise ValueError(f"Unsupported processor: {processor_name}")
+        
+        if extract_image_processor_instance:
+            img_info = extract_image_processor_instance.process_file(
+                file_data, chunking_strategy, filename, **params)
+        else:
+            img_info = []
 
         # Process in-memory file
         logger.info(
             f"Processing in-memory file: {filename} with {processor_name} processor")
         try:
-            return processor_instance.process_file(file_data, chunking_strategy, filename=filename, **params)
+            return processor_instance.process_file(file_data, chunking_strategy, filename=filename, **params), img_info
         except Exception as e:
             logger.error(f"File processing failed for {filename}: {str(e)}")
             raise
@@ -109,14 +131,21 @@ def _validate_parameters(self, chunking_strategy: str, processor: Optional[str])
         logger.debug(
             f"Parameter validation passed: chunking_strategy={chunking_strategy}, processor={processor}")
 
-    def _select_processor_by_filename(self, filename: str) -> str:
+    def _select_processor_by_filename(
+        self, filename: str, params: Optional[Dict[str, Any]] = None
+    ) -> Tuple[str, Optional[str]]:
         """Selects a processor based on the file extension."""
         _, file_extension = os.path.splitext(filename)
         file_extension = file_extension.lower()
+
+        extract_image = None
+        model_type = params.get("model_type")
+        if model_type == "multi_embedding" and file_extension in self.EXTRACT_IMAGE_EXTENSIONS:
+            extract_image = "UniversalImageExtractor"
         if file_extension in self.EXCEL_EXTENSIONS:
-            return "OpenPyxl"
+            return "OpenPyxl", extract_image
         else:
-            return "Unstructured"
+            return "Unstructured", extract_image
 
     def get_supported_file_types(self) -> Dict[str, List[str]]:
         """
diff --git a/sdk/nexent/data_process/extract_image.py b/sdk/nexent/data_process/extract_image.py
new file mode 100644
index 000000000..38b452d6d
--- /dev/null
+++ b/sdk/nexent/data_process/extract_image.py
@@ -0,0 +1,438 @@
+import os
+import re
+import base64
+import hashlib
+import tempfile
+import subprocess
+from typing import List, Dict, Any, Optional
+import zipfile
+from xml.etree import ElementTree
+
+from pptx import Presentation
+
+from .base import FileProcessor
+
+from unstructured_inference.logger import logger
+from unstructured_inference.models import tables
+from unstructured.partition.auto import partition
+
+
+tables_agent = tables.tables_agent
+TABLE_TRANSFORMER_MODEL_PATH = ""
+
+def custom_load_table_model():
+    """Loads the Table agent."""
+
+    if getattr(tables_agent, "model", None) is None:
+        with tables_agent._lock:
+            if getattr(tables_agent, "model", None) is None:
+                logger.info("Loading the Table agent ...")
+                print("path234: ", TABLE_TRANSFORMER_MODEL_PATH)
+                tables_agent.initialize(TABLE_TRANSFORMER_MODEL_PATH)
+
+    return
+
+tables.load_agent = lambda: custom_load_table_model()
+
+
+class UniversalImageExtractor(FileProcessor):
+    """
+    Multi-format image extractor for PDF, PPT, Excel, and Word.
+    Uses LibreOffice for conversion when needed and reuses PDF extraction logic.
+    """
+
+    @staticmethod
+    def _hash(data: bytes) -> str:
+        # Use a modern hash for safe, collision-resistant de-duplication.
+        return hashlib.sha256(data).hexdigest()
+
+    @staticmethod
+    def _openxml_namespace_maps() -> Dict[str, str]:
+        return {
+            "xdr": "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",  # NOSONAR
+            "a": "http://schemas.openxmlformats.org/drawingml/2006/main",  # NOSONAR
+            "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",  # NOSONAR
+        }
+
+
+    def _write_temp_file(self, data: bytes, suffix: str) -> str:
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+        tmp.write(data)
+        tmp.close()
+        return tmp.name
+
+    @staticmethod
+    def detect_image_format(image_bytes: bytes) -> str:
+        if image_bytes.startswith(b"\x89PNG"):
+            return "png"
+        elif image_bytes.startswith(b"\xFF\xD8\xFF"):
+            return "jpg"
+        else:
+            return "png"
+
+
+    def _convert_file(self, input_path: str, target_format: str) -> str:
+    
+        """
+        Convert a file to the target format using LibreOffice.
+
+        Args:
+            input_path: Source file path.
+            target_format: Target format, e.g. "pdf", "pptx", "xlsx".
+
+        Returns:
+            Output file path.
+        """
+        out_dir = os.path.dirname(input_path)
+
+        cmd = [
+            "soffice",
+            "--headless",
+            "--invisible",  # Ensure fully headless conversion.
+            "--convert-to", f"{target_format}",
+            input_path,
+            "--outdir", out_dir
+        ]
+
+        try:
+            subprocess.run(
+                cmd,
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=60  # Prevent hanging conversions.
+            )
+
+            base_name = os.path.splitext(input_path)[0]
+            new_suffix = f".{target_format}"
+            output_path = base_name + new_suffix
+
+            if os.path.exists(output_path):
+                return output_path
+            else:
+                raise FileNotFoundError(
+                    f"Conversion failed: Output file {output_path} not found.")
+
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(
+                f"LibreOffice conversion failed for {input_path}: {e}")
+        except subprocess.TimeoutExpired:
+            raise RuntimeError(
+                f"LibreOffice conversion timed out for {input_path}")
+
+
+    def _extract_pdf(self, pdf_path: str, **params) -> List[Dict]:
+        table_transformer_model_path = params.get("table_transformer_model_path")
+        unstructured_default_model_initialize_params_json_path = params.get(
+            "unstructured_default_model_initialize_params_json_path"
+        )
+        if not table_transformer_model_path or not unstructured_default_model_initialize_params_json_path:
+            return []
+        global TABLE_TRANSFORMER_MODEL_PATH
+        TABLE_TRANSFORMER_MODEL_PATH = table_transformer_model_path
+
+        results = []
+        seen = set()
+
+        elements = partition(
+            filename=pdf_path,
+            strategy="hi_res",
+            extract_images_in_pdf=True,
+            extract_image_block_to_payload=True,
+        )
+
+        for el in elements:
+            b64 = getattr(el.metadata, "image_base64", None)
+            if not b64:
+                continue
+
+            img_bytes = base64.b64decode(b64)
+            h = self._hash(img_bytes)
+            if h in seen:
+                continue
+            seen.add(h)
+
+            coords = getattr(el.metadata, "coordinates", None)
+            coord_dict = None
+
+            if coords and hasattr(coords, 'points') and coords.points:
+                pts = coords.points  # tuple of (x,y)
+                xs = [p[0] for p in pts]
+                ys = [p[1] for p in pts]
+                coord_dict = {
+                    "x1": min(xs),
+                    "y1": min(ys),
+                    "x2": max(xs),
+                    "y2": max(ys),
+                }
+
+            page_num = getattr(el.metadata, "page_number", None)
+
+            results.append({
+                "position": {
+                    "page_number": page_num,
+                    "coordinates": coord_dict
+                },
+                "image_format": self.detect_image_format(img_bytes),
+                "image_bytes": img_bytes
+            })
+
+        return results
+
+
+    def _excel_sheet_files(self, z: zipfile.ZipFile) -> List[str]:
+        return [f for f in z.namelist() if f.startswith("xl/worksheets/sheet")]
+
+
+    def _excel_drawing_file(self, z: zipfile.ZipFile, sheet_file: str) -> Optional[str]:
+        sheet_xml = ElementTree.fromstring(z.read(sheet_file))
+        drawing = sheet_xml.find(
+            ".//{https://schemas.openxmlformats.org/spreadsheetml/2006/main}drawing")
+        if drawing is None:
+            drawing = sheet_xml.find(
+                ".//{http://schemas.openxmlformats.org/spreadsheetml/2006/main}drawing")
+        if drawing is None:
+            return None
+
+        rel_id = drawing.get(
+            "{https://schemas.openxmlformats.org/officeDocument/2006/relationships}id")
+        if rel_id is None:
+            rel_id = drawing.get(
+                "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id")
+        rel_path = sheet_file.replace("worksheets", "worksheets/_rels") + ".rels"
+        if rel_path not in z.namelist():
+            return None
+
+        rel_xml = ElementTree.fromstring(z.read(rel_path))
+        for rel in rel_xml:
+            if rel.get("Id") == rel_id:
+                return "xl/" + rel.get("Target").replace("../", "")
+
+        return None
+
+
+    def _excel_rel_map(self, z: zipfile.ZipFile, drawing_file: str) -> Optional[Dict[str, str]]:
+        rel_file = drawing_file.replace("drawings/", "drawings/_rels/") + ".rels"
+        if rel_file not in z.namelist():
+            return None
+
+        rel_root = ElementTree.fromstring(z.read(rel_file))
+        return {
+            rel.get("Id"): "xl/" + rel.get("Target").replace("../", "")
+            for rel in rel_root
+        }
+
+
+    def _excel_anchors(self, z: zipfile.ZipFile, drawing_file: str, ns: Dict[str, str]) -> List[Any]:
+        drawing_root = ElementTree.fromstring(z.read(drawing_file))
+        return drawing_root.findall(".//xdr:twoCellAnchor", ns) + \
+            drawing_root.findall(".//xdr:oneCellAnchor", ns)
+
+
+    def _excel_anchor_coords(self, anchor: Any, ns: Dict[str, str]) -> Optional[Dict[str, int]]:
+        from_node = anchor.find("xdr:from", ns)
+        if from_node is None:
+            return None
+
+        row1 = int(from_node.find("xdr:row", ns).text) + 1
+        col1 = int(from_node.find("xdr:col", ns).text) + 1
+
+        to_node = anchor.find("xdr:to", ns)
+        if to_node is not None:
+            row2 = int(to_node.find("xdr:row", ns).text) + 1
+            col2 = int(to_node.find("xdr:col", ns).text) + 1
+        else:
+            row2, col2 = row1, col1
+
+        return {"row1": row1, "col1": col1, "row2": row2, "col2": col2}
+
+
+    def _excel_anchor_embed_id(self, anchor: Any, ns: Dict[str, str]) -> Optional[str]:
+        blip = anchor.find(".//a:blip", ns)
+        if blip is None:
+            return None
+
+        embed_id = blip.get(
+            "{https://schemas.openxmlformats.org/officeDocument/2006/relationships}embed")
+        if embed_id is None:
+            embed_id = blip.get(
+                "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}embed")
+        return embed_id
+
+
+    def _extract_excel_anchors(
+        self,
+        z: zipfile.ZipFile,
+        anchors: List[Any],
+        rel_map: Dict[str, str],
+        sheet_name: str,
+        ns: Dict[str, str],
+        seen: set,
+    ) -> List[Dict[str, Any]]:
+        results = []
+        for anchor in anchors:
+            coords = self._excel_anchor_coords(anchor, ns)
+            if coords is None:
+                continue
+
+            embed_rel_id = self._excel_anchor_embed_id(anchor, ns)
+            if not embed_rel_id:
+                continue
+
+            target = rel_map.get(embed_rel_id)
+            if not target:
+                continue
+
+            img_bytes = z.read(target)
+            h = self._hash(img_bytes)
+            if h in seen:
+                continue
+            seen.add(h)
+
+            results.append({
+                "position": {
+                    "sheet_name": sheet_name,
+                    "coordinates": {
+                        "x1": coords["col1"],
+                        "x2": coords["col2"],
+                        "y1": coords["row1"],
+                        "y2": coords["row2"]
+                    }
+                },
+                "image_format": self.detect_image_format(img_bytes),
+                "image_bytes": img_bytes
+            })
+
+        return results
+
+
+    def _extract_excel_sheet(
+        self,
+        z: zipfile.ZipFile,
+        sheet_file: str,
+        ns: Dict[str, str],
+        seen: set,
+    ) -> List[Dict[str, Any]]:
+        drawing_file = self._excel_drawing_file(z, sheet_file)
+        if drawing_file is None:
+            return []
+
+        rel_map = self._excel_rel_map(z, drawing_file)
+        if not rel_map:
+            return []
+
+        anchors = self._excel_anchors(z, drawing_file, ns)
+        sheet_name = os.path.basename(sheet_file)
+
+        return self._extract_excel_anchors(z, anchors, rel_map, sheet_name, ns, seen)
+
+
+    def _extract_excel(self, xlsx_path):
+        results = []
+        seen = set()
+
+        with zipfile.ZipFile(xlsx_path) as z:
+            sheet_files = self._excel_sheet_files(z)
+
+            ns = self._openxml_namespace_maps()
+            for sheet_file in sheet_files:
+                results.extend(self._extract_excel_sheet(z, sheet_file, ns, seen))
+
+        return results
+
+
+    def _extract_pptx(self, pptx_path: str, **params) -> List[Dict]:
+        if Presentation is None:
+            raise RuntimeError("python-pptx is required to extract images from PPTX files.")
+        prs = Presentation(pptx_path)
+        results = []
+        seen = set()
+        emu_per_inch = params.get("emu_per_inch", 914400)
+        dpi = params.get("dpi", 96)
+        
+        def _emu_to_px(emu: int, emu_per_inch: int, dpi: int) -> int:
+            return int((emu / emu_per_inch) * dpi)
+        
+
+        slide_w = _emu_to_px(prs.slide_width, emu_per_inch, dpi)
+        slide_h = _emu_to_px(prs.slide_height, emu_per_inch, dpi)
+
+        for slide_index, slide in enumerate(prs.slides):
+            for shape in slide.shapes:
+                if not hasattr(shape, "image"):
+                    continue
+
+                img_bytes = shape.image.blob
+                h = self._hash(img_bytes)
+                if h in seen:
+                    continue
+                seen.add(h)
+
+                x = _emu_to_px(shape.left, emu_per_inch, dpi)
+                y = _emu_to_px(shape.top, emu_per_inch, dpi)
+                w = _emu_to_px(shape.width, emu_per_inch, dpi)
+                h_px = _emu_to_px(shape.height, emu_per_inch, dpi)
+
+                results.append({
+                    "position": {
+                        "page_number": slide_index + 1,
+                        "coordinates": {
+                            "x1": x,
+                            "y1": y,
+                            "x2": x + w,
+                            "y2": y + h_px,
+                            "slide_width": slide_w,
+                            "slide_height": slide_h,
+                        },
+                    },
+                    "image_format": self.detect_image_format(img_bytes),
+                    "image_bytes": img_bytes
+                })
+
+        return results
+
+
+    def process_file(self, file_bytes: bytes, chunking_strategy: str, filename: str, **params) -> List[Dict[str, Any]]:
+        suffix = os.path.splitext(filename)[1].lower()
+        temp_path = self._write_temp_file(file_bytes, suffix)
+        converted_path = None
+
+        try:
+            direct_extractors = {
+                ".xlsx": lambda: self._extract_excel(temp_path),
+                ".pptx": lambda: self._extract_pptx(temp_path, **params),
+                ".pdf": lambda: self._extract_pdf(temp_path, **params),
+            }
+            if suffix in direct_extractors:
+                return direct_extractors[suffix]()
+
+            conversions = {
+                ".xls": ("xlsx", lambda path: self._extract_excel(path)),
+                ".ppt": ("pptx", lambda path: self._extract_pptx(path, **params)),
+                ".docx": ("pdf", lambda path: self._extract_pdf(path, **params)),
+                ".doc": ("pdf", lambda path: self._extract_pdf(path, **params)),
+            }
+            if suffix in conversions:
+                target_format, extractor = conversions[suffix]
+                converted_path = self._convert_file(temp_path, target_format)
+                return extractor(converted_path)
+
+            return []
+
+        finally:
+            files_to_clean = [temp_path]
+            if converted_path and os.path.exists(converted_path):
+                files_to_clean.append(converted_path)
+
+            base = os.path.splitext(temp_path)[0]
+            for ext in [".docx", ".pptx", ".xlsx", ".pdf"]:
+                potential_file = base + ext
+                if potential_file != converted_path and potential_file != temp_path:
+                    files_to_clean.append(potential_file)
+
+            for f_path in files_to_clean:
+                if f_path and os.path.exists(f_path):
+                    try:
+                        os.remove(f_path)
+                    except Exception:
+                        pass
diff --git a/sdk/nexent/vector_database/elasticsearch_core.py b/sdk/nexent/vector_database/elasticsearch_core.py
index e87afdf5e..6d5953f0c 100644
--- a/sdk/nexent/vector_database/elasticsearch_core.py
+++ b/sdk/nexent/vector_database/elasticsearch_core.py
@@ -1,3 +1,4 @@
+import base64
 import json
 import logging
 import threading
@@ -400,19 +401,23 @@ def _small_batch_insert(
             # Preprocess documents
             processed_docs = self._preprocess_documents(
                 documents, content_field)
-
-            # Get embeddings
-            inputs = [doc[content_field] for doc in processed_docs]
-            embeddings = embedding_model.get_embeddings(inputs)
+            processed_docs, embeddings = self._prepare_small_batch_embeddings(
+                processed_docs, content_field, embedding_model
+            )
+            
 
             # Prepare bulk operations
-            operations = []
-            for doc, embedding in zip(processed_docs, embeddings):
-                operations.append({"index": {"_index": index_name}})
-                doc["embedding"] = embedding
-                if "embedding_model_name" not in doc:
-                    doc["embedding_model_name"] = embedding_model.embedding_model_name
-                operations.append(doc)
+            operations = self._build_bulk_operations(
+                index_name=index_name,
+                processed_docs=processed_docs,
+                embeddings=embeddings,
+                embedding_model=embedding_model,
+            )
+
+            indexed_count = len(processed_docs)
+            if indexed_count == 0:
+                logger.info("Small batch insert skipped: no documents to index.")
+                return 0
 
             # Execute bulk insertion, wait for refresh to complete
             response = self.client.bulk(
@@ -423,19 +428,70 @@ def _small_batch_insert(
 
             if progress_callback:
                 try:
-                    progress_callback(len(documents), len(documents))
+                    progress_callback(indexed_count, indexed_count)
                 except Exception as e:
                     logger.warning(
                         f"[VECTORIZE] Progress callback failed in small batch: {str(e)}")
 
             logger.info(
-                f"Small batch insert completed: {len(documents)} chunks indexed.")
-            return len(documents)
+                f"Small batch insert completed: {indexed_count} chunks indexed.")
+            return indexed_count
 
         except Exception as e:
             logger.error(f"Small batch insert failed: {e}")
             raise
 
+    def _prepare_small_batch_embeddings(
+        self,
+        processed_docs: List[Dict[str, Any]],
+        content_field: str,
+        embedding_model: BaseEmbedding,
+    ):
+        if embedding_model.model_type == "multimodal":
+            inputs = []
+            for doc in processed_docs:
+                if doc.get("process_source") == "UniversalImageExtractor":
+                    img_bytes = doc.pop("image_bytes", "")
+                    if len(img_bytes) > 0:
+                        image_base64_str = base64.b64encode(
+                            img_bytes).decode("utf-8")
+                        data = f"data:image/jpeg;base64,{image_base64_str}"
+                        inputs.append({"image": data})
+                else:
+                    inputs.append({"text": doc[content_field]})
+            embeddings = embedding_model.get_multimodal_embeddings(inputs)
+            return processed_docs, embeddings
+        else:
+            filtered_docs = [
+                doc
+                for doc in processed_docs
+                if doc.get("process_source") != "UniversalImageExtractor"
+            ]
+            inputs = [doc[content_field] for doc in filtered_docs]
+            embeddings = embedding_model.get_embeddings(inputs)
+            return filtered_docs, embeddings
+
+    @staticmethod
+    def _build_bulk_operations(
+        index_name: str,
+        processed_docs: List[Dict[str, Any]],
+        embeddings: List[Any],
+        embedding_model: BaseEmbedding,
+    ) -> List[Dict[str, Any]]:
+        operations = []
+        for doc, embedding in zip(processed_docs, embeddings):
+            operations.append({"index": {"_index": index_name}})
+            embedding_field = (
+                "multi_embedding"
+                if doc.get("process_source") == "UniversalImageExtractor"
+                else "embedding"
+            )
+            doc[embedding_field] = embedding
+            if "embedding_model_name" not in doc:
+                doc["embedding_model_name"] = embedding_model.embedding_model_name
+            operations.append(doc)
+        return operations
+
     def _large_batch_insert(
         self,
         index_name: str,
@@ -453,6 +509,11 @@ def _large_batch_insert(
         try:
             processed_docs = self._preprocess_documents(
                 documents, content_field)
+            if embedding_model.model_type != "multimodal":
+                processed_docs = [
+                    doc for doc in processed_docs
+                    if doc.get("process_source") != "UniversalImageExtractor"
+                ]
             total_indexed = 0
             total_vectorized = 0
             total_docs = len(processed_docs)
@@ -484,12 +545,30 @@ def _large_batch_insert(
 
                     for retry_attempt in range(max_retries):
                         try:
-                            inputs = [doc[content_field]
-                                      for doc in embedding_sub_batch]
-                            embeddings = embedding_model.get_embeddings(inputs)
-
-                            for doc, embedding in zip(embedding_sub_batch, embeddings):
-                                doc_embedding_pairs.append((doc, embedding))
+                            if embedding_model.model_type == "multimodal":
+                                inputs = []
+                                docs_for_embeddings = []
+                                for doc in embedding_sub_batch:
+                                    if doc.get("process_source") == "UniversalImageExtractor":
+                                        img_bytes = doc.pop("image_bytes", "")
+                                        if len(img_bytes) > 0:
+                                            image_base64_str = base64.b64encode(
+                                                img_bytes).decode('utf-8')
+                                            data = f"data:image/jpeg;base64,{image_base64_str}"
+                                            inputs.append({"image": data})
+                                            docs_for_embeddings.append(doc)
+                                    else:
+                                        inputs.append({"text": doc[content_field]})
+                                        docs_for_embeddings.append(doc)
+                                embeddings = embedding_model.get_multimodal_embeddings(inputs)
+                                for doc, embedding in zip(docs_for_embeddings, embeddings):
+                                    doc_embedding_pairs.append((doc, embedding))
+                            else:
+                                inputs = [doc[content_field]
+                                          for doc in embedding_sub_batch]
+                                embeddings = embedding_model.get_embeddings(inputs)
+                                for doc, embedding in zip(embedding_sub_batch, embeddings):
+                                    doc_embedding_pairs.append((doc, embedding))
 
                             success = True
                             total_vectorized += len(embedding_sub_batch)
@@ -528,7 +607,8 @@ def _large_batch_insert(
                 operations = []
                 for doc, embedding in doc_embedding_pairs:
                     operations.append({"index": {"_index": index_name}})
-                    doc["embedding"] = embedding
+                    doc["multi_embedding" if doc["process_source"]
+                        == "UniversalImageExtractor" else "embedding"] = embedding
                     if "embedding_model_name" not in doc:
                         doc["embedding_model_name"] = getattr(
                             embedding_model, "embedding_model_name", "unknown")
@@ -979,20 +1059,41 @@ def semantic_search(
         query_embedding = embedding_model.get_embeddings(query_text)[0]
 
         # Prepare the search query
-        search_query = {
-            "knn": {
-                "field": "embedding",
-                "query_vector": query_embedding,
-                "k": top_k,
-                "num_candidates": top_k * 2,
-            },
-            "size": top_k,
-            "_source": {"excludes": ["embedding"]},
-        }
-
-        # Execute the search across multiple indices
-        raw_results = self.exec_query(index_pattern, search_query)
-
+        if embedding_model.model_type == "multimodal":
+            search_text_query = {
+                "knn": {
+                    "field": "embedding",
+                    "query_vector": query_embedding,
+                    "k": top_k,
+                    "num_candidates": top_k * 2,
+                },
+                "size": top_k,
+                "_source": {"excludes": ["embedding"]},
+            }
+            search_image_query = {
+                "knn": {
+                        "field": "multi_embedding",
+                        "query_vector": query_embedding,
+                        "k": top_k,
+                        "num_candidates": top_k * 2,
+                    },
+                "size": top_k,
+                "_source": {"excludes": ["multi_embedding"]},
+            }
+            raw_results = self.exec_query(index_pattern, search_text_query) + self.exec_query(index_pattern, search_image_query)
+        else:
+            search_query = {
+                "knn": {
+                    "field": "embedding",
+                    "query_vector": query_embedding,
+                    "k": top_k,
+                    "num_candidates": top_k * 2,
+                },
+                "size": top_k,
+                "_source": {"excludes": ["embedding"]},
+            }
+            raw_results = self.exec_query(index_pattern, search_query)
+ 
         return raw_results
 
     def hybrid_search(
@@ -1137,6 +1238,13 @@ def hybrid_search(
                            for r in accurate_results]) if accurate_results else 1
         max_semantic = max([r.get("score", 0)
                            for r in semantic_results]) if semantic_results else 1
+        is_multimodal = embedding_model.model_type == "multimodal"
+        image_semantic_scores = [
+            r.get("score", 0)
+            for r in semantic_results
+            if r.get("document", {}).get("process_source") == "UniversalImageExtractor"
+        ]
+        max_semantic_image = max(image_semantic_scores) if image_semantic_scores else 1
 
         # Calculate combined scores and sort
         results = []
@@ -1148,7 +1256,10 @@ def hybrid_search(
 
                 # Normalize scores
                 normalized_accurate = accurate_score / max_accurate if max_accurate > 0 else 0
-                normalized_semantic = semantic_score / max_semantic if max_semantic > 0 else 0
+                if is_multimodal and result.get("document", {}).get("process_source") == "UniversalImageExtractor":
+                    normalized_semantic = semantic_score / max_semantic_image if max_semantic_image > 0 else 0
+                else:
+                    normalized_semantic = semantic_score / max_semantic if max_semantic > 0 else 0
 
                 # Calculate weighted combined score
                 combined_score = weight_accurate * normalized_accurate + \
@@ -1168,9 +1279,20 @@ def hybrid_search(
                     f"Warning: Error processing result for doc_id {doc_id}: {e}")
                 continue
 
-        # Sort by combined score and return top k results
+        # Sort by combined score and return results
         results.sort(key=lambda x: x["score"], reverse=True)
-        final_results = results[:top_k]
+        if is_multimodal:
+            text_results = [
+                r for r in results
+                if r.get("document", {}).get("process_source") != "UniversalImageExtractor"
+            ][:top_k]
+            image_results = [
+                r for r in semantic_results
+                if r.get("document", {}).get("process_source") == "UniversalImageExtractor"
+            ]
+            final_results = text_results + image_results
+        else:
+            final_results = results[:top_k]
 
         return final_results
 
diff --git a/test/backend/agents/test_create_agent_info.py b/test/backend/agents/test_create_agent_info.py
index 44ce32832..cfa88ca60 100644
--- a/test/backend/agents/test_create_agent_info.py
+++ b/test/backend/agents/test_create_agent_info.py
@@ -692,6 +692,39 @@ async def test_create_tool_config_list_with_knowledge_base_tool(self):
             last_call = mock_tool_config.call_args_list[-1]
             assert last_call[1]['class_name'] == "KnowledgeBaseSearchTool"
 
+    @pytest.mark.asyncio
+    async def test_create_tool_config_list_knowledge_base_multimodal(self):
+        """Ensure multimodal param is forwarded to embedding model selection."""
+        mock_tool_instance = MagicMock()
+        mock_tool_instance.class_name = "KnowledgeBaseSearchTool"
+
+        with patch('backend.agents.create_agent_info.discover_langchain_tools', return_value=[]), \
+                patch('backend.agents.create_agent_info.search_tools_for_sub_agent') as mock_search_tools, \
+                patch('backend.agents.create_agent_info.get_vector_db_core') as mock_get_vector_db_core, \
+                patch('backend.agents.create_agent_info.get_embedding_model') as mock_embedding, \
+                patch('backend.agents.create_agent_info.ToolConfig') as mock_tool_config:
+            mock_tool_config.return_value = mock_tool_instance
+
+            mock_search_tools.return_value = [
+                {
+                    "class_name": "KnowledgeBaseSearchTool",
+                    "name": "knowledge_search",
+                    "description": "Knowledge search tool",
+                    "inputs": "string",
+                    "output_type": "string",
+                    "params": [{"name": "multimodal", "default": True}],
+                    "source": "local",
+                    "usage": None
+                }
+            ]
+            mock_get_vector_db_core.return_value = "mock_elastic_core"
+            mock_embedding.return_value = "mock_embedding_model"
+
+            result = await create_tool_config_list("agent_1", "tenant_1", "user_1")
+
+            assert len(result) == 1
+            mock_embedding.assert_called_once_with(tenant_id="tenant_1", is_multimodal=True)
+
     @pytest.mark.asyncio
     async def test_create_tool_config_list_with_analyze_image_tool(self):
         """Ensure AnalyzeImageTool receives VLM model metadata."""
@@ -1443,36 +1476,34 @@ async def test_create_agent_config_with_memory(self):
 
     @pytest.mark.asyncio
     async def test_create_agent_config_memory_disabled_no_search(self):
-        with (
-            patch(
-                "backend.agents.create_agent_info.search_agent_info_by_agent_id"
-            ) as mock_search_agent,
+        with patch(
+            "backend.agents.create_agent_info.search_agent_info_by_agent_id"
+        ) as mock_search_agent, \
             patch(
                 "backend.agents.create_agent_info.query_sub_agents_id_list"
-            ) as mock_query_sub,
+            ) as mock_query_sub, \
             patch(
                 "backend.agents.create_agent_info.create_tool_config_list"
-            ) as mock_create_tools,
+            ) as mock_create_tools, \
             patch(
                 "backend.agents.create_agent_info.get_agent_prompt_template"
-            ) as mock_get_template,
+            ) as mock_get_template, \
             patch(
                 "backend.agents.create_agent_info.tenant_config_manager"
-            ) as mock_tenant_config,
+            ) as mock_tenant_config, \
             patch(
                 "backend.agents.create_agent_info.build_memory_context"
-            ) as mock_build_memory,
+            ) as mock_build_memory, \
             patch(
                 "backend.agents.create_agent_info.get_model_by_model_id"
-            ) as mock_get_model_by_id,
+            ) as mock_get_model_by_id, \
             patch(
                 "backend.agents.create_agent_info.search_memory_in_levels",
                 new_callable=AsyncMock,
-            ) as mock_search_memory,
+            ) as mock_search_memory, \
             patch(
                 "backend.agents.create_agent_info.prepare_prompt_templates"
-            ) as mock_prepare_templates,
-        ):
+            ) as mock_prepare_templates:
             mock_search_agent.return_value = {
                 "name": "test_agent",
                 "description": "test description",
diff --git a/test/backend/app/test_model_managment_app.py b/test/backend/app/test_model_managment_app.py
index 20f3210e2..39a8aec76 100644
--- a/test/backend/app/test_model_managment_app.py
+++ b/test/backend/app/test_model_managment_app.py
@@ -406,7 +406,7 @@ async def test_check_model_health_success(client, auth_header, user_credentials,
     
     response = client.post(
         "/model/healthcheck",
-        params={"display_name": "Test Model"},
+        params={"display_name": "Test Model", "modelType": "embedding"},
         headers=auth_header
     )
     
@@ -414,7 +414,7 @@ async def test_check_model_health_success(client, auth_header, user_credentials,
     data = response.json()
     assert data["message"] == "Successfully checked model connectivity"
     assert data["data"]["connectivity"] is True
-    mock_check.assert_called_once_with("Test Model", user_credentials[1])
+    mock_check.assert_called_once_with("Test Model", user_credentials[1], "embedding")
 
 
 @pytest.mark.asyncio
@@ -429,7 +429,7 @@ async def test_check_model_health_lookup_error(client, auth_header, user_credent
     
     response = client.post(
         "/model/healthcheck",
-        params={"display_name": "X"},
+        params={"display_name": "X", "modelType": "embedding"},
         headers=auth_header
     )
     assert response.status_code == HTTPStatus.NOT_FOUND
@@ -1406,4 +1406,4 @@ async def mock_create_provider_models(*args, **kwargs):
 
 
 if __name__ == "__main__":
-    pytest.main([__file__])
\ No newline at end of file
+    pytest.main([__file__])
diff --git a/test/backend/app/test_vectordatabase_app.py b/test/backend/app/test_vectordatabase_app.py
index 993a93cda..11c622e70 100644
--- a/test/backend/app/test_vectordatabase_app.py
+++ b/test/backend/app/test_vectordatabase_app.py
@@ -6,6 +6,8 @@
 import os
 import sys
 import pytest
+import types
+import importlib.machinery
 from unittest.mock import patch, MagicMock, ANY, AsyncMock
 from fastapi.testclient import TestClient
 from fastapi import FastAPI
@@ -20,9 +22,11 @@
 
 # Environment variables are now configured in conftest.py
 
-boto3_mock = MagicMock()
+boto3_module = types.ModuleType("boto3")
+boto3_module.__spec__ = importlib.machinery.ModuleSpec("boto3", loader=None)
+boto3_module.client = MagicMock()
 minio_client_mock = MagicMock()
-sys.modules['boto3'] = boto3_mock
+sys.modules["boto3"] = boto3_module
 
 # Patch storage factory and MinIO config validation to avoid errors during initialization
 # These patches must be started before any imports that use MinioClient
@@ -237,6 +241,25 @@ async def test_create_new_index_with_partial_group_permissions(vdb_core_mock, au
         assert called_kwargs["group_ids"] is None
 
 
+@pytest.mark.asyncio
+async def test_create_new_index_with_multimodal_flag(vdb_core_mock, auth_data):
+    with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
+            patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.ElasticSearchService.create_knowledge_base") as mock_create:
+
+        mock_create.return_value = {"status": "success", "index_name": auth_data["index_name"]}
+
+        response = client.post(
+            f"/indices/{auth_data['index_name']}",
+            json={"is_multimodal": True},
+            headers=auth_data["auth_header"],
+        )
+
+        assert response.status_code == 200
+        called_kwargs = mock_create.call_args[1]
+        assert called_kwargs["is_multimodal"] is True
+
+
 @pytest.mark.asyncio
 async def test_create_new_index_error(vdb_core_mock, auth_data):
     """
@@ -634,7 +657,7 @@ async def test_create_index_documents_success(vdb_core_mock, auth_data):
     # Setup mocks
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
-            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value=None), \
+            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value={"is_multimodal": "N"}), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.index_documents") as mock_index, \
             patch("backend.apps.vectordatabase_app.get_embedding_model", return_value=MagicMock()):
 
@@ -656,9 +679,35 @@ async def test_create_index_documents_success(vdb_core_mock, auth_data):
             f"/indices/{index_name}/documents", json=documents, headers=auth_data["auth_header"])
 
         # Verify
+    assert response.status_code == 200
+    assert response.json() == expected_response.dict()
+    mock_index.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_create_index_documents_uses_multimodal_embedding(vdb_core_mock, auth_data):
+    with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
+            patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
+            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value={"is_multimodal": "Y"}), \
+            patch("backend.apps.vectordatabase_app.get_embedding_model") as mock_get_embedding, \
+            patch("backend.apps.vectordatabase_app.ElasticSearchService.index_documents") as mock_index:
+
+        mock_get_embedding.return_value = MagicMock()
+        mock_index.return_value = IndexingResponse(
+            success=True,
+            message="Documents indexed successfully",
+            total_indexed=1,
+            total_submitted=1
+        )
+
+        response = client.post(
+            f"/indices/{auth_data['index_name']}/documents",
+            json=[{"id": 1, "text": "test doc"}],
+            headers=auth_data["auth_header"],
+        )
+
         assert response.status_code == 200
-        assert response.json() == expected_response.dict()
-        mock_index.assert_called_once()
+        mock_get_embedding.assert_called_once_with(auth_data["tenant_id"], True)
 
 
 @pytest.mark.asyncio
@@ -670,7 +719,7 @@ async def test_create_index_documents_exception(vdb_core_mock, auth_data):
     # Setup mocks
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
-            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value=None), \
+            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value={"is_multimodal": "N"}), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.index_documents") as mock_index, \
             patch("backend.apps.vectordatabase_app.get_embedding_model", return_value=MagicMock()):
 
@@ -736,7 +785,7 @@ async def test_create_index_documents_embedding_model_exception(vdb_core_mock, a
     # Setup mocks
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
-            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value=None), \
+            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value={"is_multimodal": "N"}), \
             patch("backend.apps.vectordatabase_app.get_embedding_model") as mock_get_embedding:
 
         index_name = "test_index"
@@ -770,7 +819,7 @@ async def test_create_index_documents_validation_exception(vdb_core_mock, auth_d
     # Setup mocks
     with patch("backend.apps.vectordatabase_app.get_vector_db_core", return_value=vdb_core_mock), \
             patch("backend.apps.vectordatabase_app.get_current_user_id", return_value=(auth_data["user_id"], auth_data["tenant_id"])), \
-            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value=None), \
+            patch("backend.apps.vectordatabase_app.get_knowledge_record", return_value={"is_multimodal": "N"}), \
             patch("backend.apps.vectordatabase_app.ElasticSearchService.index_documents") as mock_index, \
             patch("backend.apps.vectordatabase_app.get_embedding_model", return_value=MagicMock()):
 
@@ -1356,7 +1405,8 @@ async def test_update_index_success(auth_data):
         payload = {
             "knowledge_name": "Updated Knowledge Base",
             "ingroup_permission": "EDIT",
-            "group_ids": [1, 2, 3]
+            "group_ids": [1, 2, 3],
+            "is_multimodal": True
         }
         response = client.patch(
             f"/indices/{auth_data['index_name']}",
@@ -1373,6 +1423,7 @@ async def test_update_index_success(auth_data):
             knowledge_name="Updated Knowledge Base",
             ingroup_permission="EDIT",
             group_ids=[1, 2, 3],
+            is_multimodal=True,
             tenant_id=auth_data["tenant_id"],
             user_id=auth_data["user_id"]
         )
@@ -1407,6 +1458,7 @@ async def test_update_index_partial_update(auth_data):
             knowledge_name="Only Name Updated",
             ingroup_permission=None,
             group_ids=None,
+            is_multimodal=None,
             tenant_id=auth_data["tenant_id"],
             user_id=auth_data["user_id"]
         )
diff --git a/test/backend/data_process/test_ray_actors.py b/test/backend/data_process/test_ray_actors.py
index 10e8d599e..07fe6676d 100644
--- a/test/backend/data_process/test_ray_actors.py
+++ b/test/backend/data_process/test_ray_actors.py
@@ -53,6 +53,27 @@ def expire(self, key, seconds):
         self.expirations[key] = seconds
 
 
+def make_temp_file(tmp_path, name: str, content: bytes = b"file-bytes") -> str:
+    path = tmp_path / name
+    path.write_bytes(content)
+    return str(path)
+
+
+def stub_consts(monkeypatch):
+    fake_consts_pkg = types.ModuleType("consts")
+    fake_consts_const = types.ModuleType("consts.const")
+    fake_consts_const.RAY_ACTOR_NUM_CPUS = 1
+    fake_consts_const.REDIS_BACKEND_URL = ""
+    # New defaults required by ray_actors import
+    fake_consts_const.DEFAULT_EXPECTED_CHUNK_SIZE = 1024
+    fake_consts_const.DEFAULT_MAXIMUM_CHUNK_SIZE = 1536
+    fake_consts_const.TABLE_TRANSFORMER_MODEL_PATH = "/models/table"
+    fake_consts_const.UNSTRUCTURED_DEFAULT_MODEL_INITIALIZE_PARAMS_JSON_PATH = "/models/unstructured.json"
+    monkeypatch.setitem(sys.modules, "consts", fake_consts_pkg)
+    monkeypatch.setitem(sys.modules, "consts.const", fake_consts_const)
+    return fake_consts_const
+
+
 @pytest.fixture(autouse=True)
 def stub_ray_before_import(monkeypatch):
     # Ensure that when module under test imports ray, it gets our stub
@@ -72,6 +93,11 @@ def import_module(monkeypatch):
     fake_attachment_db_mod = types.ModuleType("database.attachment_db")
     fake_attachment_db_mod.get_file_stream = lambda source: io.BytesIO(b"file-bytes")
     fake_attachment_db_mod.get_file_size_from_minio = lambda path_or_url: 0
+    fake_attachment_db_mod.upload_fileobj = lambda file_obj, file_name, prefix=None, bucket=None: {
+        "success": True,
+        "object_name": f"{prefix}/{file_name}" if prefix else file_name,
+    }
+    fake_attachment_db_mod.build_s3_url = lambda object_name: f"s3://bucket/{object_name}"
     monkeypatch.setitem(sys.modules, "database.attachment_db", fake_attachment_db_mod)
     # Ensure parent package 'database' exists and link submodule for proper resolution
     if "database" not in sys.modules:
@@ -133,15 +159,7 @@ class _Redis:
     monkeypatch.setitem(sys.modules, "backend.data_process.tasks", fake_dp_tasks)
 
     # Stub consts.const needed by ray_actors imports
-    fake_consts_pkg = types.ModuleType("consts")
-    fake_consts_const = types.ModuleType("consts.const")
-    fake_consts_const.RAY_ACTOR_NUM_CPUS = 1
-    fake_consts_const.REDIS_BACKEND_URL = ""
-    # New defaults required by ray_actors import
-    fake_consts_const.DEFAULT_EXPECTED_CHUNK_SIZE = 1024
-    fake_consts_const.DEFAULT_MAXIMUM_CHUNK_SIZE = 1536
-    monkeypatch.setitem(sys.modules, "consts", fake_consts_pkg)
-    monkeypatch.setitem(sys.modules, "consts.const", fake_consts_const)
+    stub_consts(monkeypatch)
 
     # Ensure model_management_db is stubbed to avoid importing real DB layer
     if "database.model_management_db" not in sys.modules:
@@ -177,12 +195,13 @@ class _Redis:
     return ray_actors
 
 
-def test_process_file_happy_path(monkeypatch):
+def test_process_file_happy_path(monkeypatch, tmp_path):
     ray_actors = import_module(monkeypatch)
     actor = ray_actors.DataProcessorRayActor()
 
+    source_path = make_temp_file(tmp_path, "a.txt")
     chunks = actor.process_file(
-        source="/tmp/a.txt",
+        source=source_path,
         chunking_strategy="basic",
         destination="local",
         task_id="tid-1",
@@ -194,7 +213,7 @@ def test_process_file_happy_path(monkeypatch):
     assert chunks[0]["content"] == "hello world"
 
 
-def test_process_file_applies_chunk_sizes_from_model(monkeypatch):
+def test_process_file_applies_chunk_sizes_from_model(monkeypatch, tmp_path):
     ray_actors = import_module(monkeypatch)
 
     # Recorder core to capture params
@@ -222,8 +241,9 @@ def file_process(self, file_data, filename, chunking_strategy, **params):
     )
 
     actor = ray_actors.DataProcessorRayActor()
+    source_path = make_temp_file(tmp_path, "a.txt")
     actor.process_file(
-        source="/tmp/a.txt",
+        source=source_path,
         chunking_strategy="basic",
         destination="local",
         model_id=9,
@@ -233,9 +253,13 @@ def file_process(self, file_data, filename, chunking_strategy, **params):
     assert RecorderCore.captured_params is not None
     assert RecorderCore.captured_params.get("new_after_n_chars") == 2000
     assert RecorderCore.captured_params.get("max_characters") == 3000
+    assert RecorderCore.captured_params.get("table_transformer_model_path") == "/models/table"
+    assert RecorderCore.captured_params.get(
+        "unstructured_default_model_initialize_params_json_path"
+    ) == "/models/unstructured.json"
 
 
-def test_process_file_no_model_omits_chunk_params(monkeypatch):
+def test_process_file_no_model_omits_chunk_params(monkeypatch, tmp_path):
     ray_actors = import_module(monkeypatch)
 
     class RecorderCore:
@@ -257,8 +281,9 @@ def file_process(self, file_data, filename, chunking_strategy, **params):
     )
 
     actor = ray_actors.DataProcessorRayActor()
+    source_path = make_temp_file(tmp_path, "b.txt")
     actor.process_file(
-        source="/tmp/b.txt",
+        source=source_path,
         chunking_strategy="basic",
         destination="local",
         model_id=10,
@@ -268,9 +293,13 @@ def file_process(self, file_data, filename, chunking_strategy, **params):
     assert RecorderCore.captured_params is not None
     assert "new_after_n_chars" not in RecorderCore.captured_params
     assert "max_characters" not in RecorderCore.captured_params
+    assert RecorderCore.captured_params.get("table_transformer_model_path") == "/models/table"
+    assert RecorderCore.captured_params.get(
+        "unstructured_default_model_initialize_params_json_path"
+    ) == "/models/unstructured.json"
 
 
-def test_process_file_model_lookup_exception_uses_defaults(monkeypatch):
+def test_process_file_model_lookup_exception_uses_defaults(monkeypatch, tmp_path):
     ray_actors = import_module(monkeypatch)
 
     class RecorderCore:
@@ -293,8 +322,9 @@ def file_process(self, file_data, filename, chunking_strategy, **params):
     )
 
     actor = ray_actors.DataProcessorRayActor()
+    source_path = make_temp_file(tmp_path, "c.txt")
     actor.process_file(
-        source="/tmp/c.txt",
+        source=source_path,
         chunking_strategy="basic",
         destination="local",
         model_id=11,
@@ -304,6 +334,10 @@ def file_process(self, file_data, filename, chunking_strategy, **params):
     assert RecorderCore.captured_params is not None
     assert "new_after_n_chars" not in RecorderCore.captured_params
     assert "max_characters" not in RecorderCore.captured_params
+    assert RecorderCore.captured_params.get("table_transformer_model_path") == "/models/table"
+    assert RecorderCore.captured_params.get(
+        "unstructured_default_model_initialize_params_json_path"
+    ) == "/models/unstructured.json"
 
 
 def test_process_file_get_stream_none_raises(monkeypatch):
@@ -311,6 +345,8 @@ def test_process_file_get_stream_none_raises(monkeypatch):
     fake_attachment_db_mod = types.ModuleType("database.attachment_db")
     fake_attachment_db_mod.get_file_stream = lambda source: None
     fake_attachment_db_mod.get_file_size_from_minio = lambda path_or_url: 0
+    fake_attachment_db_mod.upload_fileobj = lambda *a, **k: {"success": True, "object_name": "o"}
+    fake_attachment_db_mod.build_s3_url = lambda object_name: f"s3://bucket/{object_name}"
     monkeypatch.setitem(sys.modules, "database.attachment_db", fake_attachment_db_mod)
     # Ensure parent 'database' exists and link attachment_db
     if "database" not in sys.modules:
@@ -371,15 +407,7 @@ class _Redis:
     fake_dp_tasks.process_sync = lambda *a, **k: None
     monkeypatch.setitem(sys.modules, "backend.data_process.tasks", fake_dp_tasks)
     # Stub consts.const again for reload path
-    fake_consts_pkg = types.ModuleType("consts")
-    fake_consts_const = types.ModuleType("consts.const")
-    fake_consts_const.RAY_ACTOR_NUM_CPUS = 1
-    fake_consts_const.REDIS_BACKEND_URL = ""
-    # Provide defaults required by backend.data_process.ray_actors import
-    fake_consts_const.DEFAULT_EXPECTED_CHUNK_SIZE = 1024
-    fake_consts_const.DEFAULT_MAXIMUM_CHUNK_SIZE = 1536
-    monkeypatch.setitem(sys.modules, "consts", fake_consts_pkg)
-    monkeypatch.setitem(sys.modules, "consts.const", fake_consts_const)
+    stub_consts(monkeypatch)
 
     # Stub database.model_management_db and link to parent to avoid real DB import
     if "database.model_management_db" not in sys.modules:
@@ -410,7 +438,7 @@ class _Redis:
         actor.process_file("url://missing", "basic", destination="minio")
 
 
-def test_process_file_core_returns_none_list_variants(monkeypatch):
+def test_process_file_core_returns_none_list_variants(monkeypatch, tmp_path):
     class CoreNone(FakeDataProcessCore):
         def file_process(self, *a, **k):
             return None
@@ -434,6 +462,8 @@ def file_process(self, *a, **k):
         fake_attachment_db_mod = types.ModuleType("database.attachment_db")
         fake_attachment_db_mod.get_file_stream = lambda source: io.BytesIO(b"file-bytes")
         fake_attachment_db_mod.get_file_size_from_minio = lambda path_or_url: 0
+        fake_attachment_db_mod.upload_fileobj = lambda *a, **k: {"success": True, "object_name": "o"}
+        fake_attachment_db_mod.build_s3_url = lambda object_name: f"s3://bucket/{object_name}"
         monkeypatch.setitem(sys.modules, "database.attachment_db", fake_attachment_db_mod)
         # Also stub celery.result.AsyncResult and redis module
         fake_celery = types.ModuleType("celery")
@@ -480,15 +510,7 @@ class _Redis:
         fake_dp_tasks.process_sync = lambda *a, **k: None
         monkeypatch.setitem(sys.modules, "backend.data_process.tasks", fake_dp_tasks)
         # Stub consts.const for ray_actors imports
-        fake_consts_pkg = types.ModuleType("consts")
-        fake_consts_const = types.ModuleType("consts.const")
-        fake_consts_const.RAY_ACTOR_NUM_CPUS = 1
-        fake_consts_const.REDIS_BACKEND_URL = ""
-        # Provide defaults required by backend.data_process.ray_actors import
-        fake_consts_const.DEFAULT_EXPECTED_CHUNK_SIZE = 1024
-        fake_consts_const.DEFAULT_MAXIMUM_CHUNK_SIZE = 1536
-        monkeypatch.setitem(sys.modules, "consts", fake_consts_pkg)
-        monkeypatch.setitem(sys.modules, "consts.const", fake_consts_const)
+        stub_consts(monkeypatch)
 
         # Ensure model_management_db is stubbed to avoid importing real DB layer
         if "database.model_management_db" not in sys.modules:
@@ -503,7 +525,8 @@ class _Redis:
         import backend.data_process.ray_actors as ray_actors
         reload(ray_actors)
         actor = ray_actors.DataProcessorRayActor()
-        chunks = actor.process_file("/tmp/a.txt", "basic", destination="local")
+        source_path = make_temp_file(tmp_path, f"a_{core_cls.__name__}.txt")
+        chunks = actor.process_file(source_path, "basic", destination="local")
         assert chunks == []
 
 
@@ -547,3 +570,58 @@ def test_store_chunks_in_redis_no_url_returns_false(monkeypatch):
     actor = ray_actors.DataProcessorRayActor()
     assert actor.store_chunks_in_redis("k", [{"content": "x"}]) is False
 
+
+def test_process_file_appends_image_chunks(monkeypatch, tmp_path):
+    ray_actors = import_module(monkeypatch)
+
+    class CoreWithImages:
+        def file_process(self, *a, **k):
+            return (
+                [{"content": "text", "metadata": {}}],
+                [
+                    {
+                        "image_bytes": b"img",
+                        "image_format": "png",
+                        "position": {"page_number": 1},
+                    }
+                ],
+            )
+
+    monkeypatch.setattr(ray_actors, "DataProcessCore", CoreWithImages)
+    monkeypatch.setattr(
+        ray_actors,
+        "upload_fileobj",
+        lambda file_obj, file_name, prefix=None: {"object_name": f"{prefix}/{file_name}"},
+    )
+    monkeypatch.setattr(
+        ray_actors,
+        "build_s3_url",
+        lambda object_name: f"s3://bucket/{object_name}",
+    )
+
+    actor = ray_actors.DataProcessorRayActor()
+    source_path = make_temp_file(tmp_path, "a.pdf", content=b"%PDF-1.4")
+    chunks = actor.process_file(source_path, "basic", destination="local")
+
+    assert len(chunks) == 2
+    assert chunks[1]["metadata"]["process_source"] == "UniversalImageExtractor"
+    assert "image_url" in chunks[1]["metadata"]
+
+
+def test_process_file_skips_invalid_image_entries(monkeypatch, tmp_path):
+    ray_actors = import_module(monkeypatch)
+
+    class CoreWithBadImages:
+        def file_process(self, *a, **k):
+            return (
+                [{"content": "text", "metadata": {}}],
+                [{"not": "dict"}, {"image_format": "png"}],
+            )
+
+    monkeypatch.setattr(ray_actors, "DataProcessCore", CoreWithBadImages)
+    actor = ray_actors.DataProcessorRayActor()
+    source_path = make_temp_file(tmp_path, "a.pdf", content=b"%PDF-1.4")
+    chunks = actor.process_file(source_path, "basic", destination="local")
+
+    assert chunks == [{"content": "text", "metadata": {}}]
+
diff --git a/test/backend/database/test_attachment_db.py b/test/backend/database/test_attachment_db.py
index 7abdd3a07..771b90b27 100644
--- a/test/backend/database/test_attachment_db.py
+++ b/test/backend/database/test_attachment_db.py
@@ -17,6 +17,8 @@
 # Mock consts module
 consts_mock = MagicMock()
 consts_mock.const = MagicMock()
+# Ensure constants are real strings to avoid startswith TypeError
+consts_mock.const.S3_URL_PREFIX = "s3://"
 # Environment variables are now configured in conftest.py
 
 sys.modules['consts'] = consts_mock
@@ -71,7 +73,9 @@
         list_files,
         delete_file,
         get_file_stream,
-        get_content_type
+        get_content_type,
+        build_s3_url,
+        _normalize_object_and_bucket
     )
 
 
@@ -574,3 +578,47 @@ def test_copy_file_failure(self):
             assert result['success'] is False
             assert 'Copy failed' in result['error']
 
+
+class TestS3UrlHelpers:
+    """Test cases for S3 URL helpers and normalization."""
+
+    def test_normalize_object_and_bucket_s3_url(self):
+        object_name, bucket = _normalize_object_and_bucket("s3://my-bucket/path/to/file.txt")
+        assert object_name == "path/to/file.txt"
+        assert bucket == "my-bucket"
+
+    def test_normalize_object_and_bucket_slash_path(self):
+        object_name, bucket = _normalize_object_and_bucket("/my-bucket/path/to/file.txt")
+        assert object_name == "path/to/file.txt"
+        assert bucket == "my-bucket"
+
+    def test_build_s3_url_passthrough(self):
+        assert build_s3_url("s3://bucket/key") == "s3://bucket/key"
+
+    def test_build_s3_url_from_path(self):
+        assert build_s3_url("/bucket/key") == "s3://bucket/key"
+
+    def test_build_s3_url_from_object(self):
+        assert build_s3_url("attachments/file.txt") == "s3://test-bucket/attachments/file.txt"
+
+
+def test_get_file_stream_normalizes_s3_url():
+    minio_client_mock.get_file_stream.reset_mock()
+    mock_stream = BytesIO(b"test data")
+    minio_client_mock.get_file_stream.return_value = (True, mock_stream)
+
+    result = get_file_stream("s3://test-bucket/attachments/test.txt")
+
+    assert isinstance(result, BytesIO)
+    minio_client_mock.get_file_stream.assert_called_once_with("attachments/test.txt", "test-bucket")
+
+
+def test_delete_file_normalizes_s3_url():
+    minio_client_mock.delete_file.reset_mock()
+    minio_client_mock.delete_file.return_value = (True, "Deleted successfully")
+
+    result = delete_file("s3://test-bucket/attachments/test.txt")
+
+    assert result["success"] is True
+    minio_client_mock.delete_file.assert_called_once_with("attachments/test.txt", "test-bucket")
+
diff --git a/test/backend/database/test_knowledge_db.py b/test/backend/database/test_knowledge_db.py
index 496e04b19..219372994 100644
--- a/test/backend/database/test_knowledge_db.py
+++ b/test/backend/database/test_knowledge_db.py
@@ -6,6 +6,7 @@
 import sys
 import os
 import types
+import importlib.machinery
 from datetime import datetime
 from unittest.mock import MagicMock, patch, call
 import pytest
@@ -18,8 +19,10 @@
     sys.path.insert(0, backend_dir)
 
 # Patch boto3 and other dependencies before importing anything from backend
-boto3_mock = MagicMock()
-sys.modules['boto3'] = boto3_mock
+boto3_module = types.ModuleType("boto3")
+boto3_module.__spec__ = importlib.machinery.ModuleSpec("boto3", loader=None)
+boto3_module.client = MagicMock()
+sys.modules["boto3"] = boto3_module
 
 # Apply critical patches before importing any modules
 # This prevents real AWS/MinIO/Elasticsearch calls during import
@@ -107,8 +110,10 @@
 
 # Provide a stub for the `boto3` module so that it can be imported safely even
 # if the testing environment does not have it available.
-boto3_mock = MagicMock()
-sys.modules['boto3'] = boto3_mock
+boto3_module = types.ModuleType("boto3")
+boto3_module.__spec__ = importlib.machinery.ModuleSpec("boto3", loader=None)
+boto3_module.client = MagicMock()
+sys.modules["boto3"] = boto3_module
 
 # Mock sqlalchemy module
 sqlalchemy_mock = MagicMock()
@@ -193,27 +198,32 @@ def mock_session():
     return mock_session, mock_query
 
 
-def test_create_knowledge_record_success(monkeypatch, mock_session):
-    """Test successful creation of knowledge record"""
-    session, _ = mock_session
-
-    # Create mock knowledge record
-    mock_record = MockKnowledgeRecord(knowledge_name="test_knowledge")
-    mock_record.knowledge_id = 123
-    mock_record.index_name = "test_knowledge"
-
-    # Mock database session context
+def setup_mock_db_session(monkeypatch, session):
     mock_ctx = MagicMock()
     mock_ctx.__enter__.return_value = session
-    # Mock the context manager to call rollback on exception, like the real get_db_session does
 
     def mock_exit(exc_type, exc_val, exc_tb):
         if exc_type is not None:
             session.rollback()
         return None  # Don't suppress the exception
+
     mock_ctx.__exit__.side_effect = mock_exit
     monkeypatch.setattr(
         "backend.database.knowledge_db.get_db_session", lambda: mock_ctx)
+    return mock_ctx
+
+
+def test_create_knowledge_record_success(monkeypatch, mock_session):
+    """Test successful creation of knowledge record"""
+    session, _ = mock_session
+
+    # Create mock knowledge record
+    mock_record = MockKnowledgeRecord(knowledge_name="test_knowledge")
+    mock_record.knowledge_id = 123
+    mock_record.index_name = "test_knowledge"
+
+    # Mock database session context
+    setup_mock_db_session(monkeypatch, session)
 
     # Prepare test data
     test_query = {
@@ -294,22 +304,37 @@ def mock_exit(exc_type, exc_val, exc_tb):
     session.commit.assert_called_once()
 
 
+def test_create_knowledge_record_sets_multimodal_flag(monkeypatch, mock_session):
+    session, _ = mock_session
+    mock_record = MockKnowledgeRecord(knowledge_name="test_knowledge")
+    mock_record.knowledge_id = 123
+    mock_record.index_name = "test_knowledge"
+
+    setup_mock_db_session(monkeypatch, session)
+
+    test_query = {
+        "index_name": "test_knowledge",
+        "knowledge_describe": "Test knowledge description",
+        "user_id": "test_user",
+        "tenant_id": "test_tenant",
+        "embedding_model_name": "test_model",
+        "knowledge_name": "test_knowledge",
+        "is_multimodal": True,
+    }
+
+    with patch('backend.database.knowledge_db.KnowledgeRecord', return_value=mock_record) as mock_constructor:
+        _ = create_knowledge_record(test_query)
+
+    call_kwargs = mock_constructor.call_args[1]
+    assert call_kwargs["is_multimodal"] == "Y"
+
+
 def test_create_knowledge_record_exception(monkeypatch, mock_session):
     """Test exception during knowledge record creation"""
     session, _ = mock_session
     session.add.side_effect = MockSQLAlchemyError("Database error")
 
-    mock_ctx = MagicMock()
-    mock_ctx.__enter__.return_value = session
-    # Mock the context manager to call rollback on exception, like the real get_db_session does
-
-    def mock_exit(exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            session.rollback()
-        return None  # Don't suppress the exception
-    mock_ctx.__exit__.side_effect = mock_exit
-    monkeypatch.setattr(
-        "backend.database.knowledge_db.get_db_session", lambda: mock_ctx)
+    setup_mock_db_session(monkeypatch, session)
 
     test_query = {
         "index_name": "test_knowledge",
@@ -334,17 +359,7 @@ def test_create_knowledge_record_generates_index_name(monkeypatch, mock_session)
     mock_record = MockKnowledgeRecord(knowledge_name="kb1")
     mock_record.knowledge_id = 7
 
-    mock_ctx = MagicMock()
-    mock_ctx.__enter__.return_value = session
-    # Mock the context manager to call rollback on exception, like the real get_db_session does
-
-    def mock_exit(exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            session.rollback()
-        return None  # Don't suppress the exception
-    mock_ctx.__exit__.side_effect = mock_exit
-    monkeypatch.setattr(
-        "backend.database.knowledge_db.get_db_session", lambda: mock_ctx)
+    setup_mock_db_session(monkeypatch, session)
 
     # Deterministic index name
     monkeypatch.setattr(
@@ -459,6 +474,38 @@ def mock_exit(exc_type, exc_val, exc_tb):
     session.commit.assert_called_once()
 
 
+def test_update_knowledge_record_sets_multimodal(monkeypatch, mock_session):
+    session, query = mock_session
+    mock_record = MockKnowledgeRecord()
+    mock_record.is_multimodal = "N"
+
+    mock_filter = MagicMock()
+    mock_filter.first.return_value = mock_record
+    query.filter.return_value = mock_filter
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+
+    def mock_exit(exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            session.rollback()
+        return None
+
+    mock_ctx.__exit__.side_effect = mock_exit
+    monkeypatch.setattr(
+        "backend.database.knowledge_db.get_db_session", lambda: mock_ctx)
+
+    test_query = {
+        "index_name": "test_knowledge",
+        "is_multimodal": True,
+    }
+
+    result = update_knowledge_record(test_query)
+
+    assert result is True
+    assert mock_record.is_multimodal == "Y"
+
+
 def test_update_knowledge_record_partial_update(monkeypatch, mock_session):
     """Test partial update - only updating name and permission"""
     session, query = mock_session
@@ -1486,6 +1533,32 @@ def mock_exit(exc_type, exc_val, exc_tb):
     assert result == {}
 
 
+def test_get_knowledge_record_filters_multimodal(monkeypatch, mock_session):
+    session, query = mock_session
+    mock_filter = MagicMock()
+    mock_filter.first.return_value = MockKnowledgeRecord()
+    query.filter.return_value = mock_filter
+
+    mock_ctx = MagicMock()
+    mock_ctx.__enter__.return_value = session
+
+    def mock_exit(exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            session.rollback()
+        return None
+
+    mock_ctx.__exit__.side_effect = mock_exit
+    monkeypatch.setattr(
+        "backend.database.knowledge_db.get_db_session", lambda: mock_ctx)
+
+    monkeypatch.setattr(
+        "backend.database.knowledge_db.as_dict", lambda x: {"knowledge_id": 1})
+
+    _ = get_knowledge_record({"index_name": "test_index", "is_multimodal": "Y"})
+
+    assert query.filter.called
+
+
 def test_get_knowledge_info_by_knowledge_ids_empty_list(monkeypatch, mock_session):
     """Test get_knowledge_info_by_knowledge_ids with empty list"""
     session, query = mock_session
diff --git a/test/backend/database/test_model_managment_db.py b/test/backend/database/test_model_managment_db.py
index 34160fc3b..f2e37915b 100644
--- a/test/backend/database/test_model_managment_db.py
+++ b/test/backend/database/test_model_managment_db.py
@@ -346,6 +346,34 @@ def test_get_model_id_by_display_name(monkeypatch):
     assert result == 7
 
 
+def test_get_model_by_display_name_with_model_type_filter(monkeypatch):
+    captured_filters = {}
+
+    def fake_get_model_records(filters, tenant_id):
+        captured_filters.update(filters)
+        return [{"model_id": 10, "display_name": "Embed"}]
+
+    monkeypatch.setattr(model_mgmt_db, "get_model_records", fake_get_model_records)
+
+    result = model_mgmt_db.get_model_by_display_name("Embed", "tenant10", model_type="multiEmbedding")
+
+    assert result["display_name"] == "Embed"
+    assert captured_filters["display_name"] == "Embed"
+    assert captured_filters["model_type"] == "multi_embedding"
+
+
+def test_get_model_id_by_display_name_with_model_type(monkeypatch):
+    def fake_get_model_by_display_name(display_name, tenant_id, model_type=None):
+        assert model_type == "embedding"
+        return {"model_id": 11}
+
+    monkeypatch.setattr(model_mgmt_db, "get_model_by_display_name", fake_get_model_by_display_name)
+
+    result = model_mgmt_db.get_model_id_by_display_name("Embed", "tenant11", model_type="embedding")
+
+    assert result == 11
+
+
 def test_get_model_by_model_id_with_tenant_id(monkeypatch):
     """Test get_model_by_model_id with tenant_id filter (covers lines 222->226)"""
     mock_model = SimpleNamespace(
diff --git a/test/backend/services/test_config_sync_service.py b/test/backend/services/test_config_sync_service.py
index 0748a71b7..83fcd2152 100644
--- a/test/backend/services/test_config_sync_service.py
+++ b/test/backend/services/test_config_sync_service.py
@@ -1,11 +1,15 @@
 import sys
+import types
+import importlib.machinery
 from unittest.mock import patch, MagicMock, call
 
 import pytest
 
 # Patch boto3 and other dependencies before importing anything from backend
-boto3_mock = MagicMock()
-sys.modules['boto3'] = boto3_mock
+boto3_module = types.ModuleType("boto3")
+boto3_module.__spec__ = importlib.machinery.ModuleSpec("boto3", loader=None)
+boto3_module.client = MagicMock()
+sys.modules["boto3"] = boto3_module
 
 # Apply critical patches before importing any modules
 # This prevents real AWS/MinIO/Elasticsearch calls during import
@@ -458,6 +462,30 @@ async def test_save_config_impl_success_embedding_model(self, service_mocks):
         service_mocks['logger'].info.assert_called_once_with(
             "Configuration saved successfully")
 
+    @pytest.mark.asyncio
+    async def test_save_config_impl_passes_model_type_to_lookup(self, service_mocks):
+        config = MagicMock()
+        config.model_dump.return_value = {
+            "app": {},
+            "models": {
+                "embedding": {
+                    "modelName": "text-embedding-ada-002",
+                    "displayName": "Ada Embeddings",
+                    "apiConfig": {"apiKey": "k", "baseUrl": "https://api"}
+                }
+            }
+        }
+
+        service_mocks['tenant_config_manager'].load_config.return_value = {}
+        service_mocks['get_env_key'].side_effect = lambda key: key.upper()
+        service_mocks['safe_value'].side_effect = lambda value: str(value) if value is not None else ""
+
+        await save_config_impl(config, "tenant-id", "user-id")
+
+        service_mocks['get_model_id'].assert_called_once_with(
+            "Ada Embeddings", "tenant-id", model_type="embedding"
+        )
+
     @pytest.mark.asyncio
     async def test_save_config_impl_model_config(self, service_mocks):
         """Test saving configuration with empty model config"""
diff --git a/test/backend/services/test_data_process_service.py b/test/backend/services/test_data_process_service.py
index c52e496bb..f306c54a5 100644
--- a/test/backend/services/test_data_process_service.py
+++ b/test/backend/services/test_data_process_service.py
@@ -796,6 +796,20 @@ async def async_test_load_image_from_url_failure(self, mock_session):
         # Verify result
         self.assertIsNone(result)
 
+    @pytest.mark.asyncio
+    async def async_test_load_image_from_s3(self):
+        """Ensure s3:// URLs are routed through MinIO and decoded."""
+        img = Image.new('RGB', (64, 64), color='green')
+        img_byte_arr = io.BytesIO()
+        img.save(img_byte_arr, format='JPEG')
+        img_byte_arr.seek(0)
+
+        with patch('backend.services.data_process_service.get_file_stream', return_value=img_byte_arr):
+            result = await self.service.load_image("s3://bucket/path/to/image.jpg")
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result.size, (64, 64))
+
     @patch('aiohttp.ClientSession')
     @pytest.mark.asyncio
     async def async_test_load_image_from_base64(self, mock_session):
@@ -1257,6 +1271,7 @@ def test_load_image(self):
         """
         asyncio.run(self.async_test_load_image_from_url())
         asyncio.run(self.async_test_load_image_from_url_failure())
+        asyncio.run(self.async_test_load_image_from_s3())
         asyncio.run(self.async_test_load_image_from_base64())
         asyncio.run(self.async_test_load_image_from_file())
         asyncio.run(self.async_test_load_image_rgba_to_rgb_conversion())
@@ -1652,14 +1667,18 @@ async def async_test_create_batch_tasks_impl_success(self, mock_process, mock_fo
                 'source_type': 'url',
                 'chunking_strategy': 'semantic',
                 'index_name': 'test_index_1',
-                'original_filename': 'doc1.pdf'
+                'original_filename': 'doc1.pdf',
+                'embedding_model_id': None,
+                'tenant_id': None
             },
             {
                 'source': 'http://example.com/doc2.pdf',
                 'source_type': 'url',
                 'chunking_strategy': 'fixed',
                 'index_name': 'test_index_2',
-                'original_filename': 'doc2.pdf'
+                'original_filename': 'doc2.pdf',
+                'embedding_model_id': None,
+                'tenant_id': None
             }
         ]
         actual_process_calls = [kwargs for args,
diff --git a/test/backend/services/test_datamate_service.py b/test/backend/services/test_datamate_service.py
index ca63c42a6..d815e1952 100644
--- a/test/backend/services/test_datamate_service.py
+++ b/test/backend/services/test_datamate_service.py
@@ -300,6 +300,7 @@ async def test_create_datamate_knowledge_records_success(monkeypatch):
     assert first_call_args["tenant_id"] == "tenant1"
     assert first_call_args["user_id"] == "user1"
     assert first_call_args["embedding_model_name"] == "embedding1"
+    assert first_call_args["is_multimodal"] is False
 
 
 @pytest.mark.asyncio
diff --git a/test/backend/services/test_model_health_service.py b/test/backend/services/test_model_health_service.py
index 5a81fa8b5..44045ca53 100644
--- a/test/backend/services/test_model_health_service.py
+++ b/test/backend/services/test_model_health_service.py
@@ -24,6 +24,14 @@ def __getattr__(cls, key):
 sys.modules['utils.auth_utils'] = MockModule()
 sys.modules['utils.config_utils'] = MockModule()
 sys.modules['utils.model_name_utils'] = MockModule()
+sys.modules['consts'] = MockModule()
+consts_const_module = MockModule()
+consts_const_module.LOCALHOST_IP = "127.0.0.1"
+consts_const_module.LOCALHOST_NAME = "localhost"
+consts_const_module.DOCKER_INTERNAL_HOST = "host.docker.internal"
+sys.modules['consts.const'] = consts_const_module
+sys.modules['consts.model'] = MockModule()
+sys.modules['consts.provider'] = MockModule()
 
 # Mock nexent packages and modules with proper hierarchy
 sys.modules['nexent'] = MockModule()
@@ -65,70 +73,13 @@ def __init__(self, code, message="", data=None):
 
 
 # Now import the module under test
-try:
-    from backend.services.model_health_service import (
-        _perform_connectivity_check,
-        check_model_connectivity,
-        verify_model_config_connectivity,
-        _embedding_dimension_check,
-        embedding_dimension_check,
-    )
-except ImportError:
-    from backend.services.model_health_service import (
-        _perform_connectivity_check,
-        check_model_connectivity,
-        verify_model_config_connectivity,
-        _embedding_dimension_check,
-        embedding_dimension_check,
-    )
-
-# Mock imported functions/classes after import
-
-# Apply patch before importing the module to be tested
-with mock.patch.dict('sys.modules', {
-    'nexent': mock.MagicMock(),
-    'nexent.core': mock.MagicMock(),
-    'nexent.core.agents': mock.MagicMock(),
-    'nexent.core.agents.agent_model': mock.MagicMock(),
-    'nexent.core.models': mock.MagicMock(),
-    'nexent.core.models.embedding_model': mock.MagicMock(),
-    'database': mock.MagicMock(),
-    'database.client': mock.MagicMock(),
-    'database.model_management_db': mock.MagicMock(),
-    'utils': mock.MagicMock(),
-    'utils.auth_utils': mock.MagicMock(),
-    'utils.config_utils': mock.MagicMock(),
-    'utils.model_name_utils': mock.MagicMock(),
-    'services': mock.MagicMock(),
-    'services.voice_service': mock.MagicMock(),
-    'consts.model': mock.MagicMock(),
-    'consts.const': mock.MagicMock(),
-    'consts.provider': mock.MagicMock()
-}):
-    # Define the mocked enums and classes
-    mock_model_enum = mock.MagicMock()
-    mock_model_enum.AVAILABLE = "available"
-    mock_model_enum.UNAVAILABLE = "unavailable"
-    mock_model_enum.DETECTING = "detecting"
-    mock.patch('consts.model.ModelConnectStatusEnum', mock_model_enum)
-
-    # Now import the module under test (wrapped with fallback for optional symbols)
-    try:
-        from backend.services.model_health_service import (
-            _perform_connectivity_check,
-            check_model_connectivity,
-            verify_model_config_connectivity,
-            _embedding_dimension_check,
-            embedding_dimension_check,
-        )
-    except ImportError:
-        from backend.services.model_health_service import (
-            _perform_connectivity_check,
-            check_model_connectivity,
-            verify_model_config_connectivity,
-            _embedding_dimension_check,
-            embedding_dimension_check,
-        )
+from backend.services.model_health_service import (
+    _perform_connectivity_check,
+    check_model_connectivity,
+    verify_model_config_connectivity,
+    _embedding_dimension_check,
+    embedding_dimension_check,
+)
 
 
 @pytest.mark.asyncio
@@ -432,12 +383,12 @@ async def test_check_model_connectivity_success():
         mock_connectivity_check.return_value = True
 
         # Execute
-        response = await check_model_connectivity("GPT-4", "tenant456")
+        response = await check_model_connectivity("GPT-4", "tenant456", "embedding")
 
         # Assert
         assert response["connectivity"] is True
 
-        mock_get_model.assert_called_once_with("GPT-4", tenant_id="tenant456")
+        mock_get_model.assert_called_once_with("GPT-4", tenant_id="tenant456", model_type="embedding")
         # Detecting first, then available
         mock_update_model.assert_any_call(
             "model123", {"connect_status": "detecting"})
@@ -457,7 +408,7 @@ async def test_check_model_connectivity_model_not_found():
 
         # Execute & Assert
         with pytest.raises(LookupError):
-            await check_model_connectivity("NonexistentModel", "tenant456")
+            await check_model_connectivity("NonexistentModel", "tenant456", "embedding")
 
 
 @pytest.mark.asyncio
diff --git a/test/backend/services/test_tool_configuration_service.py b/test/backend/services/test_tool_configuration_service.py
index 24990bab9..6fcdf57bb 100644
--- a/test/backend/services/test_tool_configuration_service.py
+++ b/test/backend/services/test_tool_configuration_service.py
@@ -5,12 +5,32 @@
 import sys
 import types
 import unittest
+from pathlib import Path
 from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
 import pytest
 
 # Environment variables are now configured in conftest.py
 
+REPO_ROOT = Path(__file__).resolve().parents[3]
+SDK_ROOT = REPO_ROOT / "sdk"
+if str(SDK_ROOT) not in sys.path:
+    sys.path.insert(0, str(SDK_ROOT))
+
+try:
+    import nexent.memory.memory_service as real_memory_service
+    memory_pkg = sys.modules.get("nexent.memory")
+except Exception:
+    real_memory_service = None
+    memory_pkg = types.ModuleType("nexent.memory")
+    memory_pkg.__path__ = []
+    memory_service_stub = types.ModuleType("nexent.memory.memory_service")
+    async def _clear_memory_stub(*_args, **_kwargs):
+        await asyncio.sleep(0)
+        return None
+    memory_service_stub.clear_memory = _clear_memory_stub
+    sys.modules["nexent.memory.memory_service"] = memory_service_stub
+
 boto3_mock = MagicMock()
 minio_client_mock = MagicMock()
 sys.modules['boto3'] = boto3_mock
@@ -118,6 +138,11 @@ def _create_package_mock(name):
 sys.modules['nexent'] = nexent_mock
 sys.modules['nexent.core'] = _create_package_mock('nexent.core')
 sys.modules['nexent.core.agents'] = _create_package_mock('nexent.core.agents')
+if memory_pkg is not None:
+    sys.modules["nexent.memory"] = memory_pkg
+    nexent_mock.memory = memory_pkg
+    if real_memory_service is not None:
+        sys.modules["nexent.memory.memory_service"] = real_memory_service
 sys.modules['nexent.core.agents.agent_model'] = MagicMock()
 sys.modules['nexent.core.models'] = _create_package_mock('nexent.core.models')
 
@@ -2370,7 +2395,46 @@ def test_validate_local_tool_knowledge_base_search_success(self, mock_get_vector
         mock_tool_instance.forward.assert_called_once_with(query="test query")
 
         # Verify service calls
-        mock_get_embedding_model.assert_called_once_with(tenant_id="tenant1")
+        mock_get_embedding_model.assert_called_once_with(tenant_id="tenant1", is_multimodal=False)
+
+    @patch('backend.services.tool_configuration_service._get_tool_class_by_name')
+    @patch('backend.services.tool_configuration_service.inspect.signature')
+    @patch('backend.services.tool_configuration_service.get_embedding_model')
+    @patch('backend.services.tool_configuration_service.get_vector_db_core')
+    def test_validate_local_tool_knowledge_base_search_multimodal(self, mock_get_vector_db_core, mock_get_embedding_model,
+                                                                  mock_signature, mock_get_class):
+        mock_tool_class = Mock()
+        mock_tool_instance = Mock()
+        mock_tool_instance.forward.return_value = "knowledge base search result"
+        mock_tool_class.return_value = mock_tool_instance
+        mock_get_class.return_value = mock_tool_class
+
+        mock_sig = Mock()
+        mock_index_names_param = Mock()
+        mock_index_names_param.default = ["default_index"]
+        mock_sig.parameters = {
+            'self': Mock(),
+            'index_names': mock_index_names_param,
+            'vdb_core': Mock(),
+            'embedding_model': Mock()
+        }
+        mock_signature.return_value = mock_sig
+
+        mock_get_embedding_model.return_value = "mock_embedding_model"
+        mock_get_vector_db_core.return_value = Mock()
+
+        from backend.services.tool_configuration_service import _validate_local_tool
+
+        result = _validate_local_tool(
+            "knowledge_base_search",
+            {"query": "test query"},
+            {"param": "config", "multimodal": True},
+            "tenant1",
+            "user1"
+        )
+
+        assert result == "knowledge base search result"
+        mock_get_embedding_model.assert_called_once_with(tenant_id="tenant1", is_multimodal=True)
 
     @patch('backend.services.tool_configuration_service._get_tool_class_by_name')
     @patch('backend.services.tool_configuration_service.get_embedding_model')
diff --git a/test/backend/services/test_vectordatabase_service.py b/test/backend/services/test_vectordatabase_service.py
index 89df709e5..b583565bb 100644
--- a/test/backend/services/test_vectordatabase_service.py
+++ b/test/backend/services/test_vectordatabase_service.py
@@ -1,8 +1,10 @@
 import asyncio
+import io
 import sys
 import os
 import time
 import unittest
+from pathlib import Path
 from unittest.mock import MagicMock, ANY, AsyncMock, call
 # Mock MinioClient before importing modules that use it
 from unittest.mock import patch
@@ -13,6 +15,25 @@
 
 # Environment variables are now configured in conftest.py
 
+REPO_ROOT = Path(__file__).resolve().parents[3]
+SDK_ROOT = REPO_ROOT / "sdk"
+if str(SDK_ROOT) not in sys.path:
+    sys.path.insert(0, str(SDK_ROOT))
+
+try:
+    import nexent.memory.memory_service as real_memory_service
+    memory_pkg = sys.modules.get("nexent.memory")
+except Exception:
+    real_memory_service = None
+    memory_pkg = ModuleType("nexent.memory")
+    memory_pkg.__path__ = []
+    memory_service_stub = ModuleType("nexent.memory.memory_service")
+    async def _clear_memory_stub(*_args, **_kwargs):
+        await asyncio.sleep(0)
+        return None
+    memory_service_stub.clear_memory = _clear_memory_stub
+    sys.modules["nexent.memory.memory_service"] = memory_service_stub
+
 # Mock boto3 before importing the module under test
 boto3_mock = MagicMock()
 sys.modules['boto3'] = boto3_mock
@@ -62,6 +83,11 @@ class _VectorDatabaseCore:
 vector_db_base_module.VectorDatabaseCore = _VectorDatabaseCore
 sys.modules['nexent.vector_database.base'] = vector_db_base_module
 sys.modules['nexent.vector_database.elasticsearch_core'] = MagicMock()
+if memory_pkg is not None:
+    sys.modules["nexent.memory"] = memory_pkg
+    nexent_mock.memory = memory_pkg
+    if real_memory_service is not None:
+        sys.modules["nexent.memory.memory_service"] = real_memory_service
 sys.modules['nexent.vector_database.datamate_core'] = MagicMock()
 # Mock nexent.storage module and its submodules before any imports
 sys.modules['nexent.storage'] = _create_package_mock('nexent.storage')
@@ -175,6 +201,7 @@ def setUp(self):
         self.mock_embedding = MagicMock()
         self.mock_embedding.embedding_dim = 768
         self.mock_embedding.model = "test-model"
+        self.mock_embedding.model_type = "text"
         self.mock_get_embedding.return_value = self.mock_embedding
 
         # Patch get_rerank_model for all tests
@@ -216,6 +243,7 @@ def test_create_index_success(self, mock_create_knowledge):
 
         # Execute
         result = ElasticSearchService.create_index(
+            embedding_model=self.mock_embedding,
             index_name="test_index",
             embedding_dim=768,
             vdb_core=self.mock_vdb_core,
@@ -230,6 +258,12 @@ def test_create_index_success(self, mock_create_knowledge):
         self.mock_vdb_core.create_index.assert_called_once_with(
             "test_index", embedding_dim=768)
         mock_create_knowledge.assert_called_once()
+        call_kwargs = mock_create_knowledge.call_args[0][0]
+        self.assertNotIn("embedding_model_name", call_kwargs)
+        self.assertEqual(call_kwargs["index_name"], "test_index")
+        self.assertEqual(call_kwargs["created_by"], "test_user")
+        self.assertEqual(call_kwargs["tenant_id"], "test_tenant")
+        self.assertFalse(call_kwargs["is_multimodal"])
 
     @patch('backend.services.vectordatabase_service.create_knowledge_record')
     def test_create_index_already_exists(self, mock_create_knowledge):
@@ -247,6 +281,7 @@ def test_create_index_already_exists(self, mock_create_knowledge):
         # Execute and Assert
         with self.assertRaises(Exception) as context:
             ElasticSearchService.create_index(
+                embedding_model=self.mock_embedding,
                 index_name="test_index",
                 embedding_dim=768,
                 vdb_core=self.mock_vdb_core,
@@ -281,6 +316,8 @@ def test_create_knowledge_base_generates_index(self, mock_create_knowledge):
         self.mock_vdb_core.create_index.assert_called_once_with(
             "7-uuid", embedding_dim=256
         )
+        call_kwargs = mock_create_knowledge.call_args[0][0]
+        self.assertFalse(call_kwargs["is_multimodal"])
 
     @patch('backend.services.vectordatabase_service.create_knowledge_record')
     def test_create_knowledge_base_with_group_permissions(self, mock_create_knowledge):
@@ -314,6 +351,7 @@ def test_create_knowledge_base_with_group_permissions(self, mock_create_knowledg
         call_kwargs = mock_create_knowledge.call_args[0][0]
         self.assertEqual(call_kwargs["ingroup_permission"], "EDIT")
         self.assertEqual(call_kwargs["group_ids"], [1, 2, 3])
+        self.assertFalse(call_kwargs["is_multimodal"])
 
     @patch('backend.services.vectordatabase_service.create_knowledge_record')
     def test_create_knowledge_base_with_partial_group_permissions(self, mock_create_knowledge):
@@ -346,6 +384,7 @@ def test_create_knowledge_base_with_partial_group_permissions(self, mock_create_
         self.assertEqual(call_kwargs["ingroup_permission"], "READ_ONLY")
         # group_ids should not be in the call if not provided
         self.assertNotIn("group_ids", call_kwargs)
+        self.assertFalse(call_kwargs["is_multimodal"])
 
     @patch('backend.services.vectordatabase_service.create_knowledge_record')
     def test_create_knowledge_base_with_empty_group_ids(self, mock_create_knowledge):
@@ -377,6 +416,29 @@ def test_create_knowledge_base_with_empty_group_ids(self, mock_create_knowledge)
         call_kwargs = mock_create_knowledge.call_args[0][0]
         self.assertEqual(call_kwargs["ingroup_permission"], "PRIVATE")
         self.assertEqual(call_kwargs["group_ids"], [])
+        self.assertFalse(call_kwargs["is_multimodal"])
+
+    @patch('backend.services.vectordatabase_service.create_knowledge_record')
+    def test_create_knowledge_base_with_multimodal(self, mock_create_knowledge):
+        self.mock_vdb_core.create_index.return_value = True
+        mock_create_knowledge.return_value = {
+            "knowledge_id": 10,
+            "index_name": "10-uuid",
+            "knowledge_name": "kb-mm",
+        }
+
+        result = ElasticSearchService.create_knowledge_base(
+            knowledge_name="kb-mm",
+            embedding_dim=256,
+            vdb_core=self.mock_vdb_core,
+            user_id="user-1",
+            tenant_id="tenant-1",
+            is_multimodal=True,
+        )
+
+        self.assertEqual(result["status"], "success")
+        call_kwargs = mock_create_knowledge.call_args[0][0]
+        self.assertTrue(call_kwargs["is_multimodal"])
 
     @patch('backend.services.vectordatabase_service.create_knowledge_record')
     def test_create_index_failure(self, mock_create_knowledge):
@@ -395,6 +457,7 @@ def test_create_index_failure(self, mock_create_knowledge):
         # Execute and Assert
         with self.assertRaises(Exception) as context:
             ElasticSearchService.create_index(
+                embedding_model=self.mock_embedding,
                 index_name="test_index",
                 embedding_dim=768,
                 vdb_core=self.mock_vdb_core,
@@ -449,7 +512,9 @@ def test_create_knowledge_base_with_embedding_model_name(self, mock_get_embeddin
         self.assertEqual(result["knowledge_id"], 10)
 
         # Verify get_embedding_model was called with the model name
-        mock_get_embedding.assert_called_once_with("tenant-1", "text-embedding-3-small")
+        mock_get_embedding.assert_called_once_with(
+            "tenant-1", is_multimodal=False, model_name="text-embedding-3-small"
+        )
 
         # Verify knowledge record was created with the embedding model name
         mock_create_knowledge.assert_called_once()
@@ -496,7 +561,7 @@ def test_create_knowledge_base_without_embedding_model_name_uses_default(self, m
         self.assertEqual(result["status"], "success")
 
         # Verify get_embedding_model was called with None (no specific model)
-        mock_get_embedding.assert_called_once_with("tenant-1", None)
+        mock_get_embedding.assert_called_once_with("tenant-1", is_multimodal=False)
 
         # Verify knowledge record was created with the model's display name
         mock_create_knowledge.assert_called_once()
@@ -1554,6 +1619,7 @@ def test_vectorize_documents_success(self):
         self.mock_vdb_core.vectorize_documents.return_value = 2
         mock_embedding_model = MagicMock()
         mock_embedding_model.model = "test-model"
+        mock_embedding_model.model_type = "text"
         with patch('backend.services.vectordatabase_service.get_knowledge_record') as mock_get_record, \
                 patch('backend.services.vectordatabase_service.tenant_config_manager') as mock_tenant_cfg:
             mock_get_record.return_value = {"tenant_id": "tenant-1"}
@@ -1600,6 +1666,69 @@ def test_vectorize_documents_success(self):
             self.assertEqual(kwargs.get("embedding_batch_size"), 5)
             self.assertTrue(callable(kwargs.get("progress_callback")))
 
+    def test_index_documents_uses_multi_embedding_config_key(self):
+        self.mock_vdb_core.check_index_exists.return_value = True
+        self.mock_vdb_core.vectorize_documents.return_value = 1
+
+        mock_embedding_model = MagicMock()
+        mock_embedding_model.model = "test-model"
+        mock_embedding_model.model_type = "multimodal"
+
+        with patch('backend.services.vectordatabase_service.get_knowledge_record') as mock_get_record, \
+                patch('backend.services.vectordatabase_service.tenant_config_manager') as mock_tenant_cfg:
+            mock_get_record.return_value = {"tenant_id": "tenant-1"}
+            mock_tenant_cfg.get_model_config.return_value = {"chunk_batch": 6}
+
+            result = ElasticSearchService.index_documents(
+                index_name="test_index",
+                data=[{"path_or_url": "p1", "content": "c1", "metadata": {}}],
+                vdb_core=self.mock_vdb_core,
+                embedding_model=mock_embedding_model
+            )
+
+            self.assertTrue(result["success"])
+            mock_tenant_cfg.get_model_config.assert_called_once_with(
+                key="MULTI_EMBEDDING_ID", tenant_id="tenant-1"
+            )
+
+    def test_index_documents_fetches_image_bytes(self):
+        self.mock_vdb_core.check_index_exists.return_value = True
+        self.mock_vdb_core.vectorize_documents.return_value = 1
+        mock_embedding_model = MagicMock()
+        mock_embedding_model.model = "test-model"
+        mock_embedding_model.model_type = "text"
+
+        with patch('backend.services.vectordatabase_service.get_knowledge_record') as mock_get_record, \
+                patch('backend.services.vectordatabase_service.tenant_config_manager') as mock_tenant_cfg, \
+                patch('backend.services.vectordatabase_service.get_file_stream') as mock_get_stream:
+            mock_get_record.return_value = {"tenant_id": "tenant-1"}
+            mock_tenant_cfg.get_model_config.return_value = {"chunk_batch": 5}
+            mock_get_stream.return_value = io.BytesIO(b"img-bytes")
+
+            data = [
+                {
+                    "metadata": {"image_url": "s3://bucket/img.png", "process_source": "UniversalImageExtractor"},
+                    "path_or_url": "test_path",
+                    "content": "image content",
+                    "source_type": "file",
+                    "file_size": 123,
+                    "filename": "img.png"
+                }
+            ]
+
+            result = ElasticSearchService.index_documents(
+                index_name="test_index",
+                data=data,
+                vdb_core=self.mock_vdb_core,
+                embedding_model=mock_embedding_model
+            )
+
+            self.assertTrue(result["success"])
+            _, kwargs = self.mock_vdb_core.vectorize_documents.call_args
+            documents = kwargs.get("documents")
+            self.assertEqual(documents[0]["image_bytes"], b"img-bytes")
+            mock_get_stream.assert_called_once_with(object_name="s3://bucket/img.png")
+
     def test_vectorize_documents_empty_data(self):
         """
         Test document indexing with empty data.
@@ -1612,6 +1741,7 @@ def test_vectorize_documents_empty_data(self):
         # Setup
         test_data = []
         mock_embedding_model = MagicMock()
+        mock_embedding_model.model_type = "text"
 
         # Execute
         result = ElasticSearchService.index_documents(
@@ -1641,6 +1771,7 @@ def test_vectorize_documents_create_index(self):
         self.mock_vdb_core.create_index.return_value = True
         self.mock_vdb_core.vectorize_documents.return_value = 1
         mock_embedding_model = MagicMock()
+        mock_embedding_model.model_type = "text"
         test_data = [
             {
                 "metadata": {"title": "Test"},
@@ -1687,6 +1818,7 @@ def test_vectorize_documents_indexing_error(self):
         self.mock_vdb_core.vectorize_documents.side_effect = Exception(
             "Indexing error")
         mock_embedding_model = MagicMock()
+        mock_embedding_model.model_type = "text"
         test_data = [
             {
                 "metadata": {"title": "Test"},
@@ -3533,6 +3665,7 @@ def test_vectorize_documents_success_status_200(self, mock_get_record, mock_tena
         self.mock_vdb_core.vectorize_documents.return_value = 3
         mock_embedding_model = MagicMock()
         mock_embedding_model.model = "test-model"
+        mock_embedding_model.model_type = "text"
         mock_get_record.return_value = {"tenant_id": "tenant-1"}
         mock_tenant_cfg.get_model_config.return_value = {"chunk_batch": 10}
 
@@ -3727,12 +3860,12 @@ def test_get_embedding_model_embedding_type(self, mock_tenant_config_manager):
 
                 # Execute - now we can call the real function
                 from backend.services.vectordatabase_service import get_embedding_model
-                result = get_embedding_model("test_tenant")
+                result = get_embedding_model("test_tenant", is_multimodal=True)
 
                 # Assert
                 self.assertEqual(result, mock_embedding_instance)
                 mock_tenant_config_manager.get_model_config.assert_called_once_with(
-                    key="EMBEDDING_ID", tenant_id="test_tenant")
+                    key="MULTI_EMBEDDING_ID", tenant_id="test_tenant")
                 mock_embedding_class.assert_called_once_with(
                     api_key="test_api_key",
                     base_url="https://test.api.com",
@@ -3959,6 +4092,51 @@ def test_get_embedding_model_with_model_name_found(self, mock_get_models, mock_t
             # Restart the mock for other tests
             self.get_embedding_model_patcher.start()
 
+    @patch('backend.services.vectordatabase_service.tenant_config_manager')
+    @patch('backend.services.vectordatabase_service.get_model_records')
+    def test_get_embedding_model_with_model_name_found_multimodal(self, mock_get_models, mock_tenant_config_manager):
+        mock_get_models.return_value = [
+            {
+                "model_repo": "jina",
+                "model_name": "jina-clip-v2",
+                "api_key": "test_api_key",
+                "base_url": "https://test.api.com",
+                "max_tokens": 1024,
+                "ssl_verify": True
+            }
+        ]
+        mock_tenant_config_manager.get_model_config.return_value = {}
+
+        self.get_embedding_model_patcher.stop()
+
+        try:
+            with patch('backend.services.vectordatabase_service.JinaEmbedding') as mock_embedding_class, \
+                    patch('backend.services.vectordatabase_service.get_model_name_from_config') as mock_get_model_name:
+                mock_embedding_instance = MagicMock()
+                mock_embedding_class.return_value = mock_embedding_instance
+                mock_get_model_name.return_value = "jina-clip-v2"
+
+                from backend.services.vectordatabase_service import get_embedding_model
+                result = get_embedding_model(
+                    "test_tenant",
+                    is_multimodal=True,
+                    model_name="jina/jina-clip-v2"
+                )
+
+                self.assertEqual(result, mock_embedding_instance)
+                mock_get_models.assert_called_once_with(
+                    {"model_type": "multi_embedding"}, "test_tenant")
+                mock_embedding_class.assert_called_once_with(
+                    api_key="test_api_key",
+                    base_url="https://test.api.com",
+                    model_name="jina-clip-v2",
+                    embedding_dim=1024,
+                    ssl_verify=True
+                )
+                mock_tenant_config_manager.get_model_config.assert_not_called()
+        finally:
+            self.get_embedding_model_patcher.start()
+
     @patch('backend.services.vectordatabase_service.tenant_config_manager')
     @patch('backend.services.vectordatabase_service.get_model_records')
     def test_get_embedding_model_with_model_name_found_without_repo(self, mock_get_models, mock_tenant_config_manager):
diff --git a/test/sdk/core/models/test_embedding_model.py b/test/sdk/core/models/test_embedding_model.py
index cd76232e0..292a0712f 100644
--- a/test/sdk/core/models/test_embedding_model.py
+++ b/test/sdk/core/models/test_embedding_model.py
@@ -61,6 +61,22 @@ def jina_embedding_instance():
     return JinaEmbedding(api_key="dummy-key", ssl_verify=True)
 
 
+def test_openai_embedding_default_model_type():
+    emb = OpenAICompatibleEmbedding(
+        model_name="dummy-model",
+        base_url="https://api.example.com",
+        api_key="dummy-key",
+        embedding_dim=128,
+        ssl_verify=True,
+    )
+    assert emb.model_type == "text"
+
+
+def test_jina_embedding_default_model_type():
+    emb = JinaEmbedding(api_key="dummy-key", ssl_verify=True)
+    assert emb.model_type == "multimodal"
+
+
 # ---------------------------------------------------------------------------
 # Tests for dimension_check
 # ---------------------------------------------------------------------------
diff --git a/test/sdk/core/tools/test_knowledge_base_search_tool.py b/test/sdk/core/tools/test_knowledge_base_search_tool.py
index ad6c7987b..051ced94d 100644
--- a/test/sdk/core/tools/test_knowledge_base_search_tool.py
+++ b/test/sdk/core/tools/test_knowledge_base_search_tool.py
@@ -1,10 +1,10 @@
-import pytest
-from unittest.mock import MagicMock, patch
 import json
+from unittest.mock import MagicMock, patch
+
+import pytest
 
-# Import target module
-from sdk.nexent.core.utils.observer import MessageObserver, ProcessType
 from sdk.nexent.core.tools.knowledge_base_search_tool import KnowledgeBaseSearchTool
+from sdk.nexent.core.utils.observer import MessageObserver, ProcessType
 
 
 @pytest.fixture
@@ -55,10 +55,10 @@ def create_mock_search_result(count=3):
                 "filename": f"test_file_{i}.txt",
                 "path_or_url": f"/path/to/file_{i}.txt",
                 "create_time": "2024-01-01T12:00:00Z",
-                "source_type": "file"
+                "source_type": "file",
             },
             "score": 0.9 - (i * 0.1),
-            "index": f"test_index_{i % 2 + 1}"
+            "index": f"test_index_{i % 2 + 1}",
         }
         results.append(result)
     return results
@@ -72,16 +72,22 @@ def test_forward_with_observer_adds_messages(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(1)
         knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
 
-        knowledge_base_search_tool.forward("hello world", index_names="test_index1,test_index2")
+        knowledge_base_search_tool.forward(
+            "hello world", index_names="test_index1,test_index2"
+        )
 
         knowledge_base_search_tool.observer.add_message.assert_any_call(
             "", ProcessType.TOOL, "Searching the knowledge base..."
         )
         knowledge_base_search_tool.observer.add_message.assert_any_call(
-            "", ProcessType.CARD, json.dumps([{"icon": "search", "text": "hello world"}], ensure_ascii=False)
+            "",
+            ProcessType.CARD,
+            json.dumps([{"icon": "search", "text": "hello world"}], ensure_ascii=False),
         )
 
-    def test_init_with_custom_values(self, mock_observer, mock_vdb_core, mock_embedding_model):
+    def test_init_with_custom_values(
+        self, mock_observer, mock_vdb_core, mock_embedding_model
+    ):
         """Test initialization with custom values"""
         tool = KnowledgeBaseSearchTool(
             top_k=10,
@@ -120,7 +126,9 @@ def test_search_hybrid_success(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(3)
         knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.search_hybrid("test query", ["test_index1"], top_k=5)
+        result = knowledge_base_search_tool.search_hybrid(
+            "test query", ["test_index1"], top_k=5
+        )
 
         # Verify result structure
         assert result["total"] == 3
@@ -139,7 +147,7 @@ def test_search_hybrid_success(self, knowledge_base_search_tool):
             index_names=["test_index1"],
             query_text="test query",
             embedding_model=knowledge_base_search_tool.embedding_model,
-            top_k=5
+            top_k=5,
         )
 
     def test_search_accurate_success(self, knowledge_base_search_tool):
@@ -148,7 +156,9 @@ def test_search_accurate_success(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(2)
         knowledge_base_search_tool.vdb_core.accurate_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.search_accurate("test query", ["test_index1"], top_k=5)
+        result = knowledge_base_search_tool.search_accurate(
+            "test query", ["test_index1"], top_k=5
+        )
 
         # Verify result structure
         assert result["total"] == 2
@@ -156,9 +166,7 @@ def test_search_accurate_success(self, knowledge_base_search_tool):
 
         # Verify vdb_core was called correctly
         knowledge_base_search_tool.vdb_core.accurate_search.assert_called_once_with(
-            index_names=["test_index1"],
-            query_text="test query",
-            top_k=5
+            index_names=["test_index1"], query_text="test query", top_k=5
         )
 
     def test_search_semantic_success(self, knowledge_base_search_tool):
@@ -167,7 +175,9 @@ def test_search_semantic_success(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(4)
         knowledge_base_search_tool.vdb_core.semantic_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.search_semantic("test query", ["test_index1"], top_k=5)
+        result = knowledge_base_search_tool.search_semantic(
+            "test query", ["test_index1"], top_k=5
+        )
 
         # Verify result structure
         assert result["total"] == 4
@@ -178,17 +188,21 @@ def test_search_semantic_success(self, knowledge_base_search_tool):
             index_names=["test_index1"],
             query_text="test query",
             embedding_model=knowledge_base_search_tool.embedding_model,
-            top_k=5
+            top_k=5,
         )
 
     def test_search_hybrid_error(self, knowledge_base_search_tool):
         """Test hybrid search with error"""
-        knowledge_base_search_tool.vdb_core.hybrid_search.side_effect = Exception("Search error")
+        knowledge_base_search_tool.vdb_core.hybrid_search.side_effect = Exception(
+            "Search error"
+        )
 
         with pytest.raises(Exception) as excinfo:
-            knowledge_base_search_tool.search_hybrid("test query", ["test_index1"], top_k=5)
+            knowledge_base_search_tool.search_hybrid(
+                "test query", ["test_index1"], top_k=5
+            )
 
-        assert "Error during semantic search" in str(excinfo.value)
+        assert "Error during hybrid search" in str(excinfo.value)
 
     def test_forward_accurate_mode_success(self, knowledge_base_search_tool):
         """Test forward method with accurate search mode"""
@@ -252,14 +266,16 @@ def test_forward_with_custom_index_names(self, knowledge_base_search_tool):
         knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
 
         # Pass index_names as a list parameter (forward expects List[str])
-        knowledge_base_search_tool.forward("test query", index_names=["custom_index1", "custom_index2"])
+        knowledge_base_search_tool.forward(
+            "test query", index_names=["custom_index1", "custom_index2"]
+        )
 
         # Verify vdb_core was called with the index names as-is
         knowledge_base_search_tool.vdb_core.hybrid_search.assert_called_once_with(
             index_names=["custom_index1", "custom_index2"],
             query_text="test query",
             embedding_model=knowledge_base_search_tool.embedding_model,
-            top_k=5
+            top_k=5,
         )
 
     def test_forward_chinese_language_observer(self, knowledge_base_search_tool):
@@ -271,7 +287,7 @@ def test_forward_chinese_language_observer(self, knowledge_base_search_tool):
         mock_results = create_mock_search_result(2)
         knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
 
-        result = knowledge_base_search_tool.forward("test query", index_names="test_index1")
+        knowledge_base_search_tool.forward("test query", index_names="test_index1")
 
         # Verify Chinese running prompt
         knowledge_base_search_tool.observer.add_message.assert_any_call(
@@ -289,10 +305,10 @@ def test_forward_title_fallback(self, knowledge_base_search_tool):
                     "filename": "test.txt",  # Should be used as title
                     "path_or_url": "/path/test.txt",
                     "create_time": "2024-01-01T12:00:00Z",
-                    "source_type": "file"
+                    "source_type": "file",
                 },
                 "score": 0.9,
-                "index": "test_index"
+                "index": "test_index",
             }
         ]
         knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
@@ -306,6 +322,41 @@ def test_forward_title_fallback(self, knowledge_base_search_tool):
         assert len(search_results) == 1
         assert search_results[0]["title"] == "test.txt"
 
+    def test_forward_adds_picture_web_for_images(
+        self, knowledge_base_search_tool, monkeypatch
+    ):
+        """Forward should add picture messages when image results are present."""
+        monkeypatch.setenv("DATA_PROCESS_SERVICE", "https://data-process")
+        knowledge_base_search_tool.data_process_service = "https://data-process"
+
+        mock_results = [
+            {
+                "document": {
+                    "title": "Image Doc",
+                    "content": "Image content",
+                    "filename": "img.png",
+                    "path_or_url": "/path/img.png",
+                    "create_time": "2024-01-01T12:00:00Z",
+                    "source_type": "file",
+                },
+                "content": json.dumps({"image_url": "s3://bucket/img.png"}),
+                "process_source": "UniversalImageExtractor",
+                "score": 0.9,
+                "index": "test_index",
+            }
+        ]
+        knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
+
+        with patch.object(
+            knowledge_base_search_tool,
+            "_filter_images",
+            return_value=["s3://bucket/img.png"],
+        ):
+            knowledge_base_search_tool.forward("find images")
+
+        calls = knowledge_base_search_tool.observer.add_message.call_args_list
+        assert any(call.args[1] == ProcessType.PICTURE_WEB for call in calls)
+
 
 class TestKnowledgeBaseSearchToolRerank:
     """Tests for KnowledgeBaseSearchTool rerank functionality."""
@@ -347,7 +398,9 @@ def test_init_without_rerank_params(self, mock_observer):
         assert tool.rerank_model_name.default == ""
         assert tool.rerank_model.default is None
 
-    def test_forward_with_rerank_enabled(self, mock_observer, mock_vdb_core, mock_embedding_model, mocker):
+    def test_forward_with_rerank_enabled(
+        self, mock_observer, mock_vdb_core, mock_embedding_model, mocker
+    ):
         """Test forward method when rerank is enabled and model is provided."""
         # Mock search results
         mock_results = [
@@ -358,10 +411,10 @@ def test_forward_with_rerank_enabled(self, mock_observer, mock_vdb_core, mock_em
                     "filename": "doc1.txt",
                     "path_or_url": "/path/doc1.txt",
                     "create_time": "2024-01-01T12:00:00Z",
-                    "source_type": "file"
+                    "source_type": "file",
                 },
                 "score": 0.9,
-                "index": "kb1"
+                "index": "kb1",
             },
             {
                 "document": {
@@ -370,11 +423,11 @@ def test_forward_with_rerank_enabled(self, mock_observer, mock_vdb_core, mock_em
                     "filename": "doc2.txt",
                     "path_or_url": "/path/doc2.txt",
                     "create_time": "2024-01-01T12:00:00Z",
-                    "source_type": "file"
+                    "source_type": "file",
                 },
                 "score": 0.8,
-                "index": "kb1"
-            }
+                "index": "kb1",
+            },
         ]
         mock_vdb_core.hybrid_search.return_value = mock_results
 
@@ -397,8 +450,7 @@ def test_forward_with_rerank_enabled(self, mock_observer, mock_vdb_core, mock_em
             observer=mock_observer,
         )
 
-        result = tool.forward("test query")
-        results = json.loads(result)
+        tool.forward("test query")
 
         # Verify rerank was called
         mock_rerank_model.rerank.assert_called_once()
@@ -406,7 +458,9 @@ def test_forward_with_rerank_enabled(self, mock_observer, mock_vdb_core, mock_em
         assert call_args[1]["query"] == "test query"
         assert len(call_args[1]["documents"]) == 2
 
-    def test_forward_rerank_disabled(self, mock_observer, mock_vdb_core, mock_embedding_model):
+    def test_forward_rerank_disabled(
+        self, mock_observer, mock_vdb_core, mock_embedding_model
+    ):
         """Test forward method when rerank is disabled."""
         # Mock search results
         mock_results = [
@@ -417,10 +471,10 @@ def test_forward_rerank_disabled(self, mock_observer, mock_vdb_core, mock_embedd
                     "filename": "doc1.txt",
                     "path_or_url": "/path/doc1.txt",
                     "create_time": "2024-01-01T12:00:00Z",
-                    "source_type": "file"
+                    "source_type": "file",
                 },
                 "score": 0.9,
-                "index": "kb1"
+                "index": "kb1",
             }
         ]
         mock_vdb_core.hybrid_search.return_value = mock_results
@@ -440,7 +494,9 @@ def test_forward_rerank_disabled(self, mock_observer, mock_vdb_core, mock_embedd
         # Should work normally without reranking
         assert result is not None
 
-    def test_forward_rerank_error_continues(self, mock_observer, mock_vdb_core, mock_embedding_model):
+    def test_forward_rerank_error_continues(
+        self, mock_observer, mock_vdb_core, mock_embedding_model
+    ):
         """Test that forward continues when rerank raises an exception."""
         # Mock search results
         mock_results = [
@@ -451,10 +507,10 @@ def test_forward_rerank_error_continues(self, mock_observer, mock_vdb_core, mock
                     "filename": "doc1.txt",
                     "path_or_url": "/path/doc1.txt",
                     "create_time": "2024-01-01T12:00:00Z",
-                    "source_type": "file"
+                    "source_type": "file",
                 },
                 "score": 0.9,
-                "index": "kb1"
+                "index": "kb1",
             }
         ]
         mock_vdb_core.hybrid_search.return_value = mock_results
@@ -493,46 +549,6 @@ def test_forward_uses_instance_index_names(self, knowledge_base_search_tool):
 
     def test_forward_empty_index_names_string(self, knowledge_base_search_tool):
         """Test forward method with empty index_names string returns no results"""
-        # Mock search results
-        mock_results = create_mock_search_result(2)
-        knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
-
-        # Pass empty string as index_names
         result = knowledge_base_search_tool.forward("test query", index_names="")
 
-        # Should return no results message
-        assert result == json.dumps("No knowledge base selected. No relevant information found.", ensure_ascii=False)
-
-    def test_forward_single_index_name(self, knowledge_base_search_tool):
-        """Test forward method with single index name"""
-        # Mock search results
-        mock_results = create_mock_search_result(1)
-        knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
-
-        # Pass index_names as a list parameter (forward expects List[str])
-        knowledge_base_search_tool.forward("test query", index_names=["single_index"])
-
-        # Verify vdb_core was called with single index
-        knowledge_base_search_tool.vdb_core.hybrid_search.assert_called_once_with(
-            index_names=["single_index"],
-            query_text="test query",
-            embedding_model=knowledge_base_search_tool.embedding_model,
-            top_k=5
-        )
-
-    def test_forward_with_whitespace_in_index_names(self, knowledge_base_search_tool):
-        """Test forward method handles whitespace in index_names correctly"""
-        # Mock search results
-        mock_results = create_mock_search_result(1)
-        knowledge_base_search_tool.vdb_core.hybrid_search.return_value = mock_results
-
-        # Pass index_names as a list parameter (forward expects List[str])
-        knowledge_base_search_tool.forward("test query", index_names=["  index1  ", "  index2  "])
-
-        # Verify vdb_core was called with the index names as-is (no stripping performed)
-        knowledge_base_search_tool.vdb_core.hybrid_search.assert_called_once_with(
-            index_names=["  index1  ", "  index2  "],
-            query_text="test query",
-            embedding_model=knowledge_base_search_tool.embedding_model,
-            top_k=5
-        )
+        assert json.loads(result) == "No knowledge base selected. No relevant information found."
diff --git a/test/sdk/core/utils/test_favicon_extractor.py b/test/sdk/core/utils/test_favicon_extractor.py
new file mode 100644
index 000000000..0e4448a82
--- /dev/null
+++ b/test/sdk/core/utils/test_favicon_extractor.py
@@ -0,0 +1,38 @@
+import importlib.util
+import sys
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+MODULE_NAME = "favicon_extractor_under_test"
+MODULE_PATH = (
+    Path(__file__).resolve().parents[4]
+    / "sdk"
+    / "nexent"
+    / "core"
+    / "utils"
+    / "favicon_extractor.py"
+)
+spec = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)
+favicon_module = importlib.util.module_from_spec(spec)
+sys.modules[MODULE_NAME] = favicon_module
+assert spec and spec.loader
+spec.loader.exec_module(favicon_module)
+
+get_favicon_url = favicon_module.get_favicon_url
+check_favicon_exists = favicon_module.check_favicon_exists
+
+
+def test_get_favicon_url_builds_default():
+    assert get_favicon_url("https://example.com/path") == "https://example.com/favicon.ico"
+
+
+def test_check_favicon_exists_true():
+    mock_response = Mock()
+    mock_response.status_code = 200
+    with patch(f"{MODULE_NAME}.requests.head", return_value=mock_response):
+        assert check_favicon_exists("https://example.com/favicon.ico") is True
+
+
+def test_check_favicon_exists_false_on_error():
+    with patch(f"{MODULE_NAME}.requests.head", side_effect=Exception("boom")):
+        assert check_favicon_exists("https://example.com/favicon.ico") is False
diff --git a/test/sdk/data_process/test_core.py b/test/sdk/data_process/test_core.py
index b75b35f94..5dfff546f 100644
--- a/test/sdk/data_process/test_core.py
+++ b/test/sdk/data_process/test_core.py
@@ -5,6 +5,18 @@
 from sdk.nexent.data_process.core import DataProcessCore
 
 
+def _unpack_chunks(result):
+    if isinstance(result, tuple):
+        return result[0]
+    return result
+
+
+def _unpack_images(result):
+    if isinstance(result, tuple):
+        return result[1]
+    return []
+
+
 class TestDataProcessCore:
     """Test suite for DataProcessCore class"""
 
@@ -18,7 +30,8 @@ def test_init(self, core):
         assert core is not None
         assert "Unstructured" in core.processors
         assert "OpenPyxl" in core.processors
-        assert len(core.processors) == 2
+        assert "UniversalImageExtractor" in core.processors
+        assert len(core.processors) == 3
 
     def test_file_process_with_excel_file(self, core, mocker: MockFixture):
         """Test file processing with Excel file"""
@@ -29,6 +42,9 @@ def test_file_process_with_excel_file(self, core, mocker: MockFixture):
                 "metadata": {"chunk_index": 0}}
         ]
         core.processors["OpenPyxl"] = mock_processor
+        core.processors["UniversalImageExtractor"] = Mock(
+            process_file=Mock(return_value=[])
+        )
 
         file_data = b"fake excel data"
         filename = "test.xlsx"
@@ -36,8 +52,9 @@ def test_file_process_with_excel_file(self, core, mocker: MockFixture):
         result = core.file_process(
             file_data, filename, chunking_strategy="basic")
 
-        assert len(result) == 1
-        assert result[0]["content"] == "test content"
+        chunks = _unpack_chunks(result)
+        assert len(chunks) == 1
+        assert chunks[0]["content"] == "test content"
         mock_processor.process_file.assert_called_once_with(
             file_data, "basic", filename=filename
         )
@@ -57,8 +74,9 @@ def test_file_process_with_pdf_file(self, core, mocker: MockFixture):
         result = core.file_process(
             file_data, filename, chunking_strategy="by_title")
 
-        assert len(result) == 1
-        assert result[0]["content"] == "pdf content"
+        chunks = _unpack_chunks(result)
+        assert len(chunks) == 1
+        assert chunks[0]["content"] == "pdf content"
         mock_processor.process_file.assert_called_once_with(
             file_data, "by_title", filename=filename
         )
@@ -68,6 +86,9 @@ def test_file_process_with_explicit_processor(self, core, mocker: MockFixture):
         mock_processor = Mock()
         mock_processor.process_file.return_value = [{"content": "test"}]
         core.processors["Unstructured"] = mock_processor
+        core.processors["UniversalImageExtractor"] = Mock(
+            process_file=Mock(return_value=[])
+        )
 
         file_data = b"data"
         filename = "test.xlsx"
@@ -77,7 +98,8 @@ def test_file_process_with_explicit_processor(self, core, mocker: MockFixture):
             file_data, filename, chunking_strategy="basic", processor="Unstructured"
         )
 
-        assert len(result) == 1
+        chunks = _unpack_chunks(result)
+        assert len(chunks) == 1
         mock_processor.process_file.assert_called_once()
 
     def test_file_process_with_additional_params(self, core, mocker: MockFixture):
@@ -94,7 +116,8 @@ def test_file_process_with_additional_params(self, core, mocker: MockFixture):
             file_data, filename, chunking_strategy="basic", **additional_params
         )
 
-        assert len(result) == 1
+        chunks = _unpack_chunks(result)
+        assert len(chunks) == 1
         mock_processor.process_file.assert_called_once_with(
             file_data, "basic", filename=filename, max_characters=2000, strategy="fast"
         )
@@ -152,7 +175,7 @@ def test_validate_parameters_valid_strategies(self, core, chunking_strategy):
 
     @pytest.mark.parametrize(
         "processor",
-        ["Unstructured", "OpenPyxl"]
+        ["Unstructured", "OpenPyxl", "UniversalImageExtractor"]
     )
     def test_validate_parameters_valid_processors(self, core, processor):
         """Test parameter validation with valid processors"""
@@ -170,21 +193,24 @@ def test_validate_parameters_invalid_processor(self, core):
             core._validate_parameters("basic", "InvalidProcessor")
 
     @pytest.mark.parametrize(
-        "filename,expected_processor",
+        "filename,expected_processor,expected_extractor",
         [
-            ("test.xlsx", "OpenPyxl"),
-            ("test.xls", "OpenPyxl"),
-            ("test.XLSX", "OpenPyxl"),
-            ("test.pdf", "Unstructured"),
-            ("test.docx", "Unstructured"),
-            ("test.txt", "Unstructured"),
-            ("test.html", "Unstructured"),
+            ("test.xlsx", "OpenPyxl", "UniversalImageExtractor"),
+            ("test.xls", "OpenPyxl", "UniversalImageExtractor"),
+            ("test.XLSX", "OpenPyxl", "UniversalImageExtractor"),
+            ("test.pdf", "Unstructured", "UniversalImageExtractor"),
+            ("test.docx", "Unstructured", "UniversalImageExtractor"),
+            ("test.pptx", "Unstructured", None),
+            ("test.txt", "Unstructured", None),
+            ("test.html", "Unstructured", None),
         ]
     )
-    def test_select_processor_by_filename(self, core, filename, expected_processor):
+    def test_select_processor_by_filename(self, core, filename, expected_processor, expected_extractor):
         """Test processor selection based on filename"""
-        result = core._select_processor_by_filename(filename)
-        assert result == expected_processor
+        params = {"model_type": "multi_embedding"} if expected_extractor else {}
+        processor_name, extractor = core._select_processor_by_filename(filename, params)
+        assert processor_name == expected_processor
+        assert extractor == expected_extractor
 
     def test_get_supported_file_types(self, core):
         """Test getting supported file types"""
@@ -240,7 +266,8 @@ def test_get_supported_processors(self, core):
 
         assert "Unstructured" in result
         assert "OpenPyxl" in result
-        assert len(result) == 2
+        assert "UniversalImageExtractor" in result
+        assert len(result) == 3
 
     @pytest.mark.parametrize(
         "filename,expected",
@@ -310,3 +337,44 @@ def test_get_processor_info_case_insensitive(self, core):
 
         assert result["processor_type"] == "excel"
         assert result["file_extension"] == ".xlsx"
+
+    def test_file_process_returns_images_when_extractor_available(self, core, mocker: MockFixture):
+        """Test image extraction is returned for supported file types."""
+        mock_processor = Mock()
+        mock_processor.process_file.return_value = [{"content": "test"}]
+        mock_extractor = Mock()
+        mock_extractor.process_file.return_value = [
+            {"image_bytes": b"img", "image_format": "png", "position": {"page_number": 1}}
+        ]
+        core.processors["Unstructured"] = mock_processor
+        core.processors["UniversalImageExtractor"] = mock_extractor
+
+        result = core.file_process(
+            b"data", "sample.pdf", chunking_strategy="basic", model_type="multi_embedding"
+        )
+
+        chunks = _unpack_chunks(result)
+        images = _unpack_images(result)
+        assert len(chunks) == 1
+        assert len(images) == 1
+        mock_extractor.process_file.assert_called_once()
+
+    def test_file_process_with_explicit_processor_still_extracts_images(self, core):
+        """Test explicit processor still triggers image extraction."""
+        core.processors["Unstructured"] = Mock(process_file=Mock(return_value=[{"content": "ok"}]))
+        core.processors["UniversalImageExtractor"] = Mock(
+            process_file=Mock(return_value=[{"image_bytes": b"x", "image_format": "png", "position": {}}])
+        )
+
+        result = core.file_process(
+            b"data",
+            "report.pdf",
+            chunking_strategy="basic",
+            processor="Unstructured",
+            model_type="multi_embedding",
+        )
+
+        chunks = _unpack_chunks(result)
+        images = _unpack_images(result)
+        assert len(chunks) == 1
+        assert len(images) == 1
diff --git a/test/sdk/data_process/test_extract_image.py b/test/sdk/data_process/test_extract_image.py
new file mode 100644
index 000000000..9b928666d
--- /dev/null
+++ b/test/sdk/data_process/test_extract_image.py
@@ -0,0 +1,118 @@
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+MODULE_PATH = REPO_ROOT / "sdk" / "nexent" / "data_process" / "extract_image.py"
+MODULE_NAME = "sdk.nexent.data_process.extract_image"
+
+sdk_pkg = types.ModuleType("sdk")
+sdk_pkg.__path__ = [str(REPO_ROOT / "sdk")]
+sys.modules.setdefault("sdk", sdk_pkg)
+
+nexent_pkg = types.ModuleType("sdk.nexent")
+nexent_pkg.__path__ = [str(REPO_ROOT / "sdk" / "nexent")]
+sys.modules.setdefault("sdk.nexent", nexent_pkg)
+sdk_pkg.nexent = nexent_pkg
+
+data_process_pkg = types.ModuleType("sdk.nexent.data_process")
+data_process_pkg.__path__ = [str(REPO_ROOT / "sdk" / "nexent" / "data_process")]
+sys.modules.setdefault("sdk.nexent.data_process", data_process_pkg)
+nexent_pkg.data_process = data_process_pkg
+spec = importlib.util.spec_from_file_location(MODULE_NAME, MODULE_PATH)
+extract_image_module = importlib.util.module_from_spec(spec)
+sys.modules[MODULE_NAME] = extract_image_module
+assert spec and spec.loader
+spec.loader.exec_module(extract_image_module)
+data_process_pkg.extract_image = extract_image_module
+
+UniversalImageExtractor = extract_image_module.UniversalImageExtractor
+
+
+def test_detect_image_format_png():
+    assert UniversalImageExtractor.detect_image_format(b"\x89PNG\r\n\x1a\n") == "png"
+
+
+def test_detect_image_format_jpg():
+    assert UniversalImageExtractor.detect_image_format(b"\xFF\xD8\xFF\xE0") == "jpg"
+
+
+def test_detect_image_format_default_png():
+    assert UniversalImageExtractor.detect_image_format(b"not-an-image") == "png"
+
+
+def test_convert_file_success(mocker):
+    extractor = UniversalImageExtractor()
+    mocker.patch(f"{MODULE_NAME}.subprocess.run")
+    mocker.patch(f"{MODULE_NAME}.os.path.exists", return_value=True)
+    mocker.patch(f"{MODULE_NAME}.os.path.splitext", return_value=("C:/tmp/file", ".doc"))
+
+    result = extractor._convert_file("C:/tmp/file.doc", "pdf")
+
+    assert result.endswith(".pdf")
+
+
+def test_convert_file_missing_output(mocker):
+    extractor = UniversalImageExtractor()
+    mocker.patch(f"{MODULE_NAME}.subprocess.run")
+    mocker.patch(f"{MODULE_NAME}.os.path.exists", return_value=False)
+    mocker.patch(f"{MODULE_NAME}.os.path.splitext", return_value=("C:/tmp/file", ".doc"))
+
+    with pytest.raises(FileNotFoundError):
+        extractor._convert_file("C:/tmp/file.doc", "pdf")
+
+
+def test_process_file_routes_pdf(mocker, tmp_path):
+    extractor = UniversalImageExtractor()
+    mocker.patch.object(extractor, "_write_temp_file", return_value=str(tmp_path / "file.pdf"))
+    mock_extract = mocker.patch.object(extractor, "_extract_pdf", return_value=[{"image_bytes": b"x"}])
+
+    result = extractor.process_file(b"data", "none", "file.pdf")
+
+    assert result == [{"image_bytes": b"x"}]
+    mock_extract.assert_called_once()
+
+
+def test_process_file_routes_xls_and_ppt(mocker, tmp_path):
+    extractor = UniversalImageExtractor()
+    mocker.patch.object(extractor, "_write_temp_file", return_value=str(tmp_path / "file.xls"))
+    mocker.patch.object(extractor, "_convert_file", return_value=str(tmp_path / "file.xlsx"))
+    mock_extract_excel = mocker.patch.object(extractor, "_extract_excel", return_value=[{"image_bytes": b"x"}])
+
+    result = extractor.process_file(b"data", "none", "file.xls")
+
+    assert result == [{"image_bytes": b"x"}]
+    mock_extract_excel.assert_called_once_with(str(tmp_path / "file.xlsx"))
+
+    mocker.patch.object(extractor, "_write_temp_file", return_value=str(tmp_path / "file.ppt"))
+    mocker.patch.object(extractor, "_convert_file", return_value=str(tmp_path / "file.pptx"))
+    mock_extract_ppt = mocker.patch.object(extractor, "_extract_pptx", return_value=[{"image_bytes": b"y"}])
+
+    result = extractor.process_file(b"data", "none", "file.ppt")
+
+    assert result == [{"image_bytes": b"y"}]
+    mock_extract_ppt.assert_called_once_with(str(tmp_path / "file.pptx"))
+
+
+def test_process_file_routes_docx_to_pdf(mocker, tmp_path):
+    extractor = UniversalImageExtractor()
+    mocker.patch.object(extractor, "_write_temp_file", return_value=str(tmp_path / "file.docx"))
+    mocker.patch.object(extractor, "_convert_file", return_value=str(tmp_path / "file.pdf"))
+    mock_extract = mocker.patch.object(extractor, "_extract_pdf", return_value=[{"image_bytes": b"x"}])
+
+    result = extractor.process_file(b"data", "none", "file.docx")
+
+    assert result == [{"image_bytes": b"x"}]
+    mock_extract.assert_called_once_with(str(tmp_path / "file.pdf"))
+
+
+def test_process_file_unsupported_extension_returns_empty(mocker, tmp_path):
+    extractor = UniversalImageExtractor()
+    mocker.patch.object(extractor, "_write_temp_file", return_value=str(tmp_path / "file.txt"))
+
+    result = extractor.process_file(b"data", "none", "file.txt")
+
+    assert result == []
diff --git a/test/sdk/vector_database/test_elasticsearch_core.py b/test/sdk/vector_database/test_elasticsearch_core.py
index 1ce45d316..bc71a915a 100644
--- a/test/sdk/vector_database/test_elasticsearch_core.py
+++ b/test/sdk/vector_database/test_elasticsearch_core.py
@@ -700,6 +700,7 @@ def time_side_effect():
 def test_vectorize_documents_empty_list(elasticsearch_core_instance):
     """Test indexing an empty list of documents."""
     mock_embedding_model = MagicMock()
+    mock_embedding_model.model_type = "text"
 
     result = elasticsearch_core_instance.vectorize_documents(
         "test_index",
@@ -714,6 +715,7 @@ def test_vectorize_documents_empty_list(elasticsearch_core_instance):
 def test_vectorize_documents_small_batch(elasticsearch_core_instance):
     """Test indexing a small batch of documents (< 64)."""
     mock_embedding_model = MagicMock()
+    mock_embedding_model.model_type = "text"
     mock_embedding_model.get_embeddings.return_value = [[0.1] * 1024] * 3
     mock_embedding_model.embedding_model_name = "test-model"
 
@@ -742,6 +744,84 @@ def test_vectorize_documents_small_batch(elasticsearch_core_instance):
         mock_embedding_model.get_embeddings.assert_called_once()
         mock_bulk.assert_called_once()
 
+
+def test_vectorize_documents_multimodal_sets_multi_embedding(elasticsearch_core_instance):
+    embedding_model = MagicMock()
+    embedding_model.model_type = "multimodal"
+    embedding_model.get_multimodal_embeddings.return_value = [[0.1, 0.2], [0.3, 0.4]]
+
+    documents = [
+        {
+            "content": "text content",
+            "process_source": "Unstructured",
+            "path_or_url": "path1",
+        },
+        {
+            "content": "image content",
+            "process_source": "UniversalImageExtractor",
+            "image_bytes": b"img",
+            "path_or_url": "path2",
+        },
+    ]
+
+    with patch.object(elasticsearch_core_instance.client, "bulk") as mock_bulk, \
+            patch.object(elasticsearch_core_instance, "_force_refresh_with_retry", return_value=True):
+        mock_bulk.return_value = {"errors": False, "items": []}
+
+        result = elasticsearch_core_instance.vectorize_documents(
+            documents=documents,
+            index_name="test_index",
+            content_field="content",
+            embedding_model=embedding_model,
+            embedding_batch_size=2,
+        )
+
+        assert result == 2
+        operations = mock_bulk.call_args.kwargs["operations"]
+        doc_entries = [item for item in operations if "index" not in item]
+        image_doc = next(doc for doc in doc_entries if doc["process_source"] == "UniversalImageExtractor")
+        text_doc = next(doc for doc in doc_entries if doc["process_source"] != "UniversalImageExtractor")
+        assert "multi_embedding" in image_doc
+        assert "embedding" in text_doc
+
+
+def test_vectorize_documents_text_embedding_skips_images(elasticsearch_core_instance):
+    embedding_model = MagicMock()
+    embedding_model.model_type = "text"
+    embedding_model.get_embeddings.return_value = [[0.1, 0.2]]
+
+    documents = [
+        {
+            "content": "image content",
+            "process_source": "UniversalImageExtractor",
+            "image_bytes": b"img",
+            "path_or_url": "path2",
+        },
+        {
+            "content": "text content",
+            "process_source": "Unstructured",
+            "path_or_url": "path1",
+        },
+    ]
+
+    with patch.object(elasticsearch_core_instance.client, "bulk") as mock_bulk, \
+            patch.object(elasticsearch_core_instance, "_force_refresh_with_retry", return_value=True):
+        mock_bulk.return_value = {"errors": False, "items": []}
+
+        result = elasticsearch_core_instance.vectorize_documents(
+            documents=documents,
+            index_name="test_index",
+            content_field="content",
+            embedding_model=embedding_model,
+            embedding_batch_size=2,
+        )
+
+        assert result == 1
+        operations = mock_bulk.call_args.kwargs["operations"]
+        doc_entries = [item for item in operations if "index" not in item]
+        assert len(doc_entries) == 1
+        assert doc_entries[0]["process_source"] != "UniversalImageExtractor"
+
 def test_small_batch_progress_callback_exception(elasticsearch_core_instance, caplog):
     """Progress callback errors should be logged without failing the insert."""
     mock_embedding_model = MagicMock()
@@ -787,6 +867,7 @@ def test_small_batch_error_path_logs_and_raises(elasticsearch_core_instance, cap
 def test_vectorize_documents_large_batch(elasticsearch_core_instance):
     """Test indexing a large batch of documents (>= 64)."""
     mock_embedding_model = MagicMock()
+    mock_embedding_model.model_type = "text"
     mock_embedding_model.get_embeddings.return_value = [[0.1] * 1024] * 64
     mock_embedding_model.embedding_model_name = "test-model"
 
@@ -1259,6 +1340,7 @@ def test_accurate_search_builds_multi_index_query(elasticsearch_core_instance):
 def test_semantic_search_success(elasticsearch_core_instance):
     """Test semantic search with vector similarity."""
     mock_embedding_model = MagicMock()
+    mock_embedding_model.model_type = "text"
     mock_embedding_model.get_embeddings.return_value = [[0.1] * 1024]
 
     with patch.object(elasticsearch_core_instance, 'exec_query') as mock_exec:
@@ -1284,9 +1366,32 @@ def test_semantic_search_success(elasticsearch_core_instance):
         mock_exec.assert_called_once()
 
 
+def test_semantic_search_multimodal_combines_queries(elasticsearch_core_instance):
+    mock_embedding_model = MagicMock()
+    mock_embedding_model.model_type = "multimodal"
+    mock_embedding_model.get_embeddings.return_value = [[0.1] * 8]
+
+    with patch.object(elasticsearch_core_instance, 'exec_query') as mock_exec:
+        mock_exec.side_effect = [
+            [{"score": 1.0, "document": {"content": "text"}, "index": "test_index"}],
+            [{"score": 0.9, "document": {"content": "image"}, "index": "test_index"}],
+        ]
+
+        result = elasticsearch_core_instance.semantic_search(
+            ["test_index"],
+            "test query",
+            mock_embedding_model,
+            top_k=3,
+        )
+
+        assert len(result) == 2
+        assert mock_exec.call_count == 2
+
+
 def test_semantic_search_sets_knn_parameters(elasticsearch_core_instance):
     """Ensure semantic_search sets k and num_candidates based on top_k."""
     mock_embedding_model = MagicMock()
+    mock_embedding_model.model_type = "text"
     mock_embedding_model.get_embeddings.return_value = [[0.2] * 8]
 
     with patch.object(elasticsearch_core_instance, 'exec_query') as mock_exec:
@@ -2143,4 +2248,4 @@ def test_hybrid_search_empty_embedding_skips_storage(elasticsearch_core_instance
         # client.index should NOT be called because embedding is empty
         mock_client.index.assert_not_called()
         # Should still complete search
-        assert mock_semantic.call_count == 2
\ No newline at end of file
+        assert mock_semantic.call_count == 2