# Claude Code

## About this Install Guide

| Reading time:         | 10 min             |
|-----------------------|--------------------|
| Last updated:         | 7 Aug 2026         |
| Ecosystem dashboard:   | [View](https://developer.arm.com/ecosystem-dashboard/windows?package=Claude%20Code) |

This guide shows you how to install and use the tool with the most common configuration. For advanced options and complete reference information, see the official documentation. Some install guides also include optional next steps to help you explore related workflows or integrations.

Claude Code is an AI-powered command-line tool that helps you build features, debug code, and navigate codebases directly from your terminal. It provides autonomous coding assistance and integrates with your existing development workflow.

Claude Code works seamlessly on Arm-based systems, including Linux distributions running on Arm servers, macOS on Apple Silicon, and Windows on Arm devices.

## Review prerequisites

You need a Claude account to use Claude Code. A Claude.ai account is recommended, though you can also use a Claude Console account.

If you don’t have a Claude account, visit [Claude.ai](https://claude.ai/) and sign up.

Claude Code is only available for paid Pro and Max accounts, if not using API credits. Visit [Claude Pricing](https://www.anthropic.com/pricing) to review the options.

## Install Claude Code

Claude Code is a terminal application that works on macOS, Linux, and Windows systems, including Arm-based platforms.

### Install on Linux (Arm)

The recommended installation method for Linux uses the installation script:

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

This script automatically detects your system architecture and installs the appropriate version for Arm64 systems.

Add Claude Code to your PATH:

```bash
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
```

### Install on macOS (Apple Silicon)

On macOS, you can use the installation script:

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

Or install using Homebrew:

```bash
brew install --cask claude-code
```

### Install on Windows on Arm

On Windows systems, including Windows on Arm, run the following PowerShell command:

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

For other options, please [see the Claude Code setup page](https://code.claude.com/docs/en/setup).

## Verify installation

Confirm Claude Code is installed by checking the version:

```bash
claude --version
```

The output shows the installed version:

```plaintext
__output__ 2.1.7 (Claude Code)
```

## Authenticate Claude Code

After installing Claude Code, you need to authenticate:

Navigate to a project directory:

```bash
cd your-project
```

Start Claude Code:

```bash
claude
```

Configure your preferences when prompted (dark mode, editor settings, etc.).

On first use, Claude Code prompts you to authenticate:
- If using Claude.ai, authenticate through your browser.
- If on a remote machine, paste the provided link into a local browser, then enter the authentication code in Claude Code.

Accept the acknowledgements to complete setup.

Claude Code automatically saves your authentication credentials for future sessions.

## Confirm Claude Code is working

Test Claude Code by asking it to perform a simple task.

Start Claude Code in a project directory:

```bash
claude
```

Type a request, for example:

```plaintext
> Create a Python function to calculate fibonacci numbers for my Arm machine
```

Claude Code analyzes your request, creates a plan, and generates the code.

Review the proposed changes before accepting them. Claude Code shows you a preview of changes before applying them, giving you control over what gets modified in your codebase.

If Claude Code doesn’t respond:
- Verify you’re authenticated (run `claude` and check for authentication prompts).
- Check your internet connection.
- Ensure your Claude account is active.
- Try restarting Claude Code.

You’re now ready to use Claude Code.

<details>
<summary>Note</summary>
The sections below are optional and cover advanced integrations, including using MCP servers with Claude Code on Arm.
</details>

## Use MCP Servers with Claude Code

Model Context Protocol (MCP) Servers extend Claude Code’s capabilities by providing specialized tools and knowledge bases. Claude Code can connect to MCP servers to access domain-specific expertise and functionality.

The Arm MCP Server provides AI assistants with tools and knowledge for Arm architecture development, migration, and optimization. This is particularly useful when working on Arm-based systems.

## Arm MCP Server tools

The Arm MCP Server includes several tools designed for Arm development:
- migrate-ease scan: Analyzes codebases for x86-specific code that needs updating for Arm compatibility.
- skopeo: Inspects container images to check for ARM64 architecture support.
- knowledge_base_search: Searches Arm documentation and learning resources.
- mca (Machine Code Analyzer): Analyzes assembly code for performance on Arm architectures.
- check_image: Verifies Docker image architecture compatibility.

## Configure the Arm MCP Server with Claude Code

You need Docker running on your system to use the Arm MCP Server. See the [Docker install guide](/install-guides/docker/) for instructions.

First, pull the Arm MCP Server image:

```bash
docker pull armlimited/arm-mcp:latest
```

Configure the Arm MCP Server using the `claude mcp add` command. You can configure MCP servers at three different scopes:
- Local scope (default): Available only to you in the current project.
- Project scope: Shared with everyone in the project via `.mcp.json` file.
- User scope: Available to you across all projects.

<details>
<summary>Note</summary>
Choose the appropriate scope based on your needs. Project scope is recommended for team collaboration, while user scope is useful for personal tools you use across multiple projects.
</details>

### Configure for a specific project (local scope)

Navigate to your project directory and add the Arm MCP Server:

```bash
cd your-project
claude mcp add --transport stdio arm-mcp -- docker run --rm -i --pull=always -v "$(pwd):/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:latest
```

This configuration is stored in `~/.claude.json` under your project’s path and is only accessible when working in this directory.

### Configure for all projects (user scope)

To make the Arm MCP Server available across all your projects:

```bash
claude mcp add --scope user --transport stdio arm-mcp -- docker run --rm -i --pull=always -v "$(pwd):/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:latest
```

This configuration is stored in `~/.claude.json` and is accessible from any project directory.

### Configure for team sharing (project scope)

To share the MCP server configuration with your team via version control:

```bash
cd your-project
claude mcp add --scope project --transport stdio arm-mcp -- docker run --rm -i --pull=always -v "$(pwd):/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:latest
```

This creates a `.mcp.json` file in your project root that can be committed to version control.

## Analyze a local codebase with the Arm MCP Server

The Arm MCP Server automatically mounts your current working directory to the `/workspace` folder inside the Docker container when you use the configuration commands shown above.

To analyze a different directory, modify the volume mount in the `docker run` command. For example, to analyze `/Users/username/myproject`:

```bash
claude mcp add --transport stdio arm-mcp -- docker run --rm -i --pull=always -v "/Users/username/myproject:/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:latest
```

To enable Arm Performix features through the Arm MCP Server, replace `/path/to/your/ssh/private_key` and `/path/to/your/ssh/known_hosts` with the SSH private key and `known_hosts` file used for your target device.

### Optional: Use a Docker replacement containerization tool

You can use other containerization tools besides Docker that are free and do not require licenses, such as Podman, Finch, Colima, and Rancher Desktop. Choose one of the options below and use its CLI in place of `docker`.

#### Install: [Podman](https://podman.io/docs/installation)

Pull the Arm MCP Server image:

```bash
podman pull armlimited/arm-mcp:latest
```

To make the Arm MCP Server available across all your projects (user scope):

```bash
claude mcp add --scope user --transport stdio arm-mcp -- podman run --rm -i --pull=always -v "$(pwd):/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:latest
```

This configuration is stored in `~/.claude.json` and is accessible from any project directory. You can choose other scopes (local or project) as described in the Docker section above.

#### Install: [Finch](https://runfinch.com/docs/getting-started/installation/)

Pull the Arm MCP Server image:

```bash
finch pull armlimited/arm-mcp:latest
```

To make the Arm MCP Server available across all your projects (user scope):

```bash
claude mcp add --scope user --transport stdio arm-mcp -- finch run --rm -i --pull=always -v "$(pwd):/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:latest
```

This configuration is stored in `~/.claude.json` and is accessible from any project directory. You can choose other scopes (local or project) as described in the Docker section above.

#### Install: [Colima](https://github.com/abiosoft/colima#installation)

Colima provides a Docker-compatible CLI via Docker contexts.

Pull the Arm MCP Server image:

```bash
docker pull armlimited/arm-mcp:latest
```

To make the Arm MCP Server available across all your projects (user scope):

```bash
claude mcp add --scope user --transport stdio arm-mcp -- docker run --rm -i --pull=always -v "$(pwd):/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:latest
```

This configuration is stored in `~/.claude.json` and is accessible from any project directory. You can choose other scopes (local or project) as described in the Docker section above.

#### Install: [Rancher Desktop](https://docs.rancherdesktop.io/getting-started/installation/)

Rancher Desktop uses the Docker container engine via Morby.

Pull the Arm MCP Server image:

```bash
docker pull armlimited/arm-mcp:latest
```

To make the Arm MCP Server available across all your projects (user scope):

```bash
claude mcp add --scope user --transport stdio arm-mcp -- docker run --rm -i --pull=always -v "$(pwd):/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:latest
```

This configuration is stored in `~/.claude.json` and is accessible from any project directory. You can choose other scopes (local or project) as described in the Docker section above.

## Verify the Arm MCP Server is working

List configured MCP servers:

```bash
claude mcp list
```

You should see `arm-mcp` in the list of configured servers.

Get details about the Arm MCP Server configuration:

```bash
claude mcp get arm-mcp
```

To test the server’s functionality, start Claude Code and ask it to use the Arm MCP tools:

```bash
claude
```

Then try one of these prompts:

```plaintext
> Use the Arm MCP Server to scan my codebase for x86-specific code
```

or

```plaintext
> Check if the nginx:latest Docker image supports Arm64
```

You can also use the `/mcp` command within Claude Code to see the status of all connected MCP servers and their available tools.

## Example prompts using the Arm MCP Server

Here are some example prompts that use the Arm MCP Server tools:
- `Scan my workspace for code that needs updating for Arm compatibility`
- `Check if the postgres:latest container image supports Arm64 architecture`
- `Search the Arm knowledge base for Neon intrinsics examples`
- `Find learning resources about migrating from x86 to Arm`
- `Analyze this assembly code for performance on Arm processors`

## Manage MCP servers

Remove an MCP server:

```bash
claude mcp remove arm-mcp
```

Update an MCP server configuration by removing and re-adding it with new settings.

Check MCP server status within Claude Code:

```plaintext
> /mcp
```

## Troubleshoot MCP Server connections

If the Arm MCP Server doesn’t connect:
- Verify Docker is running: `docker ps`
- Check that the image was pulled successfully: `docker images | grep arm-mcp`
- Ensure the volume mount path exists and is accessible
- Check that the Docker daemon is running and accessible
- Try restarting Claude Code after configuration changes
- Review the output of `claude mcp get arm-mcp` for configuration errors

If you encounter issues or have questions, reach out to [mcpserver@arm.com](mailto:mcpserver@arm.com).

## Custom prompts and workflows

Create custom prompts for common tasks in your workflow. Refer to the [Claude Code documentation](https://code.claude.com/docs) for advanced configuration options.