Docker MCP Server Configuration Guide

docker info

{
  "mcpServers": {
    "docker": {
      "command": "node",
      "args": ["/opt/mcp-servers/docker/dist/index.js"],
      "env": {
        "DOCKER_SOCKET_PATH": "/var/run/docker.sock",
        "MAX_LOG_TAIL_LINES": "100"
      }
    }
  }
}

{
  "mcpServers": {
    "docker": {
      "command": "node",
      "args": ["./dist/index.js"]
    }
  }
}

[mcp_servers.docker]
command = "node"
args = ["/opt/mcp-servers/docker/dist/index.js"]

[mcp_servers.docker.env]
DOCKER_SOCKET_PATH = "/var/run/docker.sock"
MAX_LOG_TAIL_LINES = "100"

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import Docker from 'dockerode';

const isWindows = process.platform === 'win32';
const socketPath = process.env.DOCKER_SOCKET_PATH || (isWindows ? '//./pipe/docker_engine' : '/var/run/docker.sock');

const docker = new Docker({ socketPath });

const server = new Server(
  { name: 'docker-mcp-server', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'list_containers',
        description: 'List active and stopped Docker containers with their status, image, and exposed ports.',
        inputSchema: {
          type: 'object',
          properties: {
            all: { type: 'boolean', default: false, description: 'Include stopped containers' }
          }
        }
      },
      {
        name: 'get_container_logs',
        description: 'Retrieve the most recent stdout and stderr logs from a container.',
        inputSchema: {
          type: 'object',
          properties: {
            container_id: { type: 'string', description: 'Container ID or name' },
            tail_lines: { type: 'number', default: 50, maximum: 100, description: 'Number of lines to tail' }
          },
          required: ['container_id']
        }
      },
      {
        name: 'get_container_stats',
        description: 'Retrieve a snapshot of container CPU and memory usage statistics.',
        inputSchema: {
          type: 'object',
          properties: {
            container_id: { type: 'string', description: 'Container ID or name' }
          },
          required: ['container_id']
        }
      }
    ]
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    if (name === 'list_containers') {
      const showAll = Boolean(args?.all);
      const containers = await docker.listContainers({ all: showAll });

      const simplified = containers.map(c => ({
        id: c.Id.slice(0, 12),
        names: c.Names,
        image: c.Image,
        state: c.State,
        status: c.Status,
        ports: c.Ports.map(p => `${p.PublicPort || ''}:${p.PrivatePort}`).filter(Boolean)
      }));

      return {
        content: [{ type: 'text', text: JSON.stringify(simplified, null, 2) }]
      };
    }

    if (name === 'get_container_logs') {
      const containerId = args?.container_id as string;
      const tail = Math.min(Number(args?.tail_lines) || 50, 100);

      const container = docker.getContainer(containerId);
      const logsBuffer = await container.logs({
        stdout: true,
        stderr: true,
        tail: tail,
        timestamps: true
      });

      // Strip Docker multiplexed stream headers
      const cleanLogs = logsBuffer.toString('utf8').replace(/[\x00-\x09\x0B-\x1F]/g, '');

      return {
        content: [{ type: 'text', text: cleanLogs }]
      };
    }

    if (name === 'get_container_stats') {
      const containerId = args?.container_id as string;
      const container = docker.getContainer(containerId);
      const stats = await container.stats({ stream: false });

      const memoryUsageMB = (stats.memory_stats.usage / (1024 * 1024)).toFixed(2);
      const memoryLimitMB = (stats.memory_stats.limit / (1024 * 1024)).toFixed(2);

      const result = {
        container_id: containerId,
        memory_usage_mb: memoryUsageMB,
        memory_limit_mb: memoryLimitMB,
        pids: stats.pids_stats.current || 0
      };

      return {
        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
      };
    }

    throw new Error(`Tool '${name}' is not recognized.`);
  } catch (err: any) {
    return {
      isError: true,
      content: [{ type: 'text', text: `Docker API Error: ${err.message}` }]
    };
  }
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch((err) => {
  process.stderr.write(`Fatal server error: ${err.message}\n`);
  process.exit(1);
});

{
  "jsonrpc": "2.0",
  "id": "docker-list-01",
  "method": "tools/call",
  "params": {
    "name": "list_containers",
    "arguments": {
      "all": false
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": "docker-list-01",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "[\n  {\"id\": \"e4a19b88c2f1\", \"names\": [\"/redis-cache\"], \"image\": \"redis:7-alpine\", \"state\": \"running\", \"status\": \"Up 3 hours\"}\n]"
      }
    ]
  }
}