✨ Adapt MCP protocal to different program language #416

[Specification Details] 1.Front-end modifications have been made, with the addition of a module for containerized MCP services and a container display and management module.
2.A new "container_id" field has been added in mcp_record_t to identify whether the mcp service is containerized and what the corresponding container id is.
3.The deployment pipeline has been modified, and a new MCP startup image has been added.

Author: YehongPan

.github/workflows/auto-build-mcp-dev.yml

@@ -0,0 +1,43 @@
+name: Docker Build MCP Images
+
+concurrency:
+  group: docker-build-mcp-dev-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [develop]
+    paths:
+      - 'backend/**'
+      - 'sdk/**'
+      - 'make/mcp/**'
+      - '.github/workflows/**'
+  push:
+    branches: [develop]
+    paths:
+      - 'backend/**'
+      - 'sdk/**'
+      - 'make/mcp/**'
+      - '.github/workflows/**'
+
+jobs:
+  build-mcp-amd64:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build MCP image (amd64) and load locally
+        run: |
+          docker build --platform linux/amd64 -t nexent/nexent-mcp:dev-amd64 -f make/mcp/Dockerfile .
+
+  build-mcp-arm64:
+    runs-on: ubuntu-24.04-arm
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build MCP image (arm64) and load locally
+        run: |
+          docker build --platform linux/arm64 -t nexent/nexent-mcp:dev-arm64 -f make/mcp/Dockerfile .
+
+

.github/workflows/docker-build-push-mainland.yml

@@ -244,6 +244,58 @@ jobs:
         if: inputs.push_latest == 'true'
         run: docker push ccr.ccs.tencentyun.com/nexent-hub/nexent-ubuntu-terminal:arm64
 
+  build-and-push-mcp-amd64:
+    runs-on: ${{ fromJson(inputs.runner_label_json) }}
+    steps:
+      - name: Set up Docker Buildx
+        run: |
+          if ! docker buildx inspect nexent_builder > /dev/null 2>&1; then
+            docker buildx create --name nexent_builder --use
+          else
+            docker buildx use nexent_builder
+          fi
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build MCP image (amd64) and load locally
+        run: |
+          docker buildx build --platform linux/amd64 --load -t ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-amd64 -f make/mcp/Dockerfile --build-arg MIRROR=https://pypi.tuna.tsinghua.edu.cn/simple --build-arg APT_MIRROR=tsinghua .
+      - name: Login to Tencent Cloud
+        run: echo ${{ secrets.TCR_PASSWORD }} | docker login ccr.ccs.tencentyun.com --username=${{ secrets.TCR_USERNAME }} --password-stdin
+      - name: Push MCP image (amd64) to Tencent Cloud
+        run: docker push ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-amd64
+      - name: Tag MCP image (amd64) as latest
+        if: inputs.push_latest == 'true'
+        run: docker tag ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-amd64 ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:amd64
+      - name: Push latest MCP image (amd64) to Tencent Cloud
+        if: inputs.push_latest == 'true'
+        run: docker push ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:amd64
+
+  build-and-push-mcp-arm64:
+    runs-on: ${{ fromJson(inputs.runner_label_json) }}
+    steps:
+      - name: Set up Docker Buildx
+        run: |
+          if ! docker buildx inspect nexent_builder > /dev/null 2>&1; then
+            docker buildx create --name nexent_builder --use
+          else
+            docker buildx use nexent_builder
+          fi
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build MCP image (arm64) and load locally
+        run: |
+          docker buildx build --platform linux/arm64 --load -t ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-arm64 -f make/mcp/Dockerfile --build-arg MIRROR=https://pypi.tuna.tsinghua.edu.cn/simple --build-arg APT_MIRROR=tsinghua .
+      - name: Login to Tencent Cloud
+        run: echo ${{ secrets.TCR_PASSWORD }} | docker login ccr.ccs.tencentyun.com --username=${{ secrets.TCR_USERNAME }} --password-stdin
+      - name: Push MCP image (arm64) to Tencent Cloud
+        run: docker push ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-arm64
+      - name: Tag MCP image (arm64) as latest
+        if: inputs.push_latest == 'true'
+        run: docker tag ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-arm64 ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:arm64
+      - name: Push latest MCP image (arm64) to Tencent Cloud
+        if: inputs.push_latest == 'true'
+        run: docker push ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:arm64
+
   manifest-push-main:
     runs-on: ubuntu-latest
     needs:
