Claude Desktop Extensions: One-Click MCP Server Installation

TL;DR

• Desktop Extensions (.mcpb files) eliminate the need for manual MCP server installation—no more editing JSON configs or installing runtimes
• Anthropic ships Node.js with Claude Desktop, handles automatic updates, and stores API keys in the OS keychain
• The MCPB spec is open source, meaning any AI desktop app can support the same extension format
• If you've built an MCP server, you can now package it for millions of users with three CLI commands

The Big Picture

MCP servers are powerful. They let Claude access your file system, query databases, and integrate with local dev tools—all while keeping data on your machine. But getting them running has been a nightmare.

You needed Node.js or Python installed. You had to manually edit ~/.claude/claude_desktop_config.json. Dependency conflicts were common. Updates meant doing it all over again. The result? MCP servers remained a developer-only feature, despite their potential.

Desktop Extensions solve this. Anthropic is introducing a new packaging format—.mcpb files—that bundles an entire MCP server and its dependencies into a single installable package. Download it, double-click, install. That's the entire process.

This isn't just a UX improvement. It's a distribution model. If you've built an MCP server, you can now reach non-technical users. And because Anthropic is open-sourcing the spec, any AI desktop app can support the same extensions. Build once, run everywhere.

How It Works

A Desktop Extension is a ZIP archive with a .mcpb extension. Inside, you'll find a manifest.json file that describes the server, its dependencies, and its configuration requirements. The rest of the archive contains the server code and any bundled libraries.

The manifest is where the magic happens. It tells Claude Desktop everything it needs to know: what runtime the server uses (Node.js, Python, or a binary), what command to run, what environment variables to set, and what configuration the user needs to provide.

Here's a minimal example:

{
  "mcpb_version": "0.1",
  "name": "my-extension",
  "version": "1.0.0",
  "description": "A simple MCP extension",
  "author": {
    "name": "Extension Author"
  },
  "server": {
    "type": "node",
    "entry_point": "server/index.js",
    "mcp_config": {
      "command": "node",
      "args": ["${__dirname}/server/index.js"]
    }
  }
}

The ${__dirname} template literal gets replaced at runtime with the extension's installation directory. Claude Desktop handles the rest—no user intervention required.

For servers that need user input, the manifest supports a user_config section. Declare what you need, and Claude Desktop will prompt the user with a friendly UI:

"user_config": {
  "api_key": {
    "type": "string",
    "title": "API Key",
    "description": "Your API key for authentication",
    "sensitive": true,
    "required": true
  }
}

Sensitive values like API keys are stored in the OS keychain—not in plaintext config files. When the server launches, Claude Desktop injects them as environment variables or command-line arguments, depending on how you configure the manifest.

The architecture is deliberately simple. Anthropic ships Node.js with Claude Desktop, so Node-based extensions work out of the box. Python extensions rely on the system Python, but the manifest can specify version requirements. Binary extensions are also supported for platform-specific tools.

Cross-platform support is built in. You can define platform-specific overrides in the manifest:

"server": {
  "type": "node",
  "entry_point": "server/index.js",
  "mcp_config": {
    "command": "node",
    "args": ["${__dirname}/server/index.js"],
    "platforms": {
      "win32": {
        "command": "node.exe",
        "env": {
          "TEMP_DIR": "${TEMP}"
        }
      },
      "darwin": {
        "env": {
          "TEMP_DIR": "${TMPDIR}"
        }
      }
    }
  }
}

This means you can ship a single .mcpb file that works on Windows, macOS, and Linux without modification.

The manifest also supports feature declarations—a way to tell users upfront what tools and prompts your extension provides:

"tools": [
  {
    "name": "read_file",
    "description": "Read contents of a file"
  }
],
"prompts": [
  {
    "name": "code_review",
    "description": "Review code for best practices",
    "arguments": ["file_path"]
  }
]

This isn't just documentation. It helps users understand what they're installing before they click the button.

What This Changes For Developers

If you've built an MCP server, you can now distribute it to millions of Claude Desktop users. No more GitHub README instructions. No more support requests about Node.js versions. Package it once, and it works.

The packaging process is straightforward. Anthropic provides a CLI tool that handles the heavy lifting:

npm install -g @anthropic-ai/mcpb
mcpb init
mcpb pack

The init command walks you through creating a manifest. The pack command validates it and generates the .mcpb file. That's it.

For distribution, Anthropic is launching a curated extension directory built into Claude Desktop. Users can browse, search, and install extensions without leaving the app. To get your extension listed, you submit it through a Google Form. Anthropic reviews for quality and security, then adds it to the directory.

This is a big deal for MCP server developers. Before, your audience was limited to people willing to edit JSON files. Now, it's anyone using Claude Desktop. The barrier to entry just dropped to zero.

The open-source spec matters too. Anthropic is releasing the full MCPB specification, packaging tools, and reference implementation code. This means other AI desktop apps can support the same extension format. Build your extension once, and it could run in multiple apps—not just Claude Desktop.

For enterprises, Desktop Extensions introduce new management capabilities. Admins can pre-install approved extensions, blocklist specific publishers, or disable the extension directory entirely. Group Policy (Windows) and MDM (macOS) support is built in. This makes MCP servers viable in locked-down environments where manual configuration isn't an option.

The security model is worth noting. Extensions run locally, so data never leaves the user's machine. Sensitive configuration is stored in the OS keychain, not in plaintext files. Automatic updates mean users get security patches without manual intervention. And because the extension directory is curated, there's a review process before anything goes live.

Anthropic is also betting on Claude Code to help developers build extensions. Internally, they've been using Claude to generate MCPB packages with minimal human intervention. The workflow: describe what you want the extension to do, point Claude at the MCPB spec, and let it generate the manifest and server code. This could lower the barrier even further—if you can describe the tool, Claude can build it.

Try It Yourself

If you have an existing MCP server, packaging it as a Desktop Extension takes about five minutes. Here's the full process:

First, install the MCPB CLI:

npm install -g @anthropic-ai/mcpb

Navigate to your MCP server's directory and initialize a manifest:

mcpb init

The CLI will ask you a series of questions: server type (Node.js, Python, or binary), entry point, required configuration, etc. If you want to skip the questions and generate a minimal manifest, use mcpb init --yes.

Once the manifest is generated, review it and make any necessary edits. Pay attention to the user_config section if your server needs API keys or other user input.

Package the extension:

mcpb pack

This creates a .mcpb file in your current directory. To test it, drag the file into Claude Desktop's Settings window. You'll see a preview of the extension with install and configuration options.

For a complete example, check the examples in the MCPB repository. The "Hello World" example is a good starting point.

The Bottom Line

Use Desktop Extensions if you've built an MCP server and want to reach non-technical users. The packaging process is trivial, and the distribution model—curated directory, one-click install—is a massive upgrade over GitHub READMEs.

Skip it if your MCP server is highly experimental or requires frequent manual updates. The extension directory has a review process, so rapid iteration isn't ideal. For internal tools or bleeding-edge experiments, the old manual installation method still works.

The real opportunity here is ecosystem growth. MCP servers have already proven their value for cutting agent costs and improving reliability. Desktop Extensions remove the last major barrier to adoption. If you've been sitting on an MCP server idea because distribution seemed too hard, that excuse just evaporated.

The open-source spec is the wildcard. If other AI desktop apps adopt MCPB, this becomes a universal extension format for local AI tools. That's a much bigger deal than just making Claude Desktop easier to extend. It's a bet on interoperability—and if it works, it could define how local AI tooling evolves over the next few years.

Source: Anthropic