# 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: | 03 Sep 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?

After completing this Learning Path, you'll be able to perform the following tasks:

- 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'll need the following prerequisites:

- 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

**How do I know the MCP_DOCKER server is running and connected to Copilot?**

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.

**Which repository do I clone, and where should I run the commands?**

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.

**What should I change in the Dockerfile for Arm64 builds?**

Add Arm64 support in the base image and update compiler flags. Follow the migration steps to apply `Dockerfile` adjustments identified during review.

**How do I trigger the migration with Copilot, and what should I expect it to do?**

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.

**What result should I expect when I run the Arm64 container?**

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.