@@ -330,4 +382,26 @@ jobs:
           docker manifest create ccr.ccs.tencentyun.com/nexent-hub/nexent-ubuntu-terminal:latest \
             ccr.ccs.tencentyun.com/nexent-hub/nexent-ubuntu-terminal:amd64 \
             ccr.ccs.tencentyun.com/nexent-hub/nexent-ubuntu-terminal:arm64
-          docker manifest push ccr.ccs.tencentyun.com/nexent-hub/nexent-ubuntu-terminal:latest
+          docker manifest push ccr.ccs.tencentyun.com/nexent-hub/nexent-ubuntu-terminal:latest
+
+  manifest-push-mcp:
+    runs-on: ubuntu-latest
+    needs:
+      - build-and-push-mcp-amd64
+      - build-and-push-mcp-arm64
+    steps:
+      - name: Login to Tencent Cloud
+        run: echo ${{ secrets.TCR_PASSWORD }} | docker login ccr.ccs.tencentyun.com --username=${{ secrets.TCR_USERNAME }} --password-stdin
+      - name: Create and push manifest for mcp (Tencent Cloud)
+        run: |
+          docker manifest create ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }} \
+            ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-amd64 \
+            ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}-arm64
+          docker manifest push ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:${{ inputs.version }}
+      - name: Create and push latest manifest for mcp (Tencent Cloud)
+        if: inputs.push_latest == 'true'
+        run: |
+          docker manifest create ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:latest \
+            ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:amd64 \
+            ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:arm64
+          docker manifest push ccr.ccs.tencentyun.com/nexent-hub/nexent-mcp:latest

.github/workflows/docker-build-push-overseas.yml

@@ -244,6 +244,58 @@ jobs:
         if: inputs.push_latest == 'true'
         run: docker push nexent/nexent-ubuntu-terminal:arm64
 
+  build-and-push-mcp-amd64:
+    runs-on: ${{ fromJson(inputs.runner_label_json) }}
+    steps:
+      - name: Set up Docker Buildx
+        run: |
+          if ! docker buildx inspect nexent_builder > /dev/null 2>&1; then
+            docker buildx create --name nexent_builder --use
+          else
+            docker buildx use nexent_builder
+          fi
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build MCP image (amd64) and load locally
+        run: |
+          docker buildx build --platform linux/amd64 -t nexent/nexent-mcp:${{ inputs.version }}-amd64 --load -f make/mcp/Dockerfile .
+      - name: Login to DockerHub
+        run: echo ${{ secrets.DOCKERHUB_TOKEN }} | docker login -u nexent --password-stdin
+      - name: Push MCP image (amd64) to DockerHub
+        run: docker push nexent/nexent-mcp:${{ inputs.version }}-amd64
+      - name: Tag MCP image (amd64) as latest
+        if: inputs.push_latest == 'true'
+        run: docker tag nexent/nexent-mcp:${{ inputs.version }}-amd64 nexent/nexent-mcp:amd64
+      - name: Push latest MCP image (amd64) to DockerHub
+        if: inputs.push_latest == 'true'
+        run: docker push nexent/nexent-mcp:amd64
+
+  build-and-push-mcp-arm64:
+    runs-on: ${{ fromJson(inputs.runner_label_json) }}
+    steps:
+      - name: Set up Docker Buildx
+        run: |
+          if ! docker buildx inspect nexent_builder > /dev/null 2>&1; then
+            docker buildx create --name nexent_builder --use
+          else
+            docker buildx use nexent_builder
+          fi
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build MCP image (arm64) and load locally
+        run: |
+          docker buildx build --platform linux/arm64 -t nexent/nexent-mcp:${{ inputs.version }}-arm64 --load -f make/mcp/Dockerfile .
+      - name: Login to DockerHub
+        run: echo ${{ secrets.DOCKERHUB_TOKEN }} | docker login -u nexent --password-stdin
+      - name: Push MCP image (arm64) to DockerHub
+        run: docker push nexent/nexent-mcp:${{ inputs.version }}-arm64
+      - name: Tag MCP image (arm64) as latest
+        if: inputs.push_latest == 'true'
+        run: docker tag nexent/nexent-mcp:${{ inputs.version }}-arm64 nexent/nexent-mcp:arm64
+      - name: Push latest MCP image (arm64) to DockerHub
+        if: inputs.push_latest == 'true'
+        run: docker push nexent/nexent-mcp:arm64
+
   manifest-push-main:
     runs-on: ubuntu-latest
     needs:
