Containerization Assist MCP Server

An AI-powered containerization assistant that helps you build, scan, and deploy Docker containers through VS Code and other MCP-compatible tools.

Full documentation →

Install

Features

Core Capabilities

• 🐳 Docker Integration: Build, scan, and deploy container images
• ☸️ Kubernetes Support: Generate manifests and deploy applications
• 🤖 AI-Powered: Intelligent Dockerfile generation and optimization
• 🧠 Knowledge Enhanced: AI-driven content improvement with security and performance best practices
• 🔄 Intelligent Tool Routing: Automatic dependency resolution and execution
• 📊 Progress Tracking: Real-time progress updates via MCP notifications
• 🔒 Security Scanning: Built-in vulnerability scanning with AI-powered suggestions
• ✨ Smart Analysis: Context-aware recommendations
• Policy-Driven System (v3.0)
  • Pre-generation configuration
  • Knowledge filtering and weighting
  • Template injection
  • Semantic validation
  • Cross-tool consistency

Policy System (v3.0)

Full control over containerization through Rego policies:

• Configure Before Generation: Set defaults for resources, base images, build strategy
• Guide During Generation: Filter knowledge base, inject templates automatically
• Validate After Generation: Semantic checks, security scoring, cross-tool consistency

Example Policies Included:

• Environment-based strategy (dev/staging/prod)
• Cost control by team tier
• Security-first organization
• Multi-cloud registry governance
• Speed-optimized development

See Policy Authoring Guide for details.

System Requirements

• Node.js 20+
• Docker or Docker Desktop
• Optional: Trivy (for security scanning features)
• Optional: Kubernetes (for deployment features)

Manual Install

Add the following to your VS Code settings or create .vscode/mcp.json in your project:

{
  "servers": {
    "ca": {
      "command": "npx",
      "args": ["-y", "containerization-assist-mcp", "start"],
      "env": {
         "LOG_LEVEL": "info"
      }
    }
  }
}

Restart VS Code to enable the MCP server in GitHub Copilot.

SDK Usage (Without MCP)

For direct tool usage without MCP protocol (e.g., VS Code extensions, programmatic access):

import { analyzeRepo, buildImageContext, scanImage } from 'containerization-assist-mcp/sdk';
import { execSync } from 'child_process';

// Simple function calls - no MCP server needed
const analysis = await analyzeRepo({ repositoryPath: './myapp' });
if (analysis.ok) {
  console.log('Detected:', analysis.value.modules);
}

// buildImageContext returns build context with security analysis and commands
const buildContext = await buildImageContext({ path: './myapp', imageName: 'myapp:v1', platform: 'linux/amd64' });
if (buildContext.ok) {
  const { securityAnalysis, nextAction } = buildContext.value;
  console.log('Security risk:', securityAnalysis.riskLevel);
  
  // Execute the generated build command from the build context directory
  execSync(nextAction.buildCommand.command, {
    cwd: buildContext.value.context.buildContextPath,
    env: { ...process.env, ...nextAction.buildCommand.environment }
  });
}

const scan = await scanImage({ imageId: 'myapp:v1' });

See the SDK integration examples for full SDK documentation.

Windows Users

For Windows, use the Windows Docker pipe:

"DOCKER_SOCKET": "//./pipe/docker_engine"

Quick Start

The easiest way to understand the containerization workflow is through an end-to-end example:

Single-App Containerization Journey

This MCP server guides you through a complete containerization workflow for a single application. The journey follows this sequence:

1. Analyze Repository → Understand your application's language, framework, and dependencies
2. Generate Dockerfile → Create an optimized, security-hardened container configuration
3. Build Image → Compile your application into a Docker image
4. Scan Image → Identify security vulnerabilities and get remediation guidance
5. Tag Image → Apply appropriate version tags to your image
6. Generate K8s Manifests → Create deployment configurations for Kubernetes
7. Prepare Cluster → Set up namespace and prerequisites, then deploy with kubectl apply
8. Verify → Confirm deployment health and readiness

Prerequisites

Before starting, ensure you have:

• Docker: Running Docker daemon with accessible socket (docker ps should work)
  • Linux/Mac: /var/run/docker.sock accessible
  • Windows: Docker Desktop with //./pipe/docker_engine accessible
• Kubernetes (optional, for deployment features):
  • Valid kubeconfig at ~/.kube/config
  • Cluster connectivity (kubectl cluster-info should work)
  • Appropriate RBAC permissions for deployments, services, namespaces
• Node.js: Version 20 or higher
• MCP Client: VS Code with Copilot, Claude Desktop, or another MCP-compatible client

Example Workflow with Natural Language

Once configured in your MCP client (VS Code Copilot, Claude Desktop, etc.), use natural language:

Starting the Journey:

"Analyze my Java application for containerization"

Building the Container:

"Generate an optimized Dockerfile with security best practices"
"Build a Docker image tagged myapp:v1.0.0"
"Scan the image for vulnerabilities"

Deploying to Kubernetes:

"Generate Kubernetes manifests for this application"
"Prepare my cluster and deploy to the default namespace"
"Verify the deployment is healthy"

Single-Operator Model

This server is optimized for one engineer containerizing one application at a time. Key characteristics:

• Sequential execution: Each tool builds on the results of previous steps
• Fast-fail validation: Clear, actionable error messages if Docker/Kubernetes are unavailable
• Deterministic AI generation: Tools provide reproducible outputs through built-in prompt engineering
• Real-time progress: MCP notifications surface progress updates to clients during long-running operations

Multi-Module/Monorepo Support

The server detects and supports monorepo structures with multiple independently deployable services:

• Automatic Detection: analyze-repo identifies monorepo patterns (npm workspaces, services/, apps/ directories)
• Automated Multi-Module Generation: generate-dockerfile and generate-k8s-manifests support multi-module workflows
• Conservative Safeguards: Excludes shared libraries and utility folders from containerization

Multi-Module Workflow Example:

1. "Analyze my monorepo at ./my-monorepo"
   → Detects 3 modules: api-gateway, user-service, notification-service

2. "Generate Dockerfiles"
   → Automatically creates Dockerfiles for all 3 modules:
     - services/api-gateway/Dockerfile
     - services/user-service/Dockerfile
     - services/notification-service/Dockerfile

3. "Generate K8s manifests"
   → Automatically creates manifests for all 3 modules

4. Optional: "Generate Dockerfile for user-service module"
   → Creates module-specific deployment manifests

Detection Criteria:

• Workspace configurations (npm, yarn, pnpm workspaces, lerna, nx, turborepo, cargo workspace)
• Separate package.json, pom.xml, go.mod, Cargo.toml per service
• Independent entry points and build configs
• EXCLUDES: shared/, common/, lib/, packages/utils directories

Available Tools

The server provides 11 MCP tools organized by functionality:

Analysis & Planning

Dockerfile Operations