The MCP Server can be run in two modes: stdio (for local testing) or http (for networked access). To start the server, use the following commands:

container-manager-mcp

container-manager-mcp --transport "http"  --host "0.0.0.0"  --port "8000"

• get_version: Retrieve version information of the container runtime
• get_info: Get system information about the container runtime
• list_images: List all available images
• pull_image: Pull an image from a registry
• remove_image: Remove an image
• list_containers: List running or all containers
• run_container: Run a new container
• stop_container: Stop a running container
• remove_container: Remove a container
• get_container_logs: Retrieve logs from a container
• exec_in_container: Execute a command in a container
• list_volumes: List all volumes
• create_volume: Create a new volume
• remove_volume: Remove a volume
• list_networks: List all networks
• create_network: Create a new network
• remove_network: Remove a network
• compose_up: Start services defined in a Compose file
• compose_down: Stop and remove services defined in a Compose file
• compose_ps: List containers for a Compose project
• compose_logs: View logs for a Compose project or specific service
• init_swarm: Initialize a Docker Swarm
• leave_swarm: Leave a Docker Swarm
• list_nodes: List nodes in a Docker Swarm
• list_services: List services in a Docker Swarm
• create_service: Create a new service in a Docker Swarm
• remove_service: Remove a service from a Docker Swarm

The ServiceNow MCP server can be deployed using Docker, with configurable authentication, middleware, and Eunomia authorization.

docker pull knucklessg1/container-manager:latest

docker run -d \
  --name container-manager-mcp \
  -p 8004:8004 \
  -e HOST=0.0.0.0 \
  -e PORT=8004 \
  -e TRANSPORT=http \
  -e AUTH_TYPE=none \
  -e EUNOMIA_TYPE=none \
  knucklessg1/container-manager:latest

docker run -d \
  --name container-manager-a2a \
  -p 9000:9000 \
  -e PORT=9000 \
  -e PROVIDER=openai \
  -e MODEL_ID=qwen3:4b \
  -e BASE_URL=http://host.docker.internal:11434/v1 \
  -e MCP_URL=http://host.docker.internal:8004/mcp \
  knucklessg1/container-manager:latest \
  container-manager-a2a

For advanced authentication (e.g., JWT, OAuth Proxy, OIDC Proxy, Remote OAuth) or Eunomia, add the relevant environment variables:

docker run -d \
  --name container-manager-mcp \
  -p 8004:8004 \
  -e HOST=0.0.0.0 \
  -e PORT=8004 \
  -e TRANSPORT=http \
  -e AUTH_TYPE=oidc-proxy \
  -e OIDC_CONFIG_URL=https://provider.com/.well-known/openid-configuration \
  -e OIDC_CLIENT_ID=your-client-id \
  -e OIDC_CLIENT_SECRET=your-client-secret \
  -e OIDC_BASE_URL=https://your-server.com \
  -e ALLOWED_CLIENT_REDIRECT_URIS=http://localhost:*,https://*.example.com/* \
  -e EUNOMIA_TYPE=embedded \
  -e EUNOMIA_POLICY_FILE=/app/mcp_policies.json \
  knucklessg1/container-manager:latest

Create a docker-compose.yml file:

services:
  container-manager-mcp:
    image: knucklessg1/container-manager:latest
    environment:
      - HOST=0.0.0.0
      - PORT=8004
      - TRANSPORT=http
      - AUTH_TYPE=none
      - EUNOMIA_TYPE=none
    ports:
      - 8004:8004

For advanced setups with authentication and Eunomia:

services:
  container-manager-mcp:
    image: knucklessg1/container-manager:latest
    environment:
      - HOST=0.0.0.0
      - PORT=8004
      - TRANSPORT=http
      - AUTH_TYPE=oidc-proxy
      - OIDC_CONFIG_URL=https://provider.com/.well-known/openid-configuration
      - OIDC_CLIENT_ID=your-client-id
      - OIDC_CLIENT_SECRET=your-client-secret
      - OIDC_BASE_URL=https://your-server.com
      - ALLOWED_CLIENT_REDIRECT_URIS=http://localhost:*,https://*.example.com/*
      - EUNOMIA_TYPE=embedded
      - EUNOMIA_POLICY_FILE=/app/mcp_policies.json
    ports:
      - 8004:8004
    volumes:
      - ./mcp_policies.json:/app/mcp_policies.json

Run the service:

docker-compose up -d

{
  "mcpServers": {
    "container_manager": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "container-manager-mcp",
        "container-manager-mcp"
      ],
      "env": {
        "CONTAINER_MANAGER_SILENT": "False",                                  //Optional
        "CONTAINER_MANAGER_LOG_FILE": "~/Documents/container_manager_mcp.log" //Optional
        "CONTAINER_MANAGER_TYPE": "podman",                                   //Optional
        "CONTAINER_MANAGER_PODMAN_BASE_URL": "tcp://127.0.0.1:8080"           //Optional
      },
      "timeout": 200000
    }
  }
}

python -m pip install container-manager-mcp

or

uv pip install --upgrade container-manager-mcp

container-manager-mcp --transport http --host 127.0.0.1 --port 8080

This starts the MCP server using HTTP transport on localhost port 8080.

To interact with the MCP server programmatically, you can use a FastMCP client or make HTTP requests to the exposed endpoints. Example using curl to pull an image:

curl -X POST http://127.0.0.1:8080/pull_image \
  -H "Content-Type: application/json" \
  -d '{"image": "nginx", "tag": "latest", "manager_type": "docker"}'

Install the Python package:

python -m pip install container-manager-mcp

• Python 3.7+
• fastmcp for MCP server functionality
• docker for Docker support
• podman for Podman support
• pydantic for data validation

Install dependencies:

python -m pip install fastmcp docker podman pydantic

Ensure Docker or Podman is installed and running on your system.

Contributions are welcome! To contribute:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/your-feature)
3. Commit your changes (git commit -am 'Add your feature')
4. Push to the branch (git push origin feature/your-feature)
5. Create a new Pull Request

Please ensure your code follows the project's coding standards and includes appropriate tests.

This project is licensed under the MIT License - see the LICENSE file for details.