✨ Adapt MCP protocal to different program language #416

[Specification Details] 1. Add a basic image for starting the mcp service
2. Implementation of the app and service for containerized startup of mcp services
3. Test case modification

Author: YehongPan

backend/apps/remote_mcp_app.py

@@ -5,14 +5,17 @@
 from fastapi.responses import JSONResponse
 from http import HTTPStatus
 
-from consts.exceptions import MCPConnectionError, MCPNameIllegal
+from consts.const import MCP_DOCKER_IMAGE
+from consts.exceptions import MCPConnectionError, MCPNameIllegal, MCPContainerError
+from consts.model import MCPConfigRequest
 from services.remote_mcp_service import (
     add_remote_mcp_server_list,
     delete_remote_mcp_server_list,
     get_remote_mcp_server_list,
     check_mcp_health_and_update_db,
 )
 from services.tool_configuration_service import get_tool_from_remote_mcp_server
+from services.mcp_container_service import MCPContainerManager
 from utils.auth_utils import get_current_user_id
 
 router = APIRouter(prefix="/mcp")
@@ -138,3 +141,254 @@ async def check_mcp_health(mcp_url: str, service_name: str, authorization: Optio
         logger.error(f"Failed to check the health of the MCP server: {e}")
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
                             detail="Failed to check the health of the MCP server")
+
+
+@router.post("/add-from-config")
+async def add_mcp_from_config(
+    mcp_config: MCPConfigRequest,
+    authorization: Optional[str] = Header(None)
+):
+    """
+    Add MCP server by starting a container with command+args config.
+    Similar to Cursor's MCP server configuration format.
+    
+    Example request:
+    {
+        "mcpServers": {
+            "12306-mcp": {
+                "command": "npx",
+                "args": ["-y", "12306-mcp"],
+                "env": {"NODE_ENV": "production"}
+            }
+        }
+    }
+    """
+    try:
+        user_id, tenant_id = get_current_user_id(authorization)
+        
+        # Initialize container manager
+        try:
+            container_manager = MCPContainerManager()
+        except MCPContainerError as e:
+            logger.error(f"Failed to initialize container manager: {e}")
+            raise HTTPException(
+                status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                detail="Docker service unavailable. Please ensure Docker socket is mounted."
+            )
+        
+        results = []
+        errors = []
+        
+        for service_name, config in mcp_config.mcpServers.items():
+            try:
+                command = config.command
+                args = config.args or []
+                env_vars = config.env or {}
+                port = config.port
+                
+                if not command:
+                    errors.append(f"{service_name}: command is required")
+                    continue
+                
+                if port is None:
+                    errors.append(f"{service_name}: port is required")
+                    continue
+
+                # Build full command to run inside nexent/nexent-mcp image
+                full_command = [
+                    "python",
+                    "-m",
+                    "mcp_proxy",
+                    "--host",
+                    "0.0.0.0",
+                    "--port",
+                    str(port),
+                    "--transport",
+                    "streamablehttp",
+                    "--",
+                    command,
+                    *args,
+                ]
+
+                # Start container
+                container_info = await container_manager.start_mcp_container(
+                    service_name=service_name,
+                    tenant_id=tenant_id,
+                    user_id=user_id,
+                    env_vars=env_vars,
+                    host_port=port,
+                    image=config.image or MCP_DOCKER_IMAGE,
+                    full_command=full_command,
+                )
+                
+                # Register to remote MCP server list
+                try:
+                    await add_remote_mcp_server_list(
+                        tenant_id=tenant_id,
+                        user_id=user_id,
+                        remote_mcp_server=container_info["mcp_url"],
+                        remote_mcp_server_name=service_name
+                    )
+                except MCPNameIllegal:
+                    # If name already exists, try to stop the container we just created
+                    try:
+                        await container_manager.stop_mcp_container(container_info["container_id"])
+                    except Exception:
+                        pass
+                    errors.append(f"{service_name}: MCP name already exists")
+                    continue
+                
+                results.append({
+                    "service_name": service_name,
+                    "status": "success",
+                    "mcp_url": container_info["mcp_url"],
+                    "container_id": container_info["container_id"],
+                    "container_name": container_info.get("container_name"),
+                    "host_port": container_info.get("host_port")
+                })
+                
+            except MCPContainerError as e:
+                logger.error(f"Failed to start MCP container {service_name}: {e}")
+                errors.append(f"{service_name}: {str(e)}")
+            except Exception as e:
+                logger.error(f"Unexpected error adding MCP {service_name}: {e}")
+                errors.append(f"{service_name}: {str(e)}")
+        
+        if errors and not results:
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST,
+                detail=f"All MCP servers failed: {errors}"
+            )
+        
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content={
+                "message": "MCP servers processed",
+                "results": results,
+                "errors": errors if errors else None,
+                "status": "success"
+            }
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to add MCP from config: {e}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Failed to add MCP servers: {str(e)}"
+        )
+
+
+@router.delete("/container/{container_id}")
+async def stop_mcp_container(
+    container_id: str,
+    authorization: Optional[str] = Header(None)
+):
+    """ Stop and remove MCP container """
+    try:
+        user_id, tenant_id = get_current_user_id(authorization)
+        
+        try:
+            container_manager = MCPContainerManager()
+        except MCPContainerError as e:
+            logger.error(f"Failed to initialize container manager: {e}")
+            raise HTTPException(
+                status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                detail="Docker service unavailable"
+            )
+        
+        success = await container_manager.stop_mcp_container(container_id)
+        
+        if success:
+            return JSONResponse(
+                status_code=HTTPStatus.OK,
+                content={"message": "Container stopped successfully", "status": "success"}
+            )
+        else:
+            return JSONResponse(
+                status_code=HTTPStatus.NOT_FOUND,
+                content={"message": "Container not found", "status": "error"}
+            )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to stop container: {e}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Failed to stop container: {str(e)}"
+        )
+
+
+@router.get("/containers")
+async def list_mcp_containers(
+    authorization: Optional[str] = Header(None)
+):
+    """ List all MCP containers for the current tenant """
+    try:
+        user_id, tenant_id = get_current_user_id(authorization)
+        
+        try:
+            container_manager = MCPContainerManager()
+        except MCPContainerError as e:
+            logger.error(f"Failed to initialize container manager: {e}")
+            raise HTTPException(
+                status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                detail="Docker service unavailable"
+            )
+        
+        containers = container_manager.list_mcp_containers(tenant_id=tenant_id)
+        
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content={
+                "containers": containers,
+                "status": "success"
+            }
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to list containers: {e}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Failed to list containers: {str(e)}"
+        )
+
+
+@router.get("/container/{container_id}/logs")
+async def get_container_logs(
+    container_id: str,
+    tail: int = 100,
+    authorization: Optional[str] = Header(None)
+):
+    """ Get logs from MCP container """
+    try:
+        user_id, tenant_id = get_current_user_id(authorization)
+        
+        try:
+            container_manager = MCPContainerManager()
+        except MCPContainerError as e:
+            logger.error(f"Failed to initialize container manager: {e}")
+            raise HTTPException(
+                status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                detail="Docker service unavailable"
+            )
+        
+        logs = container_manager.get_container_logs(container_id, tail=tail)
+        
+        return JSONResponse(
+            status_code=HTTPStatus.OK,
+            content={
+                "logs": logs,
+                "status": "success"
+            }
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get container logs: {e}")
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get container logs: {str(e)}"
+        )

