A Guide to One-Click Local AI Tools (MCP DXT)

The Pain of Powering Up Your AI

If you've ever tried to connect a local tool or script to an AI model, you know the drill. You find a cool project on GitHub, and the instructions hit you with a wall of commands: git clone, npm install, pip install -r requirements.txt, edit a .env file, and then, if you're lucky, you run a server from your terminal. It's a process that screams "for developers only."

This complexity has been a major hurdle for getting the most out of powerful frameworks like the Model Context Protocol (MCP). How can we give an AI assistant access to local files or apps if setting up the server is a project in itself?

Anthropic came up with a seriously clever answer: DXTs, or Desktop Extensions.

So, What's a DXT, Really?

Forget what you might think when you hear "extension." A DXT isn't a little UI widget. It's a server-in-a-box.

A DXT is a special .dxt file that bundles a complete server—code, dependencies, and all—into a single, tidy package. The magic is that a host application, like an AI desktop client, can run this server for you with a single click. No terminal, no manual setup. You download the .dxt file, open it, and it just works.

This is a game-changer for how we use AI. Suddenly, anyone can install a local mcp dxt server that, for example:

  • Lets an AI read and write to a specific project folder.
  • Gives an AI access to your local calendar or contacts.
  • Connects to a local database or other software on your machine.

The Anatomy of a DXT

Under the hood, a .dxt file is just a zip archive with two key ingredients:

  1. Your Server Code: This can be a Node.js app, a Python script, or even a pre-compiled binary. It’s the engine of your extension.
  2. A manifest.json File: This is the instruction manual. It tells the host application (like Claude Desktop) everything it needs to know: the name of your extension, what it does, how to run the server, and what settings the user might need to provide (like an API key).

The manifest is the core of the whole system. It defines the runtime ("node", "python", etc.), the entry point (e.g., server.js), and can even ask the user for configuration in a secure way. For instance, if your DXT needs an API key, the manifest can specify that, and the host app will provide a nice UI to ask the user for it, storing it safely in the system keychain.

Let's Build a Simple DXT

Time to build a "Hello, World" DXT. This will be a tiny Node.js server that just responds to a ping.

Step 1: Set Up Your Project

Create a folder called hello-server-dxt. Inside, we'll need three files:

  • package.json
  • server.js
  • manifest.json

Step 2: The Server

First, define your Node.js project in package.json. We'll use Express for a simple web server.

{
  "name": "hello-server-dxt",
  "version": "0.1.0",
  "main": "server.js",
  "dependencies": {
    "express": "^4.19.2"
  }
}

Next, create the actual server in server.js:

const express = require('express');
const app = express();
const port = process.env.PORT || 3000; // DXT host will provide the port

app.get('/', (req, res) => {
  res.send('Hello from your friendly DXT server!');
});

app.listen(port, () => {
  console.log(`DXT server listening on port ${port}`);
});

Don't forget to run npm install in your terminal to get the node_modules folder.

Step 3: The Manifest

Now for the magic part, the manifest.json. This tells the DXT runner how to handle our server.

{
  "name": "Hello Server",
  "version": "0.1.0",
  "author": "Your Name",
  "description": "A simple DXT that runs a 'Hello, World' server.",
  "server": {
    "type": "node",
    "entry_point": "server.js"
  }
}

This is a basic manifest. It declares that we have a node server and its main file is server.js. The DXT runner will automatically handle installing the express dependency from our package.json.

Step 4: Package It Up!

With these files in place, you're ready to create the .dxt package. Anthropic provides a command-line tool for this. Open your terminal in the hello-server-dxt directory and run:

npx @anthropic-ai/dxt pack .

This command will bundle your server.js, package.json, and node_modules into a single hello-server.dxt file. That's it! You've created a distributable, one-click server package.

A More Open Future for AI

DXTs are more than just a convenience. They represent a vision for an open, interoperable ecosystem of local AI tools. By open-sourcing the specification and tooling, Anthropic has paved the way for any developer to build and share mcp dxt extensions, and for any AI application to run them.

It’s a huge step toward making powerful AI capabilities accessible to everyone, not just developers. So, what will you build?