Containerization Assist

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 →](https://azure.github.io/containerization-assist/)

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

1. "Generate Dockerfiles" → Automatically creates Dockerfiles for all 3 modules:

• services/api-gateway/Dockerfile
• services/user-service/Dockerfile
• services/notification-service/Dockerfile

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

1. 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

Image Operations

Kubernetes Operations

Utilities

Workflow Tools

Interactive workflow tools that return step-by-step plans (output is collapsed by default in VS Code Copilot Chat):

Version Tracking

All generated artifacts include version metadata so you can track which version of containerization-assist produced them.

Dockerfiles (generate-dockerfile):

The tool output includes attributionLabels.labels with a version label, included as a LABEL instruction in the generated Dockerfile:

Kubernetes Manifests (generate-k8s-manifests):

The tool output includes attributionLabels.annotations applied to all generated Kubernetes r