From Developer Laptops to Isolated Containers — Enterprise MCP Infrastructure with MCPNest

        raise HTTPException(status_code=503, detail="Bridge not initialized")
    
    payload = {"jsonrpc": "2.0", "id": 2, "method": "tools/list"}
    await self.process.stdin.write((json.dumps(payload) + "\n").encode())
    await self.process.stdin.drain()
    
    result = await self._read_response()
    return result.get("result", [])

async def call_tool(self, req: ToolCallRequest) -> Dict:
    if not self.initialized:
        raise HTTPException(status_code=503, detail="Bridge not initialized")
    
    payload = {
        "jsonrpc": "2.0",
        "id": 3,
        "method": "tools/call",
        "params": {"name": req.tool, "arguments": req.arguments}
    }
    await self.process.stdin.write((json.dumps(payload) + "\n").encode())
    await self.process.stdin.drain()
    
    return await self._read_response()

async def _read_response(self) -> Dict | None:
    """Read JSON-RPC response from stdout."""
    try:
        line = await asyncio.wait_for(self.process.stdout.readline(), timeout=10.0)
        if not line:
            return None
        return json.loads(line.decode().strip())
    except asyncio.TimeoutError:
        return None

**2. The Orchestrator: Secure Container Management**

The Orchestrator is responsible for provisioning containers with strict security constraints. It must ensure that containers run with minimal privileges, are isolated from the host network, and have resource limits enforced.

Key security measures include dropping all Linux capabilities, preventing privilege escalation, running as a non-root user, and attaching containers to a dedicated Docker network.

```python
import docker
from docker.types import Resources, Ulimit

class ContainerOrchestrator:
    def __init__(self, docker_client: docker.DockerClient):
        self.client = docker_client
        self.network_name = "mcp_isolated_net"

    def _ensure_image(self, image_name: str):
        """Optimization: Skip pull if image exists locally."""
        try:
            self.client.images.get(image_name)
            return True
        except docker.errors.ImageNotFound:
            self.client.images.pull(image_name)
            return False

    def deploy_bridge(self, image: str, mcp_command: str, env_vars: Dict[str, str]) -> str:
        """Deploy a hardened MCP Bridge container."""
        self._ensure_image(image)
        
        security_opts = {
            "cap_drop": ["ALL"],
            "no_new_privileges": True,
            "user": "bridge"
        }
        
        resource_limits = Resources(
            cpu_shares=512,
            mem_limit="512m",
            memswap_limit="512m"
        )
        
        container = self.client.containers.run(
            image=image,
            detach=True,
            name=f"mcp-bridge-{uuid.uuid4().hex[:8]}",
            environment={
                "MCP_COMMAND": mcp_command,
                **env_vars
            },
            security_opt=security_opts,
            resources=resource_limits,
            network=self.network_name,
            restart_policy={"Name": "no"}
        )
        
        return container.id

3. Credential Management and Validation

Credentials must never be stored in the database or logged. The system uses a declarative approach where each allowed MCP server defines its required environment variables. Before deployment, the frontend collects these values via a secure modal and passes them directly to the Orchestrator in the deployment request. The Orchestrator injects them as environment variables into the container. Once deployed, the credentials are inaccessible to developers and are excluded from all log outputs.

4. Audit and Access Control

The Gateway layer intercepts all requests. It validates the user's bearer token, verifies that the requested tool is in the allowlist for that user's role, and logs the invocation. Logs include the member ID, server slug, tool name, latency, and HTTP status. Inputs and outputs are not stored to maintain data privacy and reduce storage costs. This design ensures GDPR compliance while providing a complete audit trail for security reviews.

Pitfall Guide

Implementing enterprise MCP infrastructure introduces specific technical challenges. The following pitfalls are common in production environments and include mitigation strategies.

Production Bundle

Action Checklist

• Define Server Catalog: Create a registry of approved MCP servers with their required environment variables and resource profiles.
• Configure Gateway Auth: Implement bearer token validation and role-based allowlists in the Gateway layer.
• Set Up Orchestrator: Deploy the Orchestrator service with Docker access and configure the isolated network.
• Build Bridge Image: Create a Docker image with pre-installed MCP server packages and the Bridge application.
• Implement Credential Flow: Develop the UI modal for credential collection and ensure secure transmission to the Orchestrator.
• Enable Audit Logging: Configure the Gateway to log all tool invocations with member, tool, and latency metadata.
• Test Security Constraints: Verify that containers cannot access the host network, escalate privileges, or leak credentials.
• Plan Offboarding: Document the process for revoking user tokens and cleaning up associated containers.

Decision Matrix

Configuration Template

The following Docker Compose configuration demonstrates a self-hosted Bridge node with security hardening. This template can be adapted for use in a Kubernetes deployment or as part of a larger orchestration stack.

version: '3.8'

services:
  mcp-bridge:
    image: mcp-bridge:latest
    environment:
      - MCP_COMMAND=npx -y @modelcontextprotocol/server-filesystem /workspace
      - GITHUB_TOKEN=${GITHUB_TOKEN}
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    user: "bridge"
    networks:
      - mcp_isolated
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M
    restart: "no"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

networks:
  mcp_isolated:
    driver: bridge
    internal: true

Quick Start Guide

1. Deploy the Orchestrator: Provision a server with Docker installed and run the Orchestrator service. Configure it to connect to your Docker socket and set up the isolated network.
2. Configure the Gateway: Deploy the Gateway service and configure it with your authentication provider. Define the allowlists for your team members.
3. Create the Bridge Image: Build the Bridge Docker image with the required MCP server packages. Tag and load the image onto the Orchestrator host.
4. Define a Server: Add an entry to your server catalog with the command and required environment variables.
5. Deploy and Test: Use the dashboard to deploy a Bridge container. Verify that the container starts, the health check passes, and the Gateway can proxy requests to the tool.