@@ -330,4 +382,26 @@ jobs:
           docker manifest create nexent/nexent-ubuntu-terminal:latest \
             nexent/nexent-ubuntu-terminal:amd64 \
             nexent/nexent-ubuntu-terminal:arm64
-          docker manifest push nexent/nexent-ubuntu-terminal:latest
+          docker manifest push nexent/nexent-ubuntu-terminal:latest
+
+  manifest-push-mcp:
+    runs-on: ubuntu-latest
+    needs:
+      - build-and-push-mcp-amd64
+      - build-and-push-mcp-arm64
+    steps:
+      - name: Login to DockerHub
+        run: echo ${{ secrets.DOCKERHUB_TOKEN }} | docker login -u nexent --password-stdin
+      - name: Create and push manifest for mcp (DockerHub)
+        run: |
+          docker manifest create nexent/nexent-mcp:${{ inputs.version }} \
+            nexent/nexent-mcp:${{ inputs.version }}-amd64 \
+            nexent/nexent-mcp:${{ inputs.version }}-arm64
+          docker manifest push nexent/nexent-mcp:${{ inputs.version }}
+      - name: Create and push latest manifest for mcp (DockerHub)
+        if: inputs.push_latest == 'true'
+        run: |
+          docker manifest create nexent/nexent-mcp:latest \
+            nexent/nexent-mcp:amd64 \
+            nexent/nexent-mcp:arm64
+          docker manifest push nexent/nexent-mcp:latest

backend/apps/remote_mcp_app.py

@@ -13,6 +13,7 @@
     delete_remote_mcp_server_list,
     get_remote_mcp_server_list,
     check_mcp_health_and_update_db,
+    delete_mcp_by_container_id,
 )
 from services.tool_configuration_service import get_tool_from_remote_mcp_server
 from services.mcp_container_service import MCPContainerManager
