# Automate x86 to Arm Migration with Docker MCP Toolkit, VS Code and GitHub Copilot

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/)
- [Simplify Arm migration with the Docker MCP Toolkit and Arm MCP Server](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/1-overview/)
- [Set up Docker MCP Toolkit with Arm, GitHub, and Sequential Thinking servers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/2-setup/)
- [Examine x86 AVX2 intrinsics in the demo application](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/3-understand-the-demo/)
- [Automate x86 to Arm migration with GitHub Copilot](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/4-run-migration/)
- [Validate the Arm64 migration and test containers](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/5-validate-and-next-steps/)
- [Next Steps](https://learn.arm.com/learning-paths/servers-and-cloud-computing/docker-mcp-toolkit/_next-steps/)

## About this Learning Path

| Skill level: | Advanced |
|--------------|----------|
| Reading time: | 45 min |
| Last updated: | 31 Jul 2026 |

| Author: | Ajeet Singh Raina |
|---------|------------------|
| Arm IP: | [Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors) |
| Tags: | [Containers and Virtualization](https://learn.arm.com/tag/containers-and-virtualization), [Linux](https://learn.arm.com/tag/linux), [macOS](https://learn.arm.com/tag/macos), [Docker](https://learn.arm.com/tag/docker), [MCP](https://learn.arm.com/tag/mcp), [GitHub Copilot](https://learn.arm.com/tag/github-copilot), [CPP](https://learn.arm.com/tag/cpp), [VS Code](https://learn.arm.com/tag/vs-code) |

### Who is this for?
This is an advanced topic for developers and DevOps engineers who want to automate the migration of containerized applications from x86 to Arm64 using AI-powered tools in the Docker MCP Toolkit.

### What will you learn?
Upon completion of this Learning Path, you will be able to:
- Describe how the Model Context Protocol (MCP) enables AI coding assistants to invoke structured migration tools through the Arm MCP server
- Explain how the Docker MCP Toolkit connects AI coding assistants to Arm MCP server
- Install and configure the Docker MCP Toolkit with the Arm MCP Server, GitHub MCP Server, and Sequential Thinking MCP Server
- Connect the MCP Gateway to VS Code with GitHub Copilot
- Use AI agents to scan codebases for x86-specific dependencies and intrinsics
- Automate the conversion of x86 AVX2 intrinsics to Arm Neon equivalents using the Arm MCP Server knowledge base
- Create and manage pull requests with migrated code using the GitHub MCP Server

### Prerequisites
Before starting, you will need the following:
- Docker Desktop 4.59 or later with MCP Toolkit enabled
- Visual Studio Code (VS Code) with the GitHub Copilot extension
- A GitHub account with a personal access token
- A machine with at least 8 GB RAM (16 GB recommended)
- Basic familiarity with Docker, C++, and SIMD intrinsics concepts

### Summary
You’ll use Docker MCP Toolkit, the Arm MCP Server, and GitHub Copilot in VS Code to migrate an x86-optimized C++ container to Arm64. You’ll configure the MCP servers and Gateway, use a provided prompt to find x86-specific code and propose Arm Neon conversions, update the Dockerfile, and build the container with `docker buildx`. Finally, you’ll run the container and verify Arm64 execution with NEON.

### Frequently asked questions
<details>
<summary>How do I know the MCP_DOCKER server is running and connected to Copilot?</summary>
In VS Code, select **Extensions**, then **MCP_DOCKER** and **Start Server**. When it’s running, GitHub Copilot can invoke the configured MCP servers through the MCP Gateway.
</details>

<details>
<summary>Which repository do I clone, and where should I run the commands?</summary>
Clone `https://github.com/JoeStech/docker-blog-arm-migration` and change into that directory. Open the repository in VS Code and run the build and run commands from the repository root.
</details>

<details>
<summary>What should I change in the Dockerfile for Arm64 builds?</summary>
Add Arm64 support in the base image and update compiler flags. Follow the migration steps to apply `Dockerfile` adjustments identified during review.
</details>

<details>
<summary>How do I trigger the migration with Copilot, and what should I expect it to do?</summary>
Open GitHub Copilot Chat in VS Code and paste the provided migration prompt. Copilot uses the Arm MCP Server tools to scan for x86-specific dependencies and AVX2 intrinsics and propose Neon equivalents. Copilot can also prepare a pull request using the GitHub MCP Server.
</details>

<details>
<summary>What result should I expect when I run the Arm64 container?</summary>
The benchmark output shows Arm64 execution with Neon optimizations and prints benchmark details. Look for lines such as the architecture notice, the matrix size, and a result sum to confirm a successful run.
</details>