The Developer Superpower You're Not Using Yet: Claude Code Meets Docker MCP Toolkit

What Is Claude Code, and Why Should You Care?

Claude Code is Anthropic's terminal-native agentic coding tool — not a chat window, not a code-completion plugin, but a full autonomous coding agent that lives inside your terminal. It reads your entire codebase, makes multi-file edits, runs tests, queries git history, and submits pull requests, all from natural-language instructions.

Launched as a research preview in early 2025 and made generally available in May 2025, Claude Code went from niche experiment to a product running at a $1 billion annualised run rate in under six months. The reason it caught fire so quickly is simple: unlike tools that suggest code snippets, Claude Code acts — it plans, executes, and validates on its own.

But Claude Code's power multiplies enormously when you connect it to your real development tools — your git repositories, project management boards, and local files. That bridge is built using something called MCP.

Understanding MCP (Model Context Protocol) in Plain English

Before touching Docker, you need to understand MCP because it's the glue between Claude Code and everything else.

Model Context Protocol (MCP) is an open-source standard released by Anthropic that gives AI models a universal, structured way to connect to external tools, databases, APIs, and services. Think of it as a power strip for AI — instead of hardwiring your AI agent to one specific service, MCP provides a standardized socket that any tool can plug into.

The architecture has three parts:

MCP Host — the AI application (Claude Code in our case) that wants to use external tools
MCP Client — the connection handler built into the host, negotiating with servers
MCP Server — a lightweight process exposing specific tools, like the GitHub API or Jira REST endpoints

When Claude Code needs to query git blame or create a Jira ticket, it doesn't call APIs directly. It makes a request through the MCP client, which routes to the right MCP server, which calls the actual API, and returns structured results. This keeps things clean, secure, and composable.

Why Docker Makes MCP 100x Better

Running MCP servers manually means installing Node.js runtimes, managing environment variables, wiring up config files, and debugging version conflicts. Docker eliminates all of this friction.

The Docker MCP Toolkit is a built-in feature of Docker Desktop that acts as a central hub for managing MCP servers. With it, you can:

Browse and install from 300+ pre-built, containerized MCP servers with one click
Store credentials as encrypted secrets inside Docker, never in plain-text config files
Connect any MCP client (Claude Code, Cursor, VS Code, etc.) through a single Docker MCP Gateway
Configure all your servers once and have them available across all your MCP clients

Each MCP server runs in an isolated Docker container. That means no dependency conflicts, consistent behavior on Mac, Windows, and Linux, and zero manual setup beyond a few config values.

Prerequisites: What You Need Before Starting

Gather these before you begin:

Docker Desktop (latest version) — download from docker.com/products/docker-desktop
Claude subscription — Claude Pro, Max, Teams, or Enterprise (or an Anthropic Console API account)
Atlassian account — free at atlassian.com, with a Jira project created
GitHub account — for OAuth authorization
macOS, Linux, or Windows 10+ — Claude Code runs natively on all three

Part 1: Installing Claude Code

Step 1 — Run the Native Installer

Claude Code switched from npm to native installers in early 2026. Open your terminal and run the single command for your platform:

macOS / Linux / WSL:

curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell:

irm https://claude.ai/install.ps1 | iex

The installer downloads the Claude Code binary and adds the claude command to your system PATH. This takes under 30 seconds on a typical connection.

Step 2 — Verify the Installation

Open a new terminal window (so your shell picks up the updated PATH) and type:

claude --version

If you see a version number like Claude Code v2.x.x, the installation succeeded. If not, close and reopen your terminal before troubleshooting.

Step 3 — Authenticate with Your Anthropic Account

Launch Claude Code for the first time:

claude

Claude Code will present a theme selector and a login prompt. Choose your preferred theme (dark mode recommended for terminal work), then select Log in with Anthropic. Your browser will open and ask you to authorize the CLI application. Click Authenticate, return to the terminal, and press Enter to confirm.

Claude Code will ask for a few permissions — to access your directories and run commands. Review these and confirm. You're now inside the Claude Code REPL (Read-Eval-Print Loop).

Step 4 — A Quick Sanity Check

