diff --git a/application/agents/tools/mcp_tool.py b/application/agents/tools/mcp_tool.py index 27d0b5f5..7cb32633 100644 --- a/application/agents/tools/mcp_tool.py +++ b/application/agents/tools/mcp_tool.py @@ -1,14 +1,20 @@ -import json +import asyncio +import base64 import time from typing import Any, Dict, List, Optional -import requests - from application.agents.tools.base import Tool from application.security.encryption import decrypt_credentials +from fastmcp import Client +from fastmcp.client.auth import BearerAuth +from fastmcp.client.transports import ( + SSETransport, + StdioTransport, + StreamableHttpTransport, +) -_mcp_session_cache = {} +_mcp_clients_cache = {} class MCPTool(Tool): @@ -24,15 +30,21 @@ class MCPTool(Tool): Args: config: Dictionary containing MCP server configuration: - server_url: URL of the remote MCP server - - auth_type: Type of authentication (api_key, bearer, basic, none) + - transport_type: Transport type (auto, sse, http, stdio) + - auth_type: Type of authentication (bearer, oauth, api_key, basic, none) - encrypted_credentials: Encrypted credentials (if available) - timeout: Request timeout in seconds (default: 30) + - headers: Custom headers for requests + - command: Command for STDIO transport + - args: Arguments for STDIO transport user_id: User ID for decrypting credentials (required if encrypted_credentials exist) """ self.config = config self.server_url = config.get("server_url", "") + self.transport_type = config.get("transport_type", "auto") self.auth_type = config.get("auth_type", "none") self.timeout = config.get("timeout", 30) + self.custom_headers = config.get("headers", {}) self.auth_credentials = {} if config.get("encrypted_credentials") and user_id: @@ -42,33 +54,21 @@ class MCPTool(Tool): else: self.auth_credentials = config.get("auth_credentials", {}) self.available_tools = [] - self._session = requests.Session() - self._mcp_session_id = None - self._setup_authentication() self._cache_key = self._generate_cache_key() + self._client = None - def _setup_authentication(self): - """Setup authentication for the MCP server connection.""" - if self.auth_type == "api_key": - api_key = self.auth_credentials.get("api_key", "") - header_name = self.auth_credentials.get("api_key_header", "X-API-Key") - if api_key: - self._session.headers.update({header_name: api_key}) - elif self.auth_type == "bearer": - token = self.auth_credentials.get("bearer_token", "") - if token: - self._session.headers.update({"Authorization": f"Bearer {token}"}) - elif self.auth_type == "basic": - username = self.auth_credentials.get("username", "") - password = self.auth_credentials.get("password", "") - if username and password: - self._session.auth = (username, password) + # Only validate and setup if server_url is provided + + if self.server_url: + self._setup_client() def _generate_cache_key(self) -> str: """Generate a unique cache key for this MCP server configuration.""" auth_key = "" - if self.auth_type == "bearer": - token = self.auth_credentials.get("bearer_token", "") + if self.auth_type in ["bearer", "oauth"]: + token = self.auth_credentials.get( + "bearer_token", "" + ) or self.auth_credentials.get("access_token", "") auth_key = f"bearer:{token[:10]}..." if token else "bearer:none" elif self.auth_type == "api_key": api_key = self.auth_credentials.get("api_key", "") @@ -78,208 +78,174 @@ class MCPTool(Tool): auth_key = f"basic:{username}" else: auth_key = "none" - return f"{self.server_url}#{auth_key}" + return f"{self.server_url}#{self.transport_type}#{auth_key}" - def _get_cached_session(self) -> Optional[str]: - """Get cached session ID if available and not expired.""" - global _mcp_session_cache - - if self._cache_key in _mcp_session_cache: - session_data = _mcp_session_cache[self._cache_key] - if time.time() - session_data["created_at"] < 1800: - return session_data["session_id"] + def _setup_client(self): + """Setup FastMCP client with proper transport and authentication.""" + global _mcp_clients_cache + if self._cache_key in _mcp_clients_cache: + cached_data = _mcp_clients_cache[self._cache_key] + if time.time() - cached_data["created_at"] < 1800: + self._client = cached_data["client"] + return else: - del _mcp_session_cache[self._cache_key] - return None + del _mcp_clients_cache[self._cache_key] + transport = self._create_transport() - def _cache_session(self, session_id: str): - """Cache the session ID for reuse.""" - global _mcp_session_cache - _mcp_session_cache[self._cache_key] = { - "session_id": session_id, + if self.auth_type in ["bearer", "oauth"]: + token = self.auth_credentials.get( + "bearer_token", "" + ) or self.auth_credentials.get("access_token", "") + if token: + self._client = Client(transport, auth=BearerAuth(token)) + else: + self._client = Client(transport) + else: + self._client = Client(transport) + _mcp_clients_cache[self._cache_key] = { + "client": self._client, "created_at": time.time(), } - def _initialize_mcp_connection(self) -> Dict: - """ - Initialize MCP connection with the server, using cached session if available. + def _create_transport(self): + """Create appropriate transport based on configuration.""" + headers = {"Content-Type": "application/json", "User-Agent": "DocsGPT-MCP/1.0"} + headers.update(self.custom_headers) - Returns: - Server capabilities and information - """ - cached_session = self._get_cached_session() - if cached_session: - self._mcp_session_id = cached_session - return {"cached": True} - try: - init_params = { - "protocolVersion": "2024-11-05", - "capabilities": {"roots": {"listChanged": True}, "sampling": {}}, - "clientInfo": {"name": "DocsGPT", "version": "1.0.0"}, - } - response = self._make_mcp_request("initialize", init_params) - self._make_mcp_request("notifications/initialized") - - return response - except Exception as e: - return {"error": str(e), "fallback": True} - - def _ensure_valid_session(self): - """Ensure we have a valid MCP session, reinitializing if needed.""" - if not self._mcp_session_id: - self._initialize_mcp_connection() - - def _make_mcp_request(self, method: str, params: Optional[Dict] = None) -> Dict: - """ - Make an MCP protocol request to the server with automatic session recovery. - - Args: - method: MCP method name (e.g., "tools/list", "tools/call") - params: Parameters for the MCP method - - Returns: - Response data as dictionary - - Raises: - Exception: If request fails after retry - """ - mcp_message = {"jsonrpc": "2.0", "method": method} - - if not method.startswith("notifications/"): - mcp_message["id"] = int(time.time() * 1000000) - if params: - mcp_message["params"] = params - return self._execute_mcp_request(mcp_message, method) - - def _execute_mcp_request( - self, mcp_message: Dict, method: str, is_retry: bool = False - ) -> Dict: - """Execute MCP request with optional retry on session failure.""" - try: - final_headers = self._session.headers.copy() - final_headers.update( - { - "Content-Type": "application/json", - "Accept": "application/json, text/event-stream", - } - ) - - if self._mcp_session_id: - final_headers["Mcp-Session-Id"] = self._mcp_session_id - response = self._session.post( - self.server_url.rstrip("/"), - json=mcp_message, - headers=final_headers, - timeout=self.timeout, - ) - - if "mcp-session-id" in response.headers: - self._mcp_session_id = response.headers["mcp-session-id"] - self._cache_session(self._mcp_session_id) - response.raise_for_status() - - if method.startswith("notifications/"): - return {} - response_text = response.text.strip() - if ( - response.headers.get("content-type", "").startswith("text/event-stream") - or response_text.startswith("event:") - and "data:" in response_text - ): - lines = response_text.split("\n") - data_line = None - for line in lines: - if line.startswith("data:"): - data_line = line[5:].strip() - break - if data_line: - try: - result = json.loads(data_line) - except json.JSONDecodeError: - raise Exception(f"Invalid JSON in SSE data: {data_line}") - else: - raise Exception(f"No data found in SSE response: {response_text}") + if self.auth_type == "api_key": + api_key = self.auth_credentials.get("api_key", "") + header_name = self.auth_credentials.get("api_key_header", "X-API-Key") + if api_key: + headers[header_name] = api_key + elif self.auth_type == "basic": + username = self.auth_credentials.get("username", "") + password = self.auth_credentials.get("password", "") + if username and password: + credentials = base64.b64encode( + f"{username}:{password}".encode() + ).decode() + headers["Authorization"] = f"Basic {credentials}" + if self.transport_type == "auto": + if "sse" in self.server_url.lower() or self.server_url.endswith("/sse"): + transport_type = "sse" else: - try: - result = response.json() - except json.JSONDecodeError: - raise Exception(f"Invalid JSON response: {response.text}") + transport_type = "http" + else: + transport_type = self.transport_type + if transport_type == "sse": + headers.update({"Accept": "text/event-stream", "Cache-Control": "no-cache"}) + return SSETransport(url=self.server_url, headers=headers) + elif transport_type == "http": + return StreamableHttpTransport(url=self.server_url, headers=headers) + elif transport_type == "stdio": + command = self.config.get("command", "python") + args = self.config.get("args", []) + env = self.auth_credentials if self.auth_credentials else None + return StdioTransport(command=command, args=args, env=env) + else: + return StreamableHttpTransport(url=self.server_url, headers=headers) - if "error" in result: - error_msg = result["error"] - if isinstance(error_msg, dict): - error_msg = error_msg.get("message", str(error_msg)) - raise Exception(f"MCP server error: {error_msg}") + async def _execute_with_client(self, operation: str, *args, **kwargs): + """Execute operation with FastMCP client.""" + if not self._client: + raise Exception("FastMCP client not initialized") + async with self._client: + if operation == "ping": + return await self._client.ping() + elif operation == "list_tools": + tools_response = await self._client.list_tools() - return result.get("result", result) + if hasattr(tools_response, "tools"): + tools = tools_response.tools + elif isinstance(tools_response, list): + tools = tools_response + else: + tools = [] + tools_dict = [] + for tool in tools: + if hasattr(tool, "name"): + tool_dict = { + "name": tool.name, + "description": tool.description, + } + if hasattr(tool, "inputSchema"): + tool_dict["inputSchema"] = tool.inputSchema + tools_dict.append(tool_dict) + elif isinstance(tool, dict): + tools_dict.append(tool) + else: - except requests.exceptions.RequestException as e: - if not is_retry and self._should_retry_with_new_session(e): - self._invalidate_and_refresh_session() - return self._execute_mcp_request(mcp_message, method, is_retry=True) - raise Exception(f"MCP server request failed: {str(e)}") + if hasattr(tool, "model_dump"): + tools_dict.append(tool.model_dump()) + else: + tools_dict.append({"name": str(tool), "description": ""}) + return tools_dict + elif operation == "call_tool": + tool_name = args[0] + tool_args = kwargs + return await self._client.call_tool(tool_name, tool_args) + elif operation == "list_resources": + return await self._client.list_resources() + elif operation == "list_prompts": + return await self._client.list_prompts() + else: + raise Exception(f"Unknown operation: {operation}") - def _should_retry_with_new_session(self, error: Exception) -> bool: - """Check if error indicates session invalidation and retry is warranted.""" - error_str = str(error).lower() - return ( - any( - indicator in error_str - for indicator in [ - "invalid session", - "session expired", - "unauthorized", - "401", - "403", - ] - ) - and self._mcp_session_id is not None - ) + def _run_async_operation(self, operation: str, *args, **kwargs): + """Run async operation in sync context.""" + try: + loop = asyncio.get_event_loop() + if loop.is_running(): + import concurrent.futures - def _invalidate_and_refresh_session(self) -> None: - """Invalidate current session and create a new one.""" - global _mcp_session_cache - if self._cache_key in _mcp_session_cache: - del _mcp_session_cache[self._cache_key] - self._mcp_session_id = None - self._initialize_mcp_connection() + def run_in_thread(): + new_loop = asyncio.new_event_loop() + asyncio.set_event_loop(new_loop) + try: + return new_loop.run_until_complete( + self._execute_with_client(operation, *args, **kwargs) + ) + finally: + new_loop.close() + + with concurrent.futures.ThreadPoolExecutor() as executor: + future = executor.submit(run_in_thread) + return future.result(timeout=self.timeout) + else: + return loop.run_until_complete( + self._execute_with_client(operation, *args, **kwargs) + ) + except RuntimeError: + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + try: + return loop.run_until_complete( + self._execute_with_client(operation, *args, **kwargs) + ) + finally: + loop.close() def discover_tools(self) -> List[Dict]: """ - Discover available tools from the MCP server using MCP protocol. + Discover available tools from the MCP server using FastMCP. Returns: List of tool definitions from the server """ + if not self.server_url: + return [] + if not self._client: + self._setup_client() try: - self._ensure_valid_session() - - response = self._make_mcp_request("tools/list") - - # Handle both formats: response with 'tools' key or response that IS the tools list - - if isinstance(response, dict): - if "tools" in response: - self.available_tools = response["tools"] - elif ( - "result" in response - and isinstance(response["result"], dict) - and "tools" in response["result"] - ): - self.available_tools = response["result"]["tools"] - else: - self.available_tools = [response] if response else [] - elif isinstance(response, list): - self.available_tools = response - else: - self.available_tools = [] + tools = self._run_async_operation("list_tools") + self.available_tools = tools return self.available_tools except Exception as e: raise Exception(f"Failed to discover tools from MCP server: {str(e)}") def execute_action(self, action_name: str, **kwargs) -> Any: """ - Execute an action on the remote MCP server using MCP protocol. + Execute an action on the remote MCP server using FastMCP. Args: action_name: Name of the action to execute @@ -288,22 +254,91 @@ class MCPTool(Tool): Returns: Result from the MCP server """ - self._ensure_valid_session() - - # Skipping empty/None values - letting the server use defaults - + if not self.server_url: + raise Exception("No MCP server configured") + if not self._client: + self._setup_client() cleaned_kwargs = {} for key, value in kwargs.items(): if value == "" or value is None: continue cleaned_kwargs[key] = value - call_params = {"name": action_name, "arguments": cleaned_kwargs} try: - result = self._make_mcp_request("tools/call", call_params) - return result + result = self._run_async_operation( + "call_tool", action_name, **cleaned_kwargs + ) + return self._format_result(result) except Exception as e: raise Exception(f"Failed to execute action '{action_name}': {str(e)}") + def _format_result(self, result) -> Dict: + """Format FastMCP result to match expected format.""" + if hasattr(result, "content"): + content_list = [] + for content_item in result.content: + if hasattr(content_item, "text"): + content_list.append({"type": "text", "text": content_item.text}) + elif hasattr(content_item, "data"): + content_list.append({"type": "data", "data": content_item.data}) + else: + content_list.append( + {"type": "unknown", "content": str(content_item)} + ) + return { + "content": content_list, + "isError": getattr(result, "isError", False), + } + else: + return result + + def test_connection(self) -> Dict: + """ + Test the connection to the MCP server and validate functionality. + + Returns: + Dictionary with connection test results including tool count + """ + if not self.server_url: + return { + "success": False, + "message": "No MCP server URL configured", + "tools_count": 0, + "transport_type": self.transport_type, + "auth_type": self.auth_type, + "error_type": "ConfigurationError", + } + if not self._client: + self._setup_client() + try: + try: + self._run_async_operation("ping") + ping_success = True + except Exception: + ping_success = False + tools = self.discover_tools() + + message = f"Successfully connected to MCP server. Found {len(tools)} tools." + if not ping_success: + message += " (Ping not supported, but tool discovery worked)" + return { + "success": True, + "message": message, + "tools_count": len(tools), + "transport_type": self.transport_type, + "auth_type": self.auth_type, + "ping_supported": ping_success, + "tools": [tool.get("name", "unknown") for tool in tools[:5]], + } + except Exception as e: + return { + "success": False, + "message": f"Connection failed: {str(e)}", + "tools_count": 0, + "transport_type": self.transport_type, + "auth_type": self.auth_type, + "error_type": type(e).__name__, + } + def get_actions_metadata(self) -> List[Dict]: """ Get metadata for all available actions. @@ -348,58 +383,76 @@ class MCPTool(Tool): actions.append(action) return actions - def test_connection(self) -> Dict: - """ - Test the connection to the MCP server and validate functionality. - - Returns: - Dictionary with connection test results including tool count - """ - try: - self._mcp_session_id = None - - init_result = self._initialize_mcp_connection() - - tools = self.discover_tools() - - message = f"Successfully connected to MCP server. Found {len(tools)} tools." - if init_result.get("cached"): - message += " (Using cached session)" - elif init_result.get("fallback"): - message += " (No formal initialization required)" - return { - "success": True, - "message": message, - "tools_count": len(tools), - "session_id": self._mcp_session_id, - "tools": [tool.get("name", "unknown") for tool in tools[:5]], - } - except Exception as e: - return { - "success": False, - "message": f"Connection failed: {str(e)}", - "tools_count": 0, - "error_type": type(e).__name__, - } - def get_config_requirements(self) -> Dict: + """Get configuration requirements for the MCP tool.""" return { "server_url": { "type": "string", - "description": "URL of the remote MCP server (e.g., https://api.example.com)", + "description": "URL of the remote MCP server (e.g., https://api.example.com/mcp or https://docs.mcp.cloudflare.com/sse)", "required": True, }, + "transport_type": { + "type": "string", + "description": "Transport type for connection", + "enum": ["auto", "sse", "http", "stdio"], + "default": "auto", + "required": False, + "help": { + "auto": "Automatically detect best transport", + "sse": "Server-Sent Events (for real-time streaming)", + "http": "HTTP streaming (recommended for production)", + "stdio": "Standard I/O (for local servers)", + }, + }, "auth_type": { "type": "string", "description": "Authentication type", - "enum": ["none", "api_key", "bearer", "basic"], + "enum": ["none", "bearer", "oauth", "api_key", "basic"], "default": "none", "required": True, + "help": { + "none": "No authentication", + "bearer": "Bearer token authentication", + "oauth": "OAuth 2.0 authentication", + "api_key": "API key authentication", + "basic": "Basic authentication", + }, }, "auth_credentials": { "type": "object", "description": "Authentication credentials (varies by auth_type)", "required": False, + "properties": { + "bearer_token": { + "type": "string", + "description": "Bearer token for bearer/oauth auth", + }, + "access_token": { + "type": "string", + "description": "Access token for OAuth", + }, + "api_key": { + "type": "string", + "description": "API key for api_key auth", + }, + "api_key_header": { + "type": "string", + "description": "Header name for API key (default: X-API-Key)", + }, + "username": { + "type": "string", + "description": "Username for basic auth", + }, + "password": { + "type": "string", + "description": "Password for basic auth", + }, + }, + }, + "headers": { + "type": "object", + "description": "Custom headers to send with requests", + "required": False, }, "timeout": { "type": "integer", @@ -409,4 +462,15 @@ class MCPTool(Tool): "maximum": 300, "required": False, }, + "command": { + "type": "string", + "description": "Command to run for STDIO transport (e.g., 'python')", + "required": False, + }, + "args": { + "type": "array", + "description": "Arguments for STDIO command", + "items": {"type": "string"}, + "required": False, + }, } diff --git a/application/api/user/routes.py b/application/api/user/routes.py index f0493c7c..293a7c26 100644 --- a/application/api/user/routes.py +++ b/application/api/user/routes.py @@ -494,7 +494,6 @@ class DeleteOldIndexes(Resource): ) if not doc: return make_response(jsonify({"status": "not found"}), 404) - storage = StorageCreator.get_storage() try: @@ -511,7 +510,6 @@ class DeleteOldIndexes(Resource): settings.VECTOR_STORE, source_id=str(doc["_id"]) ) vectorstore.delete_index() - if "file_path" in doc and doc["file_path"]: file_path = doc["file_path"] if storage.is_directory(file_path): @@ -520,7 +518,6 @@ class DeleteOldIndexes(Resource): storage.delete_file(f) else: storage.delete_file(file_path) - except FileNotFoundError: pass except Exception as err: @@ -528,7 +525,6 @@ class DeleteOldIndexes(Resource): f"Error deleting files and indexes: {err}", exc_info=True ) return make_response(jsonify({"success": False}), 400) - sources_collection.delete_one({"_id": ObjectId(source_id)}) return make_response(jsonify({"success": True}), 200) @@ -600,7 +596,6 @@ class UploadFile(Resource): == temp_file_path ): continue - rel_path = os.path.relpath( os.path.join(root, extracted_file), temp_dir ) @@ -625,7 +620,6 @@ class UploadFile(Resource): file_path = f"{base_path}/{safe_file}" with open(temp_file_path, "rb") as f: storage.save_file(f, file_path) - task = ingest.delay( settings.UPLOAD_FOLDER, [ @@ -697,7 +691,6 @@ class ManageSourceFiles(Resource): return make_response( jsonify({"success": False, "message": "Unauthorized"}), 401 ) - user = decoded_token.get("sub") source_id = request.form.get("source_id") operation = request.form.get("operation") @@ -747,7 +740,6 @@ class ManageSourceFiles(Resource): return make_response( jsonify({"success": False, "message": "Database error"}), 500 ) - try: storage = StorageCreator.get_storage() source_file_path = source.get("file_path", "") @@ -804,7 +796,6 @@ class ManageSourceFiles(Resource): ), 200, ) - elif operation == "remove": file_paths_str = request.form.get("file_paths") if not file_paths_str: @@ -858,7 +849,6 @@ class ManageSourceFiles(Resource): ), 200, ) - elif operation == "remove_directory": directory_path = request.form.get("directory_path") if not directory_path: @@ -884,7 +874,6 @@ class ManageSourceFiles(Resource): ), 400, ) - full_directory_path = ( f"{source_file_path}/{directory_path}" if directory_path @@ -943,7 +932,6 @@ class ManageSourceFiles(Resource): ), 200, ) - except Exception as err: error_context = f"operation={operation}, user={user}, source_id={source_id}" if operation == "remove_directory": @@ -955,7 +943,6 @@ class ManageSourceFiles(Resource): elif operation == "add": parent_dir = request.form.get("parent_dir", "") error_context += f", parent_dir={parent_dir}" - current_app.logger.error( f"Error managing source files: {err} ({error_context})", exc_info=True ) @@ -1632,7 +1619,6 @@ class CreateAgent(Resource): ), 400, ) - # Validate that it has either a 'schema' property or is itself a schema if "schema" not in json_schema and "type" not in json_schema: @@ -3476,7 +3462,6 @@ class AvailableTools(Resource): "displayName": name, "description": description, "configRequirements": tool_instance.get_config_requirements(), - "actions": tool_instance.get_actions_metadata(), } ) except Exception as err: @@ -3527,11 +3512,6 @@ class CreateTool(Resource): "customName": fields.String( required=False, description="Custom name for the tool" ), - "actions": fields.List( - fields.Raw, - required=True, - description="Actions the tool can perform", - ), "status": fields.Boolean( required=True, description="Status of the tool" ), @@ -3549,24 +3529,35 @@ class CreateTool(Resource): "name", "displayName", "description", - "actions", "config", "status", ] missing_fields = check_required_fields(data, required_fields) if missing_fields: return missing_fields - transformed_actions = [] - for action in data["actions"]: - action["active"] = True - if "parameters" in action: - if "properties" in action["parameters"]: - for param_name, param_details in action["parameters"][ - "properties" - ].items(): - param_details["filled_by_llm"] = True - param_details["value"] = "" - transformed_actions.append(action) + try: + tool_instance = tool_manager.tools.get(data["name"]) + if not tool_instance: + return make_response( + jsonify({"success": False, "message": "Tool not found"}), 404 + ) + actions_metadata = tool_instance.get_actions_metadata() + transformed_actions = [] + for action in actions_metadata: + action["active"] = True + if "parameters" in action: + if "properties" in action["parameters"]: + for param_name, param_details in action["parameters"][ + "properties" + ].items(): + param_details["filled_by_llm"] = True + param_details["value"] = "" + transformed_actions.append(action) + except Exception as err: + current_app.logger.error( + f"Error getting tool actions: {err}", exc_info=True + ) + return make_response(jsonify({"success": False}), 400) try: new_tool = { "user": user, @@ -3907,7 +3898,6 @@ class GetChunks(Resource): if not (text_match or title_match): continue filtered_chunks.append(chunk) - chunks = filtered_chunks total_chunks = len(chunks) @@ -4098,7 +4088,6 @@ class UpdateChunk(Resource): current_app.logger.warning( f"Failed to delete old chunk {chunk_id}, but new chunk {new_chunk_id} was created" ) - return make_response( jsonify( { @@ -4226,23 +4215,19 @@ class DirectoryStructure(Resource): decoded_token = request.decoded_token if not decoded_token: return make_response(jsonify({"success": False}), 401) - user = decoded_token.get("sub") doc_id = request.args.get("id") if not doc_id: return make_response(jsonify({"error": "Document ID is required"}), 400) - if not ObjectId.is_valid(doc_id): return make_response(jsonify({"error": "Invalid document ID"}), 400) - try: doc = sources_collection.find_one({"_id": ObjectId(doc_id), "user": user}) if not doc: return make_response( jsonify({"error": "Document not found or access denied"}), 404 ) - directory_structure = doc.get("directory_structure", {}) base_path = doc.get("file_path", "") @@ -4315,7 +4300,6 @@ class TestMCPServerConfig(Resource): auth_credentials["username"] = config["username"] if "password" in config: auth_credentials["password"] = config["password"] - test_config = config.copy() test_config["auth_credentials"] = auth_credentials @@ -4395,14 +4379,12 @@ class MCPServerSave(Resource): raise Exception( "No valid credentials provided for the selected authentication type" ) - storage_config = config.copy() if auth_credentials: encrypted_credentials_string = encrypt_credentials( auth_credentials, user ) storage_config["encrypted_credentials"] = encrypted_credentials_string - for field in [ "api_key", "bearer_token",