⭐️ Release/v1.7.7

Author: Phinease

.gitignore

@@ -1,5 +1,4 @@
 .idea
-.gitignore
 /.env
 .vscode
 

backend/agents/create_agent_info.py

@@ -9,6 +9,7 @@
 from nexent.core.agents.agent_model import AgentRunInfo, ModelConfig, AgentConfig, ToolConfig
 from nexent.memory.memory_service import search_memory_in_levels
 
+from services.file_management_service import get_llm_model
 from services.vectordatabase_service import (
     ElasticSearchService,
     get_vector_db_core,
@@ -17,13 +18,15 @@
 from services.tenant_config_service import get_selected_knowledge_list
 from services.remote_mcp_service import get_remote_mcp_server_list
 from services.memory_config_service import build_memory_context
+from services.image_service import get_vlm_model
 from database.agent_db import search_agent_info_by_agent_id, query_sub_agents_id_list
 from database.tool_db import search_tools_for_sub_agent
 from database.model_management_db import get_model_records, get_model_by_model_id
+from database.client import minio_client
 from utils.model_name_utils import add_repo_to_name
 from utils.prompt_template_utils import get_agent_prompt_template
 from utils.config_utils import tenant_config_manager, get_model_name_from_config
-from consts.const import LOCAL_MCP_SERVER, MODEL_CONFIG_MAPPING, LANGUAGE
+from consts.const import LOCAL_MCP_SERVER, MODEL_CONFIG_MAPPING, LANGUAGE, DATA_PROCESS_SERVICE
 
 logger = logging.getLogger("create_agent_info")
 logger.setLevel(logging.DEBUG)
@@ -236,6 +239,18 @@ async def create_tool_config_list(agent_id, tenant_id, user_id):
                 "vdb_core": get_vector_db_core(),
                 "embedding_model": get_embedding_model(tenant_id=tenant_id),
             }
+        elif tool_config.class_name == "AnalyzeTextFileTool":
+            tool_config.metadata = {
+                "llm_model": get_llm_model(tenant_id=tenant_id),
+                "storage_client": minio_client,
+                "data_process_service_url": DATA_PROCESS_SERVICE
+            }
+        elif tool_config.class_name == "AnalyzeImageTool":
+            tool_config.metadata = {
+                "vlm_model": get_vlm_model(tenant_id=tenant_id),
+                "storage_client": minio_client,
+            }
+
         tool_config_list.append(tool_config)
 
     return tool_config_list
@@ -299,13 +314,12 @@ async def join_minio_file_description_to_query(minio_files, query):
     if minio_files and isinstance(minio_files, list):
         file_descriptions = []
         for file in minio_files:
-            if isinstance(file, dict) and "description" in file and file["description"]:
-                file_descriptions.append(file["description"])
-
+            if isinstance(file, dict) and "url" in file and file["url"] and "name" in file and file["name"]:
+                file_descriptions.append(f"File name: {file['name']}, S3 URL: s3:/{file['url']}")
         if file_descriptions:
-            final_query = "User provided some reference files:\n"
+            final_query = "User uploaded files. The file information is as follows:\n"
             final_query += "\n".join(file_descriptions) + "\n\n"
-            final_query += f"User wants to answer questions based on the above information: {query}"
+            final_query += f"User wants to answer questions based on the information in the above files: {query}"
     return final_query
 
 

backend/apps/agent_app.py