Type the following slash command inside Claude Code:

/mcp

This shows all currently connected MCP servers. Right now, you'll see nothing or just a message about managing MCP servers. That's expected — we haven't connected Docker yet. Exit Claude Code by typing:

/exit

Part 2: Enabling Docker MCP Toolkit

Step 5 — Enable the MCP Toolkit in Docker Desktop

Open Docker Desktop, click the gear icon (Settings) in the top-right corner, and navigate to Beta Features in the left sidebar. Check the box labeled Enable Docker MCP Toolkit and click Apply & Restart.

Once Docker Desktop restarts, you'll see a new MCP Toolkit icon in the left navigation bar. Click it — you'll find four tabs: Catalog, My Servers, Clients, and Configuration.

Step 6 — Connect Claude Code as an MCP Client

Click the Clients tab inside MCP Toolkit. You'll see a list of supported AI applications. Find Claude Code (or Claude CLI) and click Connect.

Docker Desktop will automatically write the required MCP gateway configuration to Claude Code's settings. This tells Claude Code to route all MCP requests through Docker's gateway container, which then dispatches them to your individual MCP servers.

Now restart Claude Code in your terminal:

claude

Type /mcp again. This time, you should see the Docker MCP gateway listed as an available server. Claude Code is now wired into Docker's MCP ecosystem.

Part 3: Configuring Three MCP Servers

For the automation demo ahead, you'll configure three servers: Atlassian (Jira), GitHub, and Filesystem. Each serves a distinct role:

MCP Server	What It Does in This Workflow
Filesystem	Scans your local codebase and reads source files
GitHub Official	Runs `git blame` and retrieves commit author information
Atlassian	Creates and manages Jira issues

Step 7 — Configure the Atlassian (Jira) MCP Server

Get Your Atlassian Credentials First

You'll need three values from your Atlassian account:

Jira URL — your workspace URL, e.g., https://yourcompany.atlassian.net (note: https:// is required)
Username — your Atlassian account email address
API Token — generate one at https://id.atlassian.com/manage-profile/security/api-tokens. Click Create API Token, give it a name, and copy the token immediately — you won't see it again.

If you don't have a Jira project yet, create one at atlassian.com. A free Jira Software project works perfectly for this demo.

Add the Server in Docker Desktop

Go to MCP Toolkit → Catalog
Search for "Atlassian" and click + Add
Open the Configuration tab for the server
Fill in your values:
- atlassian.jira.url: https://yourcompany.atlassian.net
- atlassian.jira.username: your email address
- Under Secrets, add your API token to both the personal token and API token fields
Click Save, then click Start Server

Why Docker handles secrets safely: Your credentials are stored as encrypted Docker secrets — not in environment variables or plain-text config files. They live inside Docker and never touch your shell profile or get accidentally committed to version control.

Test the Connection

Restart Claude Code and ask it a simple Jira question:

List the last two issues in my project

Claude Code will display a permission prompt asking if it can call the Jira tool. Press Enter to approve. If you see real Jira issue data returned, your Atlassian MCP server is working correctly.

Step 8 — Configure the GitHub MCP Server

Add via OAuth (Recommended)

Go to MCP Toolkit → Catalog
Search for "GitHub Official" and click + Add
In the server configuration, select the OAuth tab
Click the Authorize link — your browser opens GitHub's authorization page
Click Authorize Docker
You'll be redirected back to Docker Desktop; in the bottom-right corner, you'll see a confirmation that the login code was received
Click Start Server

OAuth gives Docker temporary, revocable access through GitHub's secure authorization flow — no manual token creation, no long-lived keys sitting in config files.

Alternative: Personal Access Token

If you prefer explicit token control, go to GitHub → Settings → Developer Settings → Personal Access Tokens → Tokens (Classic). Create a new token with scopes repo, workflow, and read:org. Copy it and paste it into the GitHub server's Configuration tab in Docker Desktop.

Test It

Restart Claude Code and ask:

What is my GitHub username?

Claude Code will use the GitHub MCP server to fetch your profile. If it returns your actual username, the server is configured correctly.

Step 9 — Configure the Filesystem MCP Server