@@ -58,7 +59,8 @@ async def add_remote_proxies(
         await add_remote_mcp_server_list(tenant_id=tenant_id,
                                          user_id=user_id,
                                          remote_mcp_server=mcp_url,
-                                         remote_mcp_server_name=service_name)
+                                         remote_mcp_server_name=service_name,
+                                         container_id=None)
         return JSONResponse(
             status_code=HTTPStatus.OK,
             content={"message": "Successfully added remote MCP proxy",
@@ -227,7 +229,8 @@ async def add_mcp_from_config(
                         tenant_id=tenant_id,
                         user_id=user_id,
                         remote_mcp_server=container_info["mcp_url"],
-                        remote_mcp_server_name=service_name
+                        remote_mcp_server_name=service_name,
+                        container_id=container_info["container_id"],
                     )
                 except MCPNameIllegal:
                     # If name already exists, try to stop the container we just created
@@ -297,18 +300,27 @@ async def stop_mcp_container(
                 status_code=HTTPStatus.SERVICE_UNAVAILABLE,
                 detail="Docker service unavailable"
             )
-        
+
         success = await container_manager.stop_mcp_container(container_id)
-        
+
         if success:
+            # Soft delete the corresponding MCP record (if any) by container ID
+            await delete_mcp_by_container_id(
+                tenant_id=tenant_id,
+                user_id=user_id,
+                container_id=container_id,
+            )
             return JSONResponse(
                 status_code=HTTPStatus.OK,
-                content={"message": "Container stopped successfully", "status": "success"}
+                content={
+                    "message": "Container and MCP service stopped successfully",
+                    "status": "success",
+                },
             )
         else:
             return JSONResponse(
                 status_code=HTTPStatus.NOT_FOUND,
-                content={"message": "Container not found", "status": "error"}
+                content={"message": "Container not found", "status": "error"},
             )
     except HTTPException:
         raise

backend/database/db_models.py

@@ -300,8 +300,15 @@ class McpRecord(TableBase):
     user_id = Column(String(100), doc="User ID")
     mcp_name = Column(String(100), doc="MCP name")
     mcp_server = Column(String(500), doc="MCP server address")
-    status = Column(Boolean, default=None,
-                    doc="MCP server connection status, True=connected, False=disconnected, None=unknown")
+    status = Column(
+        Boolean,
+        default=None,
+        doc="MCP server connection status, True=connected, False=disconnected, None=unknown",
+    )
+    container_id = Column(
+        String(200),
+        doc="Docker container ID for MCP service, None for non-containerized MCP",
+    )
 
 
 class UserTenant(TableBase):

backend/database/remote_mcp_db.py

@@ -46,6 +46,22 @@ def delete_mcp_record_by_name_and_url(mcp_name: str, mcp_server: str, tenant_id:
         ).update({"delete_flag": "Y", "updated_by": user_id})
 
 
+def delete_mcp_record_by_container_id(container_id: str, tenant_id: str, user_id: str):
+    """
+    Soft delete MCP record by container ID
+
+    :param container_id: Docker container ID
+    :param tenant_id: Tenant ID
+    :param user_id: User ID
+    """
+    with get_db_session() as session:
+        session.query(McpRecord).filter(
+            McpRecord.container_id == container_id,
+            McpRecord.tenant_id == tenant_id,
+            McpRecord.delete_flag != 'Y'
+        ).update({"delete_flag": "Y", "updated_by": user_id})
+
+
 def update_mcp_status_by_name_and_url(mcp_name: str, mcp_server: str, tenant_id: str, user_id: str, status: bool):
     """
     Update the status of MCP record by name and URL

backend/services/remote_mcp_service.py

@@ -6,9 +6,10 @@
 from database.remote_mcp_db import (
     create_mcp_record,
     delete_mcp_record_by_name_and_url,
+    delete_mcp_record_by_container_id,
     get_mcp_records_by_tenant,
     check_mcp_name_exists,
-    update_mcp_status_by_name_and_url
+    update_mcp_status_by_name_and_url,
 )
 
 logger = logging.getLogger("remote_mcp_service")
@@ -26,10 +27,13 @@ async def mcp_server_health(remote_mcp_server: str) -> bool:
         raise MCPConnectionError("MCP connection failed")
 
 
-async def add_remote_mcp_server_list(tenant_id: str,
-                                     user_id: str,
-                                     remote_mcp_server: str,
-                                     remote_mcp_server_name: str):
+async def add_remote_mcp_server_list(
+    tenant_id: str,
+    user_id: str,
+    remote_mcp_server: str,
+    remote_mcp_server_name: str,
+    container_id: str | None = None,
+):
 
     # check if MCP name already exists
     if check_mcp_name_exists(mcp_name=remote_mcp_server_name, tenant_id=tenant_id):
@@ -42,11 +46,13 @@ async def add_remote_mcp_server_list(tenant_id: str,
         raise MCPConnectionError("MCP connection failed")
 
     # update the PG database record
-    insert_mcp_data = {"mcp_name": remote_mcp_server_name,
-                       "mcp_server": remote_mcp_server,
-                       "status": True}
-    create_mcp_record(
-        mcp_data=insert_mcp_data, tenant_id=tenant_id, user_id=user_id)
+    insert_mcp_data = {
+        "mcp_name": remote_mcp_server_name,
+        "mcp_server": remote_mcp_server,
+        "status": True,
+        "container_id": container_id,
+    }
+    create_mcp_record(mcp_data=insert_mcp_data, tenant_id=tenant_id, user_id=user_id)
 
 
 async def delete_remote_mcp_server_list(tenant_id: str,
@@ -88,3 +94,17 @@ async def check_mcp_health_and_update_db(mcp_url, service_name, tenant_id, user_
         status=status)
     if not status:
         raise MCPConnectionError("MCP connection failed")
+
+
+async def delete_mcp_by_container_id(tenant_id: str, user_id: str, container_id: str):
+    """
+    Soft delete MCP record associated with a specific container ID.
+
+    This is used when stopping a containerized MCP so that the MCP record and
+    its container are removed together.
+    """
+    delete_mcp_record_by_container_id(
+        container_id=container_id,
+        tenant_id=tenant_id,
+        user_id=user_id,
+    )

docker/sql/v1.7.8_1219_add_container_id_to_mcp_record_t.sql

@@ -0,0 +1,6 @@
+ALTER TABLE nexent.mcp_record_t
+ADD COLUMN IF NOT EXISTS container_id VARCHAR(200);
+
+COMMENT ON COLUMN nexent.mcp_record_t.container_id IS 'Docker container ID for MCP service, NULL for non-containerized MCP';
+
+