Arm MCP Server

Official

Arm's official MCP server for architecture migration and optimization

How to install ↓ Compare GitHub source repository ↗

Category: Dev Tools #108 of 438
Stars: ★ 91 Popular
Transport: stdio (local process)
Runtime: Docker
Credentials: No credential needed
License: Apache-2.0
Last commit: 1 day ago

61FMRS · C

An officially maintained Arm server focused on x86-to-Arm migration analysis, container architecture inspection, and assembly performance analysis, distributed via Docker over stdio, requiring a local workspace mount with optional SSH configuration for Arm Performix remote performance capture.

Strongest · Documentation 15/20 Weakest · Reliability 9/20

Reliability

9/20

Security and permissions

11/20

Maintenance

13/20

Documentation

15/20

Setup experience

13/20

Why each score

Reliability 9/20: The manifest declares a single OCI package (docker.io/armlimited/arm-mcp:2.12.0) with stdio transport, and the README describes building the image, configuring multiple clients, and running integration tests (pytest tests/test_mcp.py). Tool descriptions (migration analysis, container architecture inspection, assembly performance analysis, Performix remote execution) are specific and internally consistent with no visible contradictions. However, no actual CI workflow files or committed test code are present in the reviewed material — only prose references to a test script. Per the static calibration rule, reliability cannot exceed 12 without verifiable CI plus committed tests, so this is capped and further reduced for unverifiable claims; whether declared tool behavior matches implementation, and how well timeouts/errors (README notes 'timeout errors during migration scans' as a known issue) are controlled, cannot be confirmed from the given evidence.
Security and permissions 11/20: The server runs via Docker with clearly scoped mount examples (workspace directory; optional SSH private key and known_hosts, both user-supplied paths, both isRequired:false and off by default), with no hardcoded credentials or real tokens present. The README proactively discloses that mcp-traffic.jsonl and error_logging.yaml record tool inputs and project information, and advises users to review these before sharing — a good data-boundary disclosure practice. However, the server includes the ability to execute Arm Performix workflows against a remote target device over SSH, and neither the README nor the manifest describes any confirmation step or scope limitation before such remote command execution occurs; the sensitive operation lacks an explicit user-confirmation flow. The container also defaults to `--pull=always` from Docker Hub, introducing a supply-chain dependency. These risks are visible but not fully mitigated in the documentation, which is a deduction though not a red-line violation.
Maintenance 13/20: The project is Apache-2.0 licensed, not archived, has only 3 open issues, 90 stars, and a version number (2.12.0) indicating iterative releases; the README distinguishes prod/stage/dev image tagging conventions, showing some release governance awareness. However, no commit history, changelog, security-response channel (e.g., SECURITY.md), or dependency-update process is evidenced in the provided material, so issue-response speed and maintenance cadence cannot be assessed — deducted for missing evidence.
Documentation 15/20: The README is well-layered, covering prerequisites, multi-arch Docker builds, concrete configuration examples for five mainstream clients (Claude Code, GitHub Copilot, Kiro CLI, Gemini CLI, and TOML-based clients), log file disclosure with a privacy reminder, troubleshooting (timeouts, empty workspace, architecture mismatches), integration testing steps, and contribution guidelines — all reviewable and substantive. It falls short of full marks because it lacks detailed per-tool parameter/input schema documentation, authentication details for Arm Performix, and any discussion of cost implications, which are hidden assumptions left undocumented.
Setup experience 13/20: The README provides a clear path from building the image to working configuration in five mainstream clients, with copy-pasteable JSON/TOML examples, plus a pre-built multi-arch image option (`armlimited/arm-mcp:latest` on Docker Hub) that avoids local builds. Still, setup requires manual path substitution, platform-specific build flag selection, and manual handling of known issues like scan timeouts. Per the static calibration rule, setup cannot exceed 15 without verifiable execution evidence, so the score is capped there and further reduced for the manual/fragile steps involved.

Static review · not runListed 2026-08-26

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the network

Best for

Teams planning or executing an x86-to-Arm application migration
DevOps engineers verifying multi-architecture support in container images
Systems and embedded developers tuning performance on Arm platforms

Not for

General development tasks unrelated to Arm architecture, migration, or performance
Environments that can't run Docker or don't allow mounting the local filesystem
Users unwilling to review locally generated log files that may contain project details before sharing them

Required permissions

Requires mounting a local workspace directory into the container at /workspace, giving it read access to project code
Optionally mounts an SSH private key and known_hosts file for Arm Performix remote target access
Requires Docker execution rights to pull and run the container image