backend/consts/const.py

@@ -130,6 +130,7 @@ class VectorDatabaseType(str, Enum):
     "DISABLE_CELERY_FLOWER", "false").lower() == "true"
 DOCKER_ENVIRONMENT = os.getenv("DOCKER_ENVIRONMENT", "false").lower() == "true"
 DOCKER_HOST = os.getenv("DOCKER_HOST")
+MCP_DOCKER_IMAGE = os.getenv("MCP_DOCKER_IMAGE", "nexent/nexent-mcp:latest")
 
 
 # Celery Configuration

backend/consts/exceptions.py

@@ -90,4 +90,9 @@ class VoiceConfigException(Exception):
 
 class ToolExecutionException(Exception):
     """Raised when mcp tool execution failed."""
+    pass
+
+
+class MCPContainerError(Exception):
+    """Raised when MCP container operation fails."""
     pass

backend/consts/model.py

@@ -429,3 +429,23 @@ class ToolValidateRequest(BaseModel):
         None, description="Tool inputs")
     params: Optional[Dict[str, Any]] = Field(
         None, description="Tool configuration parameters")
+
+
+class MCPServerConfig(BaseModel):
+    """Configuration for a single MCP server"""
+    command: str = Field(..., description="Command to run (e.g., 'npx')")
+    args: List[str] = Field(default_factory=list, description="Command arguments")
+    env: Optional[Dict[str, str]] = Field(
+        None, description="Environment variables for the MCP server")
+    port: Optional[int] = Field(
+        None, description="Host port to expose the MCP server on (e.g., 5020)")
+    image: Optional[str] = Field(
+        None,
+        description="Docker image for the MCP proxy container (optional, overrides MCP_DOCKER_IMAGE)",
+    )
+
+
+class MCPConfigRequest(BaseModel):
+    """Request model for adding MCP servers from configuration"""
+    mcpServers: Dict[str, MCPServerConfig] = Field(
+        ..., description="Dictionary of MCP server configurations")