query_all_tools♻️ Backend code cleanup and import organization (apps/, consts/) #1037

Author: WMC001

backend/agents/agent_run_manager.py

@@ -1,10 +1,12 @@
 import logging
 import threading
 from typing import Dict
+
 from nexent.core.agents.agent_model import AgentRunInfo
 
 logger = logging.getLogger("agent_run_manager")
 
+
 class AgentRunManager:
     _instance = None
     _lock = threading.Lock()
@@ -52,4 +54,4 @@ def stop_agent_run(self, conversation_id: int) -> bool:
 
 
 # create singleton instance
-agent_run_manager = AgentRunManager()
+agent_run_manager = AgentRunManager()

backend/agents/create_agent_info.py

@@ -1,28 +1,28 @@
 import threading
 import logging
 from urllib.parse import urljoin
+from datetime import datetime
+
+from jinja2 import Template, StrictUndefined
+from smolagents.utils import BASE_BUILTIN_MODULES
 from nexent.core.utils.observer import MessageObserver
 from nexent.core.agents.agent_model import AgentRunInfo, ModelConfig, AgentConfig, ToolConfig
-from services.remote_mcp_service import get_remote_mcp_server_list
-from utils.auth_utils import get_current_user_id
+from nexent.memory.memory_service import search_memory_in_levels
 
-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 services.elasticsearch_service import ElasticSearchService, elastic_core, get_embedding_model
 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 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 utils.prompt_template_utils import get_agent_prompt_template
 from utils.config_utils import config_manager, tenant_config_manager, get_model_name_from_config
-from smolagents.utils import BASE_BUILTIN_MODULES
-from services.memory_config_service import build_memory_context
-from jinja2 import Template, StrictUndefined
-from datetime import datetime
-
-from nexent.memory.memory_service import search_memory_in_levels
-
+from utils.auth_utils import get_current_user_id
 
 logger = logging.getLogger("create_agent_info")
 logger.setLevel(logging.DEBUG)
 
+
 async def create_model_config_list(tenant_id):
     main_model_config = tenant_config_manager.get_model_config(key="LLM_ID", tenant_id=tenant_id)
     sub_model_config = tenant_config_manager.get_model_config(key="LLM_SECONDARY_ID", tenant_id=tenant_id)