Risks and side effects

Generated log files (mcp-traffic.jsonl and error_logging.yaml) may contain project code snippets and tool call content — review before sharing
Mounting an SSH private key for remote access could expose credentials if misconfigured
The container needs local filesystem access via the workspace mount, which carries some path-exposure risk

Setup

Before you start

Runtime：Docker

Install Docker with buildx support
Build the image from the repo root with docker buildx build -f mcp-local/Dockerfile -t armlimited/arm-mcp ., or use the official pre-built image armlimited/arm-mcp:latest from Docker Hub
Add a docker run --rm -i entry to your MCP client's config (e.g. Claude Code's .mcp.json, VS Code's .vscode/mcp.json, Kiro's ~/.kiro/settings/mcp.json, Gemini CLI's .gemini/settings.json, or a TOML config for Codex CLI), mounting -v /path/to/your/workspace:/workspace
If using Arm Performix remote execution, also mount your SSH private key and known_hosts file
Restart your MCP client to load the server.

.mcp.json

{"mcpServers":{"arm-mcp":{"command":"docker","args":["run","--rm","-i","--pull=always","-v","/path/to/your/workspace:/workspace","-v","/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro","-v","/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro","armlimited/arm-mcp"]}}}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json

{
  "servers": {
    "arm-mcp": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--pull=always",
        "-v",
        "/path/to/your/workspace:/workspace",
        "-v",
        "/path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro",
        "-v",
        "/path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro",
        "armlimited/arm-mcp"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal

claude mcp add arm-mcp -- docker run --rm -i --pull=always -v /path/to/your/workspace:/workspace -v /path/to/your/ssh/private_key:/run/keys/ssh-key.pem:ro -v /path/to/your/ssh/known_hosts:/run/keys/known_hosts:ro armlimited/arm-mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Restart your MCP client and confirm the Arm MCP server's tools (e.g. knowledge base search, code migration analysis) appear in the tool list; for debugging, run docker run --rm -it --entrypoint /bin/bash armlimited/arm-mcp to inspect the container.

Troubleshooting

Timeout errors during migration scans: increase the timeout value in your MCP client config (e.g. 120000 ms)
Empty workspace: verify the volume mount path is correct and the directory exists
Architecture mismatches: rebuild for your specific platform using --platform linux/amd64 or linux/arm64
Docker Hub tag semantics: `latest` and semantic version tags (e.g. 2.3.0) are production, dated tags (YYYY-MM-DD-<run_number>) are staging, and locally built images are dev-only

Things to try

Once connected, you can ask your AI assistant things like:

Scan my codebase for x86-to-Arm migration compatibility issues
Search the Arm knowledge base for NEON intrinsics documentation
Check whether this Docker image supports linux/arm64 architecture
Analyze the performance of this assembly code with LLVM-MCA

Use cases

Scan an existing codebase to assess x86-to-Arm migration compatibility

Check whether Docker images support multiple architectures, including Arm64

Analyze assembly code performance characteristics on Arm architecture

Run performance capture and analysis workflows on a remote Arm target device over SSH

Search Arm documentation, intrinsics, and software compatibility knowledge

Supported clients

Claude Code

VS Code

AWS Kiro CLI

Gemini CLI

Codex

Listed from the project's documentation, not tested by this site.

Overview

Arm MCP Server is Arm's officially maintained Model Context Protocol server, giving AI assistants tools and knowledge for Arm architecture development, migration, and optimization. It integrates migrate-ease code compatibility scanning (C++, Python, Go, JavaScript, Java), Skopeo-based container image architecture inspection, LLVM-MCA assembly performance analysis, semantic search across Arm documentation and compatibility data, and Arm Performix (APX) recipe workflows that run over SSH against a remote target device to capture and analyze workload performance. The server ships as a Docker image, communicates over stdio, and requires a local workspace directory mount (plus optional SSH keys for Arm Performix remote access).

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 62.9k · Tools 2 Compare with this →

NPM Sentinel MCP Server 79 · B

AI-powered NPM package analysis MCP server

★ 18 · Tools 19 Compare with this →

MartinLoop MCP Server 79 · B

An independent control layer that gives AI coding agents budgets, brakes, and receipts

★ 409 Compare with this →

GitHub MCP Server 76 · B

GitHub's official MCP server for managing repos, issues, PRs, and workflows via natural language

★ 33.5k · Tools 15 Compare with this →

Compare with other MCP servers

Source revision 6e7ecf6343a9 Data synced 2026-10-11 Read the FMRS scoring method