# Which AI Assistants Are Compatible with Desktop Commander MCP: Complete Integration Guide

> Discover compatible AI assistants for Desktop Commander MCP. This guide details integration with Claude, ChatGPT, Gemini, Ollama, and more, enabling seamless voice control.

- Repository: [Eduard Ruzga/DesktopCommanderMCP](https://github.com/wonderwhy-er/DesktopCommanderMCP)
- Tags: deep-dive
- Published: 2026-07-26

---

**Desktop Commander MCP works with any AI assistant capable of sending HTTP requests to an MCP server, including Claude Desktop, ChatGPT, Gemini, and Ollama.**

Desktop Commander MCP is an open-source tool that exposes your local filesystem and terminal through the Model Context Protocol (MCP). According to the wonderwhy-er/DesktopCommanderMCP source code, the server implements standard MCP endpoints that any compatible AI client can invoke via JSON-over-HTTP, making it universally accessible to both local and remote AI assistants.

## Officially Supported AI Platforms

The repository explicitly documents support for two primary integration methods: native MCP server integration with Claude Desktop, and generic HTTP endpoint access for remote AI services.

### Claude Desktop (Automatic Configuration)

Claude Desktop receives first-class support through automatic configuration. The installer script at [`setup-claude-server.js`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/setup-claude-server.js) writes an entry directly into Claude Desktop's configuration file, registering Desktop Commander as a local MCP server.

The configuration entry points to the Node.js executable via npx:

```json
{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": [
        "-y",
        "@wonderwhy-er/desktop-commander@latest"
      ]
    }
  }
}

```

Once added to [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json), Claude Desktop automatically detects the server and exposes all filesystem and terminal tools within the chat interface without additional client-side code.

### ChatGPT and Remote AI Assistants (HTTP Endpoint)

Any AI assistant capable of HTTP tool calling can connect through the **Remote MCP** gateway at `https://mcp.desktopcommander.app`. This includes:

- **ChatGPT** via function calling APIs
- **Claude Web** through Connectors
- **Google Gemini** using tool calls
- **Ollama** and other local models with HTTP capabilities

The remote endpoint accepts standard MCP protocol requests, enabling AI assistants to execute commands on your local machine from cloud-based interfaces.

## How Desktop Commander MCP Works Under the Hood

The compatibility stems from a unified architecture defined in [`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts). This file implements the core MCP HTTP API that handles request parsing, route registration, and handler dispatch for filesystem and terminal operations.

### Local Server Architecture

The Node.js server defined in [`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts) exposes MCP endpoints locally when invoked by Claude Desktop. The server spawns child processes for terminal commands and streams filesystem operations back to the client using the MCP protocol specification.

### Remote Gateway Architecture

The same [`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts) implementation is exposed publicly through the Remote MCP gateway. As documented in [`src/remote-device/README.md`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/remote-device/README.md), this gateway proxies HTTP requests to your local Desktop Commander instance, allowing external AI services to invoke tools without direct network access to your machine.

## Integration Code Examples

### Claude Desktop Integration

No client code is required. After running the installer or manually adding the configuration to [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json), Claude Desktop automatically populates its tool palette with Desktop Commander capabilities.

### ChatGPT Function Calling

To invoke Desktop Commander from ChatGPT, configure the tool endpoint as follows:

```json
{
  "name": "desktop-commander",
  "url": "https://mcp.desktopcommander.app",
  "method": "POST",
  "body": {
    "type": "request",
    "command": "readFile",
    "arguments": { "path": "src/server.ts", "encoding": "utf8" }
  }
}

```

ChatGPT sends this JSON payload to the remote gateway and receives file contents in the response, which it can then display or analyze.

### Generic HTTP Client (Gemini, Ollama, etc.)

Any AI assistant capable of HTTP POST requests can invoke the server using standard MCP formatting:

```bash
curl -X POST https://mcp.desktopcommander.app \
  -H "Content-Type: application/json" \
  -d '{
        "type":"request",
        "command":"listDirectory",
        "arguments":{"path":"src","depth":1}
      }'

```

The response returns a JSON object containing directory listings, which the AI assistant parses to understand project structure.

## Key Implementation Files

Understanding these source files helps clarify the compatibility architecture:

- **[`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts)** – Implements the HTTP API and MCP request handlers for filesystem and terminal operations
- **[`setup-claude-server.js`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/setup-claude-server.js)** – Automated installer that writes MCP configuration entries to Claude Desktop's config
- **[`src/remote-device/README.md`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/remote-device/README.md)** – Documentation for external AI service integration via Remote MCP
- **[`plugin.yaml`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/plugin.yaml)** – Smithery marketplace metadata listing supported AI clients and configuration schemas

## Summary

- **Claude Desktop** integrates automatically through [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json) entries written by [`setup-claude-server.js`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/setup-claude-server.js)
- **ChatGPT and cloud AI assistants** connect via `https://mcp.desktopcommander.app` using standard HTTP tool calling
- **Universal compatibility** applies to any AI capable of JSON-over-HTTP requests, including Gemini and Ollama
- **Core implementation** resides in [`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts), which exposes both local and remote MCP endpoints
- **Protocol standardization** ensures Desktop Commander MCP works with any Model Context Protocol-compliant client

## Frequently Asked Questions

### Does Desktop Commander MCP require Claude Desktop to function?

No. While Claude Desktop receives automatic configuration through the MCP server protocol, Desktop Commander MCP operates independently. The server in [`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts) exposes HTTP endpoints that any AI assistant can access, including ChatGPT, Gemini, or custom local models running through Ollama.

### What is the Remote MCP endpoint URL for connecting external AI assistants?

The official Remote MCP gateway is `https://mcp.desktopcommander.app`. As documented in [`src/remote-device/README.md`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/remote-device/README.md), this endpoint accepts standard MCP protocol requests via HTTP POST, allowing cloud-based AI services to invoke local filesystem and terminal tools securely.

### Can I use Desktop Commander MCP with local AI models like Ollama?

Yes. Any local AI model capable of making HTTP requests can interact with Desktop Commander MCP. Configure the model to POST JSON payloads to either the local server instance (when running standalone) or the Remote MCP gateway, following the request format defined in [`src/server.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/server.ts).

### How does the automatic Claude Desktop configuration work?

The [`setup-claude-server.js`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/setup-claude-server.js) script automatically detects your Claude Desktop installation and appends a server entry to [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json). This entry specifies the npx command to launch the Desktop Commander server, enabling Claude Desktop to spawn the process and communicate via stdin/stdout using the MCP protocol.