@@ -134,7 +134,11 @@ async def import_agent_api(request: AgentImportRequest, authorization: Optional[
     import an agent
     """
     try:
-        await import_agent_impl(request.agent_info, authorization)
+        await import_agent_impl(
+            request.agent_info,
+            authorization,
+            force_import=request.force_import
+        )
         return {}
     except Exception as e:
         logger.error(f"Agent import error: {str(e)}")

backend/apps/file_management_app.py

@@ -1,16 +1,13 @@
 import logging
-import os
 from http import HTTPStatus
 from typing import List, Optional
 
-from fastapi import APIRouter, Body, File, Form, Header, HTTPException, Path as PathParam, Query, Request, UploadFile
+from fastapi import APIRouter, Body, File, Form, Header, HTTPException, Path as PathParam, Query, UploadFile
 from fastapi.responses import JSONResponse, RedirectResponse, StreamingResponse
 
 from consts.model import ProcessParams
 from services.file_management_service import upload_to_minio, upload_files_impl, \
-    get_file_url_impl, get_file_stream_impl, delete_file_impl, list_files_impl, \
-    preprocess_files_generator
-from utils.auth_utils import get_current_user_info
+    get_file_url_impl, get_file_stream_impl, delete_file_impl, list_files_impl
 from utils.file_management_utils import trigger_data_process
 
 logger = logging.getLogger("file_management_app")
@@ -271,61 +268,3 @@ async def get_storage_file_batch_urls(
         "failed_count": sum(1 for r in results if not r.get("success", False)),
         "results": results
     }
-
-
-@file_management_runtime_router.post("/preprocess")
-async def agent_preprocess_api(
-        request: Request, query: str = Form(...),
-        files: List[UploadFile] = File(...),
-        authorization: Optional[str] = Header(None)
-):
-    """
-    Preprocess uploaded files and return streaming response
-    """
-    try:
-        # Pre-read and cache all file contents
-        user_id, tenant_id, language = get_current_user_info(
-            authorization, request)
-        file_cache = []
-        for file in files:
-            try:
-                content = await file.read()
-                file_cache.append({
-                    "filename": file.filename or "",
-                    "content": content,
-                    "ext": os.path.splitext(file.filename or "")[1].lower()
-                })
-            except Exception as e:
-                file_cache.append({
-                    "filename": file.filename or "",
-                    "error": str(e)
-                })
-
-        # Generate unique task ID for this preprocess operation
-        import uuid
-        task_id = str(uuid.uuid4())
-        conversation_id = request.query_params.get("conversation_id")
-        if conversation_id:
-            conversation_id = int(conversation_id)
-        else:
-            conversation_id = -1  # Default for cases without conversation_id
-
-        # Call service layer to generate streaming response
-        return StreamingResponse(
-            preprocess_files_generator(
-                query=query,
-                file_cache=file_cache,
-                tenant_id=tenant_id,
-                language=language,
-                task_id=task_id,
-                conversation_id=conversation_id
-            ),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive"
-            }
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=500, detail=f"File preprocessing error: {str(e)}")

backend/apps/vectordatabase_app.py

@@ -5,7 +5,7 @@
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Path, Query
 from fastapi.responses import JSONResponse
 
-from consts.model import IndexingResponse
+from consts.model import ChunkCreateRequest, ChunkUpdateRequest, HybridSearchRequest, IndexingResponse
 from nexent.vector_database.base import VectorDatabaseCore
 from services.vectordatabase_service import (
     ElasticSearchService,
@@ -226,3 +226,125 @@ def get_index_chunks(
             f"Error getting chunks for index '{index_name}': {error_msg}")
         raise HTTPException(
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=f"Error getting chunks: {error_msg}")
+
+
+@router.post("/{index_name}/chunk")
+def create_chunk(
+        index_name: str = Path(..., description="Name of the index"),
+        payload: ChunkCreateRequest = Body(..., description="Chunk data"),
+        vdb_core: VectorDatabaseCore = Depends(get_vector_db_core),
+        authorization: Optional[str] = Header(None),
+):
+    """Create a manual chunk."""
+    try:
+        user_id, _ = get_current_user_id(authorization)
+        result = ElasticSearchService.create_chunk(
+            index_name=index_name,
+            chunk_request=payload,
+            vdb_core=vdb_core,
+            user_id=user_id,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content=result)
+    except Exception as exc:
+        logger.error(
+            "Error creating chunk for index %s: %s", index_name, exc, exc_info=True
+        )
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(exc)
+        )
+
+
+@router.put("/{index_name}/chunk/{chunk_id}")
+def update_chunk(
+        index_name: str = Path(..., description="Name of the index"),
+        chunk_id: str = Path(..., description="Chunk identifier"),
+        payload: ChunkUpdateRequest = Body(...,
+                                           description="Chunk update payload"),
+        vdb_core: VectorDatabaseCore = Depends(get_vector_db_core),
+        authorization: Optional[str] = Header(None),
+):
+    """Update an existing chunk."""
+    try:
+        user_id, _ = get_current_user_id(authorization)
+        result = ElasticSearchService.update_chunk(
+            index_name=index_name,
+            chunk_id=chunk_id,
+            chunk_request=payload,
+            vdb_core=vdb_core,
+            user_id=user_id,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content=result)
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=HTTPStatus.BAD_REQUEST, detail=str(exc))
+    except Exception as exc:
+        logger.error(
+            "Error updating chunk %s for index %s: %s",
+            chunk_id,
+            index_name,
+            exc,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(exc)
+        )
+
+
+@router.delete("/{index_name}/chunk/{chunk_id}")
+def delete_chunk(
+        index_name: str = Path(..., description="Name of the index"),
+        chunk_id: str = Path(..., description="Chunk identifier"),
+        vdb_core: VectorDatabaseCore = Depends(get_vector_db_core),
+        authorization: Optional[str] = Header(None),
+):
+    """Delete a chunk."""
+    try:
+        get_current_user_id(authorization)
+        result = ElasticSearchService.delete_chunk(
+            index_name=index_name,
+            chunk_id=chunk_id,
+            vdb_core=vdb_core,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content=result)
+    except ValueError as exc:
+        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail=str(exc))
+    except Exception as exc:
+        logger.error(
+            "Error deleting chunk %s for index %s: %s",
+            chunk_id,
+            index_name,
+            exc,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(exc)
+        )
+
+
+@router.post("/search/hybrid")
+async def hybrid_search(
+        payload: HybridSearchRequest,
+        vdb_core: VectorDatabaseCore = Depends(get_vector_db_core),
+        authorization: Optional[str] = Header(None),
+):
+    """Run a hybrid (accurate + semantic) search across indices."""
+    try:
+        _, tenant_id = get_current_user_id(authorization)
+        result = ElasticSearchService.search_hybrid(
+            index_names=payload.index_names,
+            query=payload.query,
+            tenant_id=tenant_id,
+            top_k=payload.top_k,
+            weight_accurate=payload.weight_accurate,
+            vdb_core=vdb_core,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content=result)
+    except ValueError as exc:
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST,
+                            detail=str(exc))
+    except Exception as exc:
+        logger.error(f"Hybrid search failed: {exc}", exc_info=True)
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Error executing hybrid search: {str(exc)}",
+        )

backend/consts/const.py

@@ -279,7 +279,7 @@ class VectorDatabaseType(str, Enum):
     os.getenv("LLM_SLOW_TOKEN_RATE_THRESHOLD", "10.0"))  # tokens per second
 
 # APP Version
-APP_VERSION = "v1.7.6"
+APP_VERSION = "v1.7.7"
 
 DEFAULT_ZH_TITLE = "新对话"
 DEFAULT_EN_TITLE = "New Conversation"

backend/consts/model.py

@@ -175,6 +175,43 @@ class IndexingResponse(BaseModel):
     total_submitted: int
 
 
+class ChunkCreateRequest(BaseModel):
+    """Request payload for manual chunk creation."""
+
+    content: str = Field(..., min_length=1, description="Chunk content")
+    title: Optional[str] = Field(None, description="Optional chunk title")
+    filename: Optional[str] = Field(None, description="Associated file name")
+    path_or_url: Optional[str] = Field(None, description="Source path or URL")
+    chunk_id: Optional[str] = Field(
+        None, description="Explicit chunk identifier")
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Additional chunk metadata")
+
+
+class ChunkUpdateRequest(BaseModel):
+    """Request payload for chunk updates."""
+
+    content: Optional[str] = Field(None, description="Updated chunk content")
+    title: Optional[str] = Field(None, description="Updated chunk title")
+    filename: Optional[str] = Field(None, description="Updated file name")
+    path_or_url: Optional[str] = Field(
+        None, description="Updated source path or URL")
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata updates")
+
+
+class HybridSearchRequest(BaseModel):
+    """Request payload for hybrid knowledge-base searches."""
+    query: str = Field(..., min_length=1,
+                       description="Search query text")
+    index_names: List[str] = Field(..., min_items=1,
+                                   description="List of index names to search")
+    top_k: int = Field(10, ge=1, le=100,
+                       description="Number of results to return")
+    weight_accurate: float = Field(0.5, ge=0.0, le=1.0,
+                                   description="Weight applied to accurate search scores")
+
+
 # Request models
 class ProcessParams(BaseModel):
     chunking_strategy: Optional[str] = "basic"
@@ -304,6 +341,7 @@ class ExportAndImportDataFormat(BaseModel):
 
 class AgentImportRequest(BaseModel):
     agent_info: ExportAndImportDataFormat
+    force_import: bool = False
 
 
 class ConvertStateRequest(BaseModel):