This server controls which local directories Claude Code can read. It's a critical security boundary — only directories you explicitly whitelist are accessible.

Get the path you want to allow:

In your terminal, navigate to your project folder and copy the full path:

cd ~/your-project-folder
 pwd

Copy the output path to your clipboard.

Add the Server:

Go to MCP Toolkit → Catalog
Search for "Filesystem" and find Filesystem (Reference) — click + Add
Open the Configuration tab
Under filesystem.paths, click the + button and paste your project directory path
Click Save, then Start Server

Test It:

Restart Claude Code and ask:

List the allowed directories

You should see the exact path you configured returned as the allowed directory.

At this point, check My Servers in the MCP Toolkit — you should see all three servers listed and active.

Part 4: The Real-World Demo — TODO-to-Jira Automation

With your three MCP servers running, it's time to see what Claude Code can actually do when they work together.

Step 10 — Clone a Sample Codebase

For this demo, you need a codebase with TODO and FIXME comments scattered through it. You can use your own project, or clone this representative sample:

git clone https://github.com/your-org/catalog-service-node
 cd catalog-service-node

Make sure this directory matches the path you configured for the Filesystem MCP server. If it doesn't, update your Filesystem MCP configuration to include this directory.

Step 11 — Craft Your Instruction Prompt

Start Claude Code from inside the project directory:

claude

Now paste the following instruction — this is the orchestration prompt that will coordinate all three MCP servers simultaneously. Adjust PROJECT_KEY to match your actual Jira project key:

Scan this codebase for all TODO and FIXME comments.
For each one:
1. Extract the comment and the surrounding code context (5 lines before and after)
2. Use git blame to identify who wrote the code and when
3. Determine priority based on keywords in the comment:
   - High: "race condition", "data loss", "security", "failure", "crash"
   - Medium: "performance", "slow", "cache", "optimization"
   - Low: "documentation", "refactor", "cleanup"
4. Create a Jira issue with:
   - Project: YOUR_PROJECT_KEY
   - Issue Type: Task
   - Summary: Extracted from the TODO/FIXME comment
   - Description: Full code context and explanation
   - Priority: Based on categorization above
   - Labels: ["tech-debt"]
   - Add a comment linking to the exact GitHub file and line number
At the end, provide a summary showing:
- Total TODOs/FIXMEs found
- Breakdown by priority (High / Medium / Low)
- List of all created Jira issues with links

Press Enter and watch Claude Code go to work.

Step 12 — What Happens Under the Hood

This is where the magic becomes real. Claude Code orchestrates three MCP servers in sequence:

Phase 1 — Filesystem scan: Claude Code calls the Filesystem MCP to traverse your src/ directory, reading every source file and identifying TODO and FIXME comments along with surrounding code context.

Phase 2 — Git history extraction: For each comment found, Claude Code calls the GitHub MCP to run git blame on the specific file and line number, identifying the original author and commit date.

Phase 3 — Priority categorization: Claude Code analyzes the comment text for keywords and assigns priority levels — High, Medium, or Low.

Phase 4 — Jira ticket creation: Claude Code calls the Atlassian MCP's jira_batch_create_issues tool, creating properly formatted tickets in bulk. Each ticket includes the code context, author information, priority, labels, and a direct link back to the exact file and line number in your repository.

Claude Code will pause at certain steps and ask for your permission before taking actions (like creating Jira issues in bulk). You can type 2 to approve all future actions of the same type without repeated prompts — useful once you've reviewed a few and trust the output.

Step 13 — Review the Results

When Claude Code finishes, it prints a summary in the terminal:

Summary:
- Total TODO/FIXME comments found: 19
- High priority: 4 (security, crash-related)
- Medium priority: 9 (performance, optimization)
- Low priority: 6 (documentation, cleanup)
Created Jira issues:
- PROJ-24: Fix race condition in payment processor (High) → src/checkout.js:147
- PROJ-25: Cache user session tokens (Medium) → src/auth.js:89
...

Open your Jira project in a browser. All the new tickets are there — formatted, prioritized, and linked to the exact source file and line.

