From 5aefb86b7d15b9b6e595f71bc944f197d7089e7a Mon Sep 17 00:00:00 2001 From: Joe <4088382+JoeStech@users.noreply.github.com> Date: Wed, 17 Dec 2025 22:44:13 -0700 Subject: [PATCH 1/4] Arm MCP Server LP --- .../arm-mcp-server/1-overview.md | 81 ++++++ .../arm-mcp-server/2-docker-check.md | 89 +++++++ .../arm-mcp-server/3-simd-migration.md | 238 ++++++++++++++++++ .../arm-mcp-server/4-agentic-systems.md | 95 +++++++ .../arm-mcp-server/_index.md | 53 ++++ .../arm-mcp-server/_next-steps.md | 8 + 6 files changed, 564 insertions(+) create mode 100644 content/learning-paths/servers-and-cloud-computing/arm-mcp-server/1-overview.md create mode 100644 content/learning-paths/servers-and-cloud-computing/arm-mcp-server/2-docker-check.md create mode 100644 content/learning-paths/servers-and-cloud-computing/arm-mcp-server/3-simd-migration.md create mode 100644 content/learning-paths/servers-and-cloud-computing/arm-mcp-server/4-agentic-systems.md create mode 100644 content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md create mode 100644 content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_next-steps.md diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/1-overview.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/1-overview.md new file mode 100644 index 0000000000..1469385d12 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/1-overview.md @@ -0,0 +1,81 @@ +--- +title: Arm MCP Server Overview +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## What is the Arm MCP Server? + +The Arm MCP Server is a tool that enables AI-powered developer tools to become Arm cloud migration and optimization experts. It implements the Model Context Protocol (MCP), an open standard that allows AI assistants to access external tools and data sources. + +By connecting your AI coding assistant to the Arm MCP Server, you gain access to Arm-specific knowledge, container image inspection tools, and code analysis capabilities that streamline the process of migrating applications from x86 to Arm. + +## How to interact with the Arm MCP Server + +There are multiple ways to interact with the Arm MCP Server, depending on your development environment and workflow: + +### 1. Direct AI Chat + +You can ask your AI assistant natural language questions, and it will automatically use the MCP tools when appropriate. For example: + +```text +Check if the nginx:latest Docker image supports Arm architecture +``` + +### 2. Prompt Files + +Many AI coding tools support prompt files that provide structured instructions. These files can reference MCP tools and guide the AI through complex workflows like full codebase migrations. + +### 3. Agentic Workflows + +Tools like GitHub Copilot Agent Mode, Claude Code, Kiro, and OpenAI Codex support autonomous agent workflows where the AI can execute multi-step migration tasks with minimal intervention. These fully agentic workflows can be combined with prompt files and direct chat to create an extremely powerful development system. + +## Available Arm MCP Server Tools + +The Arm MCP Server provides several specialized tools for migration and optimization: + +### knowledge_base_search + +Searches an Arm knowledge base of learning resources, Arm intrinsics, and software version compatibility using semantic similarity. Given a natural language query, it returns matching resources with URLs, titles, and content snippets ranked by relevance. + +**Use case:** Finding documentation, tutorials, or version compatibility information for Arm migration. + +### check_image + +Checks Docker image architectures. Provide an image in `name:tag` format and get a report of supported architectures. + +**Use case:** Quickly verify if a container base image supports `arm64` before starting a migration. + +### skopeo + +A container image architecture inspector that inspects container images remotely without downloading them to check architecture support (especially ARM64 compatibility). + +**Use case:** Detailed inspection of container manifests and multi-architecture support before migrating workloads to Arm-based infrastructure. + +### migrate_ease_scan + +Runs a migrate-ease scan against a workspace or remote Git repository. Supported scanners include: cpp, python, go, js, and java. Returns analysis results identifying x86-specific code that needs attention. + +**Use case:** Automated scanning of codebases to identify architecture-specific dependencies, build flags, intrinsics, and libraries that need to be changed for Arm. + +### mca (Machine Code Analyzer) + +An assembly code performance analyzer that predicts performance on different CPU architectures and identifies bottlenecks. It estimates Instructions Per Cycle (IPC), execution time, and resource usage. + +**Use case:** Analyzing and optimizing performance-critical assembly code when migrating between processor types. + +### sysreport_instructions + +Provides instructions for installing and using sysreport, a tool that obtains system information related to system architecture, CPU, memory, and other hardware details. + +**Use case:** Understanding the target Arm system's capabilities before deployment. + +## Setting up the Arm MCP Server + +To use the Arm MCP Server with your AI coding assistant, you need to configure your tool to connect to the server. The exact configuration depends on your tool: + +[placeholder list of links to learn.arm.com install guides] + +Continue to the next section to see the Arm MCP Server in action. diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/2-docker-check.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/2-docker-check.md new file mode 100644 index 0000000000..dd2af36159 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/2-docker-check.md @@ -0,0 +1,89 @@ +--- +title: Direct AI Chat +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Checking Base Images for Arm Compatibility + +This section demonstrates just one example of using direct AI chat with the Arm MCP Server. You can use similar natural language prompts to check library compatibility, search for Arm documentation, or analyze code for migration issues. + +One of the first steps in migrating a containerized application to Arm is verifying that your base images support the `arm64` architecture. The Arm MCP Server makes this easy with a simple natural language prompt. + +## Example: Legacy CentOS 6 Application + +Consider an application built on CentOS 6, a legacy distribution that has reached end-of-life. Here's a Dockerfile that represents a typical x86-optimized compute benchmark application. Copy it to your VS Code with GitHub Copilot or other agentic IDE: + +```dockerfile +FROM centos:6 + +# CentOS 6 reached EOL, need to use vault mirrors +RUN sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/CentOS-Base.repo && \ + sed -i 's|^#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-Base.repo + +# Install EPEL repository (required for some development tools) +RUN yum install -y epel-release && \ + sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/epel.repo && \ + sed -i 's|^#baseurl=http://download.fedoraproject.org/pub/epel|baseurl=http://archives.fedoraproject.org/pub/archive/epel|g' /etc/yum.repos.d/epel.repo + +# Install Developer Toolset 2 for better C++11 support (GCC 4.8) +RUN yum install -y centos-release-scl && \ + sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/CentOS-SCLo-scl.repo && \ + sed -i 's|^mirrorlist=|#mirrorlist=|g' /etc/yum.repos.d/CentOS-SCLo-scl-rh.repo && \ + sed -i 's|^# baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-SCLo-scl.repo && \ + sed -i 's|^# baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-SCLo-scl-rh.repo + +# Install build tools +RUN yum install -y \ + devtoolset-2-gcc \ + devtoolset-2-gcc-c++ \ + devtoolset-2-binutils \ + make \ + && yum clean all + +# Set working directory +WORKDIR /app + +# Copy all header files +COPY *.h ./ + +# Copy all C++ source files +COPY *.cpp ./ + +# Build the application with optimizations using devtoolset-2 (GCC 4.8) +# AVX2 intrinsics are used in the code for x86-64 platforms +RUN scl enable devtoolset-2 "g++ -O2 -mavx2 -o benchmark \ + main.cpp \ + matrix_operations.cpp \ + hash_operations.cpp \ + string_search.cpp \ + memory_operations.cpp \ + polynomial_eval.cpp \ + -std=c++11" + +# Create a startup script +COPY start.sh . +RUN chmod +x start.sh + +# Run the application +CMD ["./start.sh"] +``` + +This Dockerfile has several x86-specific elements: +- The `centos:6` base image +- The `-mavx2` compiler flag for x86 AVX2 SIMD instructions +- C++ source files containing x86 intrinsics (which you will examine in the next section) + +## Using the Arm MCP Server to Check Compatibility + +With the Arm MCP Server connected to your AI assistant, you can check the base image compatibility with a simple prompt: + +```text +Check this base image for Arm compatibility +``` + +The AI assistant will use the `check_image` or `skopeo` tool to inspect the image and return a report. For `centos:6`, you would discover that this legacy image does **not** support `arm64` architecture. + +This simple interaction demonstrates how direct AI chat can quickly surface compatibility issues. In the next section, you'll see how to resolve these issues automatically using a fully agentic migration workflow with prompt files. diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/3-simd-migration.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/3-simd-migration.md new file mode 100644 index 0000000000..f86f1d32eb --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/3-simd-migration.md @@ -0,0 +1,238 @@ +--- +title: Fully Agentic Migration with Prompt Files +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Migrating SIMD Code with AI Assistance + +One of the most complex aspects of migrating from x86 to Arm is converting SIMD (Single Instruction, Multiple Data) intrinsics. x86 uses SSE, AVX, and AVX2 instructions, while Arm uses NEON intrinsics. + +The Arm MCP Server, combined with a well-crafted prompt file, can automate much of this migration process. + +## Sample x86 Code with AVX2 Intrinsics + +The following example shows a matrix multiplication implementation using x86 AVX2 intrinsics. Copy this code into a file named `matrix_operations.cpp` to follow along: + +```cpp +#include "matrix_operations.h" +#include +#include +#include +#include +#include // AVX2 intrinsics + +Matrix::Matrix(size_t r, size_t c) : rows(r), cols(c) { + data.resize(rows, std::vector(cols, 0.0)); +} + +void Matrix::randomize() { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_real_distribution<> dis(0.0, 10.0); + + for (size_t i = 0; i < rows; i++) { + for (size_t j = 0; j < cols; j++) { + data[i][j] = dis(gen); + } + } +} + +Matrix Matrix::multiply(const Matrix& other) const { + if (cols != other.rows) { + throw std::runtime_error("Invalid matrix dimensions for multiplication"); + } + + Matrix result(rows, other.cols); + + // x86-64 optimized using AVX2 for double-precision + for (size_t i = 0; i < rows; i++) { + for (size_t j = 0; j < other.cols; j++) { + __m256d sum_vec = _mm256_setzero_pd(); + size_t k = 0; + + // Process 4 elements at a time with AVX2 + for (; k + 3 < cols; k += 4) { + __m256d a_vec = _mm256_loadu_pd(&data[i][k]); + __m256d b_vec = _mm256_set_pd( + other.data[k+3][j], + other.data[k+2][j], + other.data[k+1][j], + other.data[k][j] + ); + sum_vec = _mm256_add_pd(sum_vec, _mm256_mul_pd(a_vec, b_vec)); + } + + // Horizontal add using AVX + __m128d sum_high = _mm256_extractf128_pd(sum_vec, 1); + __m128d sum_low = _mm256_castpd256_pd128(sum_vec); + __m128d sum_128 = _mm_add_pd(sum_low, sum_high); + + double sum_arr[2]; + _mm_storeu_pd(sum_arr, sum_128); + double sum = sum_arr[0] + sum_arr[1]; + + // Handle remaining elements + for (; k < cols; k++) { + sum += data[i][k] * other.data[k][j]; + } + + result.data[i][j] = sum; + } + } + + return result; +} + +double Matrix::sum() const { + double total = 0.0; + for (size_t i = 0; i < rows; i++) { + for (size_t j = 0; j < cols; j++) { + total += data[i][j]; + } + } + return total; +} + +void benchmark_matrix_ops() { + std::cout << "\n=== Matrix Multiplication Benchmark ===" << std::endl; + + const size_t size = 200; + Matrix a(size, size); + Matrix b(size, size); + + a.randomize(); + b.randomize(); + + auto start = std::chrono::high_resolution_clock::now(); + Matrix c = a.multiply(b); + auto end = std::chrono::high_resolution_clock::now(); + + auto duration = std::chrono::duration_cast(end - start); + + std::cout << "Matrix size: " << size << "x" << size << std::endl; + std::cout << "Time: " << duration.count() << " ms" << std::endl; + std::cout << "Result sum: " << c.sum() << std::endl; +} +``` + +You'll also need the header file `matrix_operations.h`: + +```cpp +#ifndef MATRIX_OPERATIONS_H +#define MATRIX_OPERATIONS_H + +#include +#include + +// Matrix class with x86 SSE2 optimizations +class Matrix { +private: + std::vector> data; + size_t rows; + size_t cols; + +public: + Matrix(size_t r, size_t c); + void randomize(); + Matrix multiply(const Matrix& other) const; + double sum() const; + + size_t getRows() const { return rows; } + size_t getCols() const { return cols; } +}; + +// Benchmark function +void benchmark_matrix_ops(); + +#endif // MATRIX_OPERATIONS_H +``` + +Finally, create `main.cpp` to run the benchmark: + +```cpp +#include "matrix_operations.h" +#include + +int main() { + std::cout << "x86-64 AVX2 Matrix Operations Benchmark" << std::endl; + std::cout << "========================================" << std::endl; + +#if defined(__x86_64__) || defined(_M_X64) + std::cout << "Running on x86-64 architecture with AVX2 optimizations" << std::endl; +#else + #error "This code requires x86-64 architecture with AVX2 support" +#endif + + benchmark_matrix_ops(); + + return 0; +} +``` + +## The Arm Migration Prompt File + +To automate the migration of code like this, you can use a prompt file that instructs the AI assistant how to systematically approach the migration. Here's an example prompt file for GitHub Copilot: + +Create a file at `.github/prompts/arm-migration.prompt.md`: + +```markdown +--- +tools: ['search/codebase', 'edit/editFiles', 'arm-mcp/skopeo', 'arm-mcp/check_image', 'arm-mcp/knowledge_base_search', 'arm-mcp/migrate_ease_scan', 'arm-mcp/mca', 'arm-mcp/sysreport_instructions'] +description: 'Scan a project and migrate to ARM architecture' +--- + +Your goal is to migrate a codebase from x86 to Arm. Use the mcp server tools to help you with this. Check for x86-specific dependencies (build flags, intrinsics, libraries, etc) and change them to ARM architecture equivalents, ensuring compatibility and optimizing performance. Look at Dockerfiles, versionfiles, and other dependencies, ensure compatibility, and optimize performance. + +Steps to follow: +* Look in all Dockerfiles and use the check_image and/or skopeo tools to verify ARM compatibility, changing the base image if necessary. +* Look at the packages installed by the Dockerfile send each package to the knowledge_base_search tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. When invoking the tool, explicitly ask "Is [package] compatible with ARM architecture?" where [package] is the name of the package. +* Look at the contents of any requirements.txt files line-by-line and send each line to the knowledge_base_search tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. When invoking the tool, explicitly ask "Is [package] compatible with ARM architecture?" where [package] is the name of the package. +* Look at the codebase that you have access to, and determine what the language used is. +* Run the migrate_ease_scan tool on the codebase, using the appropriate language scanner based on what language the codebase uses, and apply the suggested changes. Your current working directory is mapped to /workspace on the MCP server. +* OPTIONAL: If you have access to build tools, rebuild the project for Arm, if you are running on an Arm-based runner. Fix any compilation errors. +* OPTIONAL: If you have access to any benchmarks or integration tests for the codebase, run these and report the timing improvements to the user. + +Pitfalls to avoid: + +* Make sure that you don't confuse a software version with a language wrapper package version -- i.e. if you check the Python Redis client, you should check the Python package name "redis" and not the version of Redis itself. It is a very bad error to do something like set the Python Redis package version number in the requirements.txt to the Redis version number, because this will completely fail. +* NEON lane indices must be compile-time constants, not variables. + +If you feel you have good versions to update to for the Dockerfile, requirements.txt, etc. immediately change the files, no need to ask for confirmation. + +Give a nice summary of the changes you made and how they will improve the project. +``` + +## Running the Migration + +With the prompt file in place and the Arm MCP Server connected, you can run the migration by referencing the prompt in your AI assistant: + +```text +/arm-migration +``` + +## Verifying the Migration + +After accepting the agent's migration changes, build and test the code on an Arm system: + +```bash +g++ -O2 -o benchmark matrix_operations.cpp main.cpp -std=c++11 +./benchmark +``` + +If everything works, you should see something like this (the agent may use different wording): + +```bash +ARM-Optimized Matrix Operations Benchmark +========================================== +Running on ARM64 architecture with NEON optimizations + +=== Matrix Multiplication Benchmark === +Matrix size: 200x200 +Time: 12 ms +Result sum: 2.01203e+08 +``` + +If there are failures, feed the failures back to the agent so that it can improve the code. \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/4-agentic-systems.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/4-agentic-systems.md new file mode 100644 index 0000000000..2115b6e1ee --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/4-agentic-systems.md @@ -0,0 +1,95 @@ +--- +title: Configure Different Agentic Systems +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Agentic AI Systems for Migration + +Different AI coding tools have different ways of configuring persistent instructions and prompt files. This section shows how to set up Arm migration workflows in a couple other popular agentic systems. + +The goal is the same across all systems: provide the AI with structured instructions that enable it to use the Arm MCP Server tools effectively and execute multi-step migration workflows autonomously. + +## Kiro Steering Documents + +[Kiro](https://kiro.dev/) uses "steering documents" - markdown files stored in `.kiro/steering/` that provide persistent context to the AI. Steering files support different inclusion modes based on when you want the instructions to apply. + +### Create Arm Migration Steering Document + +Create a file at `.kiro/steering/arm-migration.md`: + +```markdown +--- +inclusion: manual +--- + +Your goal is to migrate a codebase from x86 to Arm. Use the MCP server tools to help you with this. Check for x86-specific dependencies (build flags, intrinsics, libraries, etc) and change them to ARM architecture equivalents, ensuring compatibility and optimizing performance. Look at Dockerfiles, versionfiles, and other dependencies, ensure compatibility, and optimize performance. + +Steps to follow: +* Look in all Dockerfiles and use the check_image and/or skopeo tools to verify ARM compatibility, changing the base image if necessary. +* Look at the packages installed by the Dockerfile and send each package to the knowledge_base_search tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. When invoking the tool, explicitly ask "Is [package] compatible with ARM architecture?" where [package] is the name of the package. +* Look at the contents of any requirements.txt files line-by-line and send each line to the knowledge_base_search tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. +* Look at the codebase that you have access to, and determine what the language used is. +* Run the migrate_ease_scan tool on the codebase, using the appropriate language scanner based on what language the codebase uses, and apply the suggested changes. +* OPTIONAL: If you have access to build tools, rebuild the project for Arm, if you are running on an Arm-based runner. Fix any compilation errors. +* OPTIONAL: If you have access to any benchmarks or integration tests for the codebase, run these and report the timing improvements to the user. + +Pitfalls to avoid: + +* Make sure that you don't confuse a software version with a language wrapper package version -- i.e. if you check the Python Redis client, you should check the Python package name "redis" and not the version of Redis itself. +* NEON lane indices must be compile-time constants, not variables. + +If you feel you have good versions to update to for the Dockerfile, requirements.txt, etc. immediately change the files, no need to ask for confirmation. + +Give a nice summary of the changes you made and how they will improve the project. +``` + +Reference this steering document in chat with `#arm-migration`. + +## OpenAI Codex Prompt Files + +[OpenAI Codex](https://openai.com/codex/) uses markdown prompt files stored in `~/.codex/prompts/` or `$CODEX_HOME/prompts/`. The filename becomes the command name. + +### Create Arm Migration Prompt + +Create a file at `~/.codex/prompts/arm-migrate.md`: + +```markdown +--- +description: Migrate codebase from x86 to Arm architecture +--- + +Your goal is to migrate a codebase from x86 to Arm. Use the MCP server tools to help you with this. Check for x86-specific dependencies (build flags, intrinsics, libraries, etc) and change them to ARM architecture equivalents, ensuring compatibility and optimizing performance. Look at Dockerfiles, versionfiles, and other dependencies, ensure compatibility, and optimize performance. + +Steps to follow: +* Look in all Dockerfiles and use the check_image and/or skopeo tools to verify ARM compatibility, changing the base image if necessary. +* Look at the packages installed by the Dockerfile and send each package to the knowledge_base_search tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. When invoking the tool, explicitly ask "Is [package] compatible with ARM architecture?" where [package] is the name of the package. +* Look at the contents of any requirements.txt files line-by-line and send each line to the knowledge_base_search tool to check each package for ARM compatibility. If a package is not compatible, change it to a compatible version. +* Look at the codebase that you have access to, and determine what the language used is. +* Run the migrate_ease_scan tool on the codebase, using the appropriate language scanner based on what language the codebase uses, and apply the suggested changes. +* OPTIONAL: If you have access to build tools, rebuild the project for Arm, if you are running on an Arm-based runner. Fix any compilation errors. +* OPTIONAL: If you have access to any benchmarks or integration tests for the codebase, run these and report the timing improvements to the user. + +Pitfalls to avoid: + +* Make sure that you don't confuse a software version with a language wrapper package version -- i.e. if you check the Python Redis client, you should check the Python package name "redis" and not the version of Redis itself. +* NEON lane indices must be compile-time constants, not variables. + +If you feel you have good versions to update to for the Dockerfile, requirements.txt, etc. immediately change the files, no need to ask for confirmation. + +Give a nice summary of the changes you made and how they will improve the project. +``` + +### Running the Codex Prompt + +Invoke the prompt with: + +```bash +codex /prompts:arm-migrate +``` + +## Other AI assistants + +You should now have a good feel for how agents generally implement these types of instructions. You can search for documentation on how your specific AI coding assistent implements them. diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md new file mode 100644 index 0000000000..044bccbf01 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md @@ -0,0 +1,53 @@ +--- +title: Migrate an x86 application to Arm using the Arm MCP Server + +minutes_to_complete: 30 + +who_is_this_for: This is an introductory topic for software developers who want to use AI-powered tools to migrate x86 applications to Arm-based cloud instances. + +learning_objectives: + - Understand how the Arm MCP Server enables AI developer tools to assist with cloud migration + - Use AI prompts to check Docker images for Arm compatibility + - Perform a fully automated C++ application migration using prompt files with the Arm MCP Server + - Configure different agentic systems to automate Arm migration workflows + +prerequisites: + - An AI-powered IDE such as VS Code with GitHub Copilot, Claude Code, Cursor, or similar + - Basic familiarity with Docker and C/C++ development + - Access to an Arm-based cloud instance or local Arm computer for testing + +author: Joe Stech + +### Tags +skilllevels: Introductory +subjects: Migration to Arm +armips: + - Neoverse +tools_software_languages: + - MCP + - Docker + - GCC + - GitHub Copilot +operatingsystems: + - Linux + + + +further_reading: + - resource: + title: Arm MCP Server GitHub Repository + link: https://github.com/arm/mcp + type: website + - resource: + title: Model Context Protocol Documentation + link: https://modelcontextprotocol.io/ + type: documentation + + + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 # _index.md always has weight of 1 to order correctly +layout: "learningpathall" # All files under learning paths have this same wrapper +learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_next-steps.md new file mode 100644 index 0000000000..727b395ddd --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # The weight controls the order of the pages. _index.md always has weight 1. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- From 727f4ff6c105ab50fca5e9c2783fbde774ba3c5a Mon Sep 17 00:00:00 2001 From: Joe <4088382+JoeStech@users.noreply.github.com> Date: Wed, 17 Dec 2025 22:47:49 -0700 Subject: [PATCH 2/4] tweaks to index file --- .../servers-and-cloud-computing/arm-mcp-server/_index.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md index 044bccbf01..af23ed3e12 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md @@ -1,7 +1,7 @@ --- title: Migrate an x86 application to Arm using the Arm MCP Server -minutes_to_complete: 30 +minutes_to_complete: 20 who_is_this_for: This is an introductory topic for software developers who want to use AI-powered tools to migrate x86 applications to Arm-based cloud instances. @@ -26,7 +26,7 @@ armips: tools_software_languages: - MCP - Docker - - GCC + - C++ - GitHub Copilot operatingsystems: - Linux From c3c8a1fa83e0b3103c62533565de236a8d018e9c Mon Sep 17 00:00:00 2001 From: Joe <4088382+JoeStech@users.noreply.github.com> Date: Wed, 17 Dec 2025 22:53:06 -0700 Subject: [PATCH 3/4] Migration to Arm not allowed for this category --- .../servers-and-cloud-computing/arm-mcp-server/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md index af23ed3e12..4e1edaa6f7 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md @@ -20,7 +20,7 @@ author: Joe Stech ### Tags skilllevels: Introductory -subjects: Migration to Arm +subjects: Performance and Architecture armips: - Neoverse tools_software_languages: From 7a6adb5eccdc2122a2175e4362f62cf82ac0818a Mon Sep 17 00:00:00 2001 From: pareenaverma Date: Thu, 18 Dec 2025 15:52:58 -0500 Subject: [PATCH 4/4] Mark Arm MCP Server migration topic as draft Set the draft status for the Arm MCP Server migration topic. --- .../servers-and-cloud-computing/arm-mcp-server/_index.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md index 4e1edaa6f7..0da6d8a260 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/arm-mcp-server/_index.md @@ -1,6 +1,10 @@ --- title: Migrate an x86 application to Arm using the Arm MCP Server +draft: true +cascade: + draft: true + minutes_to_complete: 20 who_is_this_for: This is an introductory topic for software developers who want to use AI-powered tools to migrate x86 applications to Arm-based cloud instances.