@@ -117,7 +117,7 @@ async def create_agent_config(agent_id, tenant_id, user_id, language: str = 'zh'
         logger.error(f"Failed to build knowledge base summary: {e}")
 
     # Assemble system_prompt
-    if (duty_prompt or constraint_prompt or few_shots_prompt):
+    if duty_prompt or constraint_prompt or few_shots_prompt:
         system_prompt = Template(prompt_template["system_prompt"], undefined=StrictUndefined).render({
             "duty": duty_prompt,
             "constraint": constraint_prompt,
@@ -129,15 +129,19 @@ async def create_agent_config(agent_id, tenant_id, user_id, language: str = 'zh'
             "APP_DESCRIPTION": app_description,
             "memory_list": memory_list,
             "knowledge_base_summary": knowledge_base_summary,
-            "time" : datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         })
     else:
         system_prompt = agent_info.get("prompt", "")
 
     agent_config = AgentConfig(
         name="undefined" if agent_info["name"] is None else agent_info["name"],
         description="undefined" if agent_info["description"] is None else agent_info["description"],
-        prompt_templates=await prepare_prompt_templates(is_manager=len(managed_agents)>0, system_prompt=system_prompt, language=language),
+        prompt_templates=await prepare_prompt_templates(
+            is_manager=len(managed_agents) > 0,
+            system_prompt=system_prompt,
+            language=language
+        ),
         tools=tool_list,
         max_steps=agent_info.get("max_steps", 10),
         model_name=agent_info.get("model_name"),
@@ -253,7 +257,7 @@ async def join_minio_file_description_to_query(minio_files, query):
     return final_query
 
 
-def filter_mcp_servers_and_tools(input_agent_config: AgentConfig, mcp_info_dict)->list:
+def filter_mcp_servers_and_tools(input_agent_config: AgentConfig, mcp_info_dict) -> list:
     """
     Filter mcp servers and tools, only keep the actual used mcp servers
     Support multi-level agent, recursively check all sub-agent tools
@@ -282,8 +286,13 @@ async def create_agent_run_info(agent_id, minio_files, query, history, authoriza
 
     final_query = await join_minio_file_description_to_query(minio_files=minio_files, query=query)
     model_list = await create_model_config_list(tenant_id)
-    agent_config = await create_agent_config(agent_id=agent_id, tenant_id=tenant_id, user_id=user_id,
-                              language=language, last_user_query=final_query)
+    agent_config = await create_agent_config(
+        agent_id=agent_id,
+        tenant_id=tenant_id,
+        user_id=user_id,
+        language=language,
+        last_user_query=final_query
+    )
 
     remote_mcp_list = await get_remote_mcp_server_list(tenant_id=tenant_id)
     default_mcp_url = urljoin(config_manager.get_config("NEXENT_MCP_SERVER"), "sse")
@@ -297,7 +306,6 @@ async def create_agent_run_info(agent_id, minio_files, query, history, authoriza
     # Filter MCP servers and tools
     mcp_host = filter_mcp_servers_and_tools(agent_config, remote_mcp_dict)
 
-
     agent_run_info = AgentRunInfo(
         query=final_query,
         model_config_list=model_list,

backend/agents/preprocess_manager.py

@@ -6,6 +6,7 @@
 
 logger = logging.getLogger("preprocess_manager")
 
+
 class PreprocessTask:
     def __init__(self, task_id: str, conversation_id: int):
         self.task_id = task_id
@@ -14,6 +15,7 @@ def __init__(self, task_id: str, conversation_id: int):
         self.is_running = True
         self.task = None  # asyncio.Task reference
 
+
 class PreprocessManager:
     _instance = None
     _lock = threading.Lock()
@@ -124,5 +126,6 @@ def get_preprocess_status(self, conversation_id: int) -> Dict:
                 "tasks": running_tasks
             }
 
+
 # Create singleton instance
-preprocess_manager = PreprocessManager() 
+preprocess_manager = PreprocessManager()

backend/apps/agent_app.py

@@ -2,18 +2,27 @@
 from http import HTTPStatus
 from typing import Optional
 
-from fastapi import HTTPException, APIRouter, Header, Request, Body
+from fastapi import APIRouter, Body, Header, HTTPException, Request
 from fastapi.responses import JSONResponse
 
 from consts.model import AgentRequest, AgentInfoRequest, AgentIDRequest, ConversationResponse, AgentImportRequest
-from services.agent_service import get_agent_info_impl, \
-    get_creating_sub_agent_info_impl, update_agent_info_impl, delete_agent_impl, export_agent_impl, import_agent_impl, \
-    list_all_agent_info_impl, insert_related_agent_impl, run_agent_stream, stop_agent_tasks, \
-    get_agent_call_relationship_impl, delete_related_agent_impl
+from services.agent_service import (
+    get_agent_info_impl,
+    get_creating_sub_agent_info_impl,
+    update_agent_info_impl,
+    delete_agent_impl,
+    export_agent_impl,
+    import_agent_impl,
+    list_all_agent_info_impl,
+    insert_related_agent_impl,
+    run_agent_stream,
+    stop_agent_tasks,
+    get_agent_call_relationship_impl,
+    delete_related_agent_impl
+)
 from utils.auth_utils import get_current_user_info, get_current_user_id
 
 router = APIRouter(prefix="/agent")
-# Configure logging
 logger = logging.getLogger("agent_app")
 
 
@@ -130,6 +139,7 @@ async def import_agent_api(request: AgentImportRequest, authorization: Optional[
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Agent import error.")
 
 
+
 @router.get("/list")
 async def list_all_agent_info_api(authorization: Optional[str] = Header(None), request: Request = None):
     """

backend/apps/base_app.py

@@ -1,31 +1,30 @@
 import logging
 
 from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 
-from .agent_app import router as agent_router
-from .config_sync_app import router as config_sync_router
-from .conversation_management_app import router as conversation_management_router
-from .elasticsearch_app import router as elasticsearch_router
-from .memory_config_app import router as memory_router
-from .me_model_managment_app import router as me_model_manager_router
-from .model_managment_app import router as model_manager_router
-from .image_app import router as proxy_router
-from .file_management_app import router as file_manager_router
-from .voice_app import router as voice_router
-from .tool_config_app import router as tool_config_router
-from .user_management_app import router as user_management_router
-from .mock_user_management_app import router as mock_user_management_router
-from .prompt_app import router as prompt_router
-from .knowledge_summary_app import router as summary_router
-from .tenant_config_app import router as tenant_config_router
-from .remote_mcp_app import router as remote_mcp_router
+from apps.agent_app import router as agent_router
+from apps.config_sync_app import router as config_sync_router
+from apps.conversation_management_app import router as conversation_management_router
+from apps.elasticsearch_app import router as elasticsearch_router
+from apps.file_management_app import router as file_manager_router
+from apps.image_app import router as proxy_router
+from apps.knowledge_summary_app import router as summary_router
+from apps.memory_config_app import router as memory_router
+from apps.me_model_managment_app import router as me_model_manager_router
+from apps.mock_user_management_app import router as mock_user_management_router
+from apps.model_managment_app import router as model_manager_router
+from apps.prompt_app import router as prompt_router
+from apps.remote_mcp_app import router as remote_mcp_router
+from apps.tenant_config_app import router as tenant_config_router
+from apps.tool_config_app import router as tool_config_router
+from apps.user_management_app import router as user_management_router
+from apps.voice_app import router as voice_router
 from consts.const import IS_SPEED_MODE
 
 # Create logger instance
 logger = logging.getLogger("base_app")
-
 app = FastAPI(root_path="/api")
 
 # Add CORS middleware

backend/apps/config_sync_app.py

@@ -1,21 +1,31 @@
 import logging
+from typing import Optional
 
 from fastapi import APIRouter, Header, Request
 from fastapi.responses import JSONResponse
-from typing import Optional
 
+from consts.const import (
+    DEFAULT_APP_DESCRIPTION_ZH,
+    DEFAULT_APP_DESCRIPTION_EN,
+    DEFAULT_APP_NAME_EN,
+    DEFAULT_APP_NAME_ZH,
+    DEFAULT_APP_ICON_URL
+)
 from consts.model import GlobalConfig
-from consts.const import DEFAULT_APP_DESCRIPTION_ZH, DEFAULT_APP_DESCRIPTION_EN, DEFAULT_APP_NAME_EN, DEFAULT_APP_NAME_ZH, DEFAULT_APP_ICON_URL
-from utils.config_utils import config_manager, get_env_key, safe_value, tenant_config_manager, \
-    get_model_name_from_config
-from utils.auth_utils import get_current_user_id, get_current_user_info
 from database.model_management_db import get_model_id_by_display_name
+from utils.auth_utils import get_current_user_id, get_current_user_info
+from utils.config_utils import (
+    config_manager,
+    get_env_key,
+    safe_value,
+    tenant_config_manager,
+    get_model_name_from_config
+)
 
 router = APIRouter(prefix="/config")
-
-# Get logger instance
 logger = logging.getLogger("config_sync_app")
 
+
 def handle_model_config(tenant_id: str, user_id: str, config_key: str, model_id: int, tenant_config_dict: dict) -> None:
     """
     Handle model configuration updates, deletions, and settings operations
@@ -80,10 +90,10 @@ async def save_config(config: GlobalConfig, authorization: Optional[str] = Heade
                 continue
 
             model_name = model_config.get("modelName")
-            model_displayName = model_config.get("displayName")
+            model_display_name = model_config.get("displayName")
 
             config_key = get_env_key(model_type) + "_ID"
-            model_id = get_model_id_by_display_name(model_displayName, tenant_id)
+            model_id = get_model_id_by_display_name(model_display_name, tenant_id)
 
             if not model_name:
                 continue
@@ -95,8 +105,8 @@ async def save_config(config: GlobalConfig, authorization: Optional[str] = Heade
             # Still keep EMBEDDING_API_KEY in env
             if model_type == "embedding":
                 if model_config and "apiConfig" in model_config:
-                    embedding_apiCongig = model_config.get("apiConfig",{})
-                    env_config[f"{model_prefix}_API_KEY"] = safe_value(embedding_apiCongig.get("apiKey"))
+                    embedding_api_config = model_config.get("apiConfig", {})
+                    env_config[f"{model_prefix}_API_KEY"] = safe_value(embedding_api_config.get("apiKey"))
 
         # Batch update environment variables
         for key, value in env_config.items():
@@ -228,4 +238,3 @@ async def load_config(authorization: Optional[str] = Header(None), request: Requ
             status_code=400,
             content={"message": f"Failed to load configuration: {str(e)}", "status": "error"}
         )
-