What would have taken a developer 20–30 minutes of manual work was completed in under 2 minutes. And critically, the output is consistent — no tickets accidentally skipped, no context forgotten, no copy-paste errors in the file links.

Part 5: Going Further — Local Models with Docker Model Runner

Everything above used Claude's hosted API (billed per token). Docker offers another option for those who want complete privacy and cost control.

Running Claude Code Locally via Docker Model Runner

Docker Model Runner (DMR) lets you pull and run open-source language models locally. Because it exposes an Anthropic-compatible API endpoint, Claude Code connects to it with a single environment variable.

Enable TCP access for Docker Model Runner:

docker desktop enable model-runner --tcp

Once enabled, Docker Model Runner is available at http://localhost:12434.

Pull and package a local model:

docker model pull gpt-oss
 docker model package --from ai/gpt-oss --context-size 32000 gpt-oss:32k

Point Claude Code at your local model:

ANTHROPIC_BASE_URL=http://localhost:12434 claude --model gpt-oss:32k

Claude Code will now send all requests to your local Docker Model Runner instance instead of Anthropic's servers. All reasoning, code generation, and tool calls happen entirely on your machine — no data leaves your environment.

To make this setting permanent, add it to your shell profile:

# ~/.zshrc or ~/.bashrcexport ANTHROPIC_BASE_URL=http://localhost:12434

Then simply run claude --model gpt-oss:32k as normal.

Part 6: Running Claude Code Safely in Docker Sandboxes

As Claude Code evolves from making suggestions to taking real actions — installing packages, modifying files, running builds — a new question becomes critical: how do you let an agent run autonomously without risking your machine?

The Problem with Unsandboxed Agents

Most sandboxing approaches for coding agents have painful trade-offs:

OS-level sandboxing interrupts workflows and behaves inconsistently across platforms
Standard Docker containers work until the agent needs to run Docker itself
Full VMs are secure but slow, manual, and hard to reset between tasks

Docker Sandboxes: MicroVM-Based Isolation

Docker Sandboxes provide a purpose-built solution. Each agent session runs inside a dedicated microVM — a lightweight virtual machine offering hypervisor-grade isolation:

Only your project workspace is mounted into the sandbox
The agent can install system packages, run services, and modify files freely
The agent can even build and run Docker containers inside the microVM, completely isolated from your host Docker daemon
Network access is controlled via allow/deny lists
If something goes wrong, delete the sandbox and spin up a fresh one in seconds

The practical result: you can run Claude Code in fully autonomous mode (no constant permission prompts) without fear. Claude Code, Copilot CLI, Codex CLI, Gemini CLI, and Kiro are all supported on the same sandbox infrastructure.

Workflow Comparison: Before and After Docker MCP

Task	Manual Process	With Claude Code + Docker MCP	Time Saved
Convert TODO comments to Jira tickets	Read each file, identify TODOs, look up git history, categorize, create tickets one-by-one	Single natural language prompt; Claude orchestrates filesystem, git, and Jira automatically	~25 min → ~2 min
Debug performance issue	Check dashboards, export logs, analyze locally, write Jira ticket, notify team	"Why are API response times spiking?" → Claude queries logs, identifies root cause, files issue, posts update	~20 min → ~3 min
Run agent tasks safely	Risk host filesystem or use slow VM setup	Docker Sandbox microVM: full autonomy, zero host risk, reset in seconds	Ongoing safety

Key Takeaways

Claude Code becomes dramatically more powerful when paired with Docker's MCP infrastructure. The core insight is that configuration happens once — set up your Atlassian, GitHub, and Filesystem MCP servers in Docker Desktop, and every MCP-compatible client you use from that point forward inherits the same secure, pre-configured connections.

The Docker MCP Toolkit solves the three hardest problems with running MCP servers: installation complexity (one-click from a catalog of 300+ servers), credential security (encrypted Docker secrets instead of plain-text environment variables), and cross-platform consistency (containerized servers that behave identically on Mac, Windows, and Linux). Add Docker Sandboxes for autonomous agent execution and Docker Model Runner for privacy-first local inference, and you have a complete, production-grade environment for AI-powered development.