# How to Integrate MCP Servers with Claude Desktop: A Complete Configuration Guide

> Integrate MCP servers with Claude Desktop using a standard JSON-RPC interface. Follow our complete configuration guide to add your server endpoint to config.json.

- Repository: [Frank Fiegel/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
- Tags: how-to-guide
- Published: 2026-09-04

---

**Yes, Claude Desktop can integrate with any MCP server that exposes a standard JSON‑RPC interface by adding the server endpoint to the `mcpServers` configuration array in `~/.claude/desktop/config.json`.**

Claude Desktop supports the Model Context Protocol (MCP) to extend its capabilities with external tools and data sources. According to the `punkpeye/awesome-mcp-servers` repository, this integration allows Claude to call third-party servers that implement the three core JSON‑RPC methods—`list_tools`, `get_schema`, and `call_tool`—enabling the model to query databases, scrape web pages, or interact with APIs while maintaining secure, sandboxed execution.

## Understanding the MCP Integration Architecture

The MCP protocol defines a language-agnostic standard for tool discovery and execution. Claude Desktop acts as the MCP client, forwarding requests to configured servers and injecting responses back into the conversation.

The architecture requires servers to expose three essential JSON‑RPC methods:
- **`list_tools`** – Returns a catalog of available tools and their metadata
- **`get_schema`** – Provides detailed input/output schemas for type safety
- **`call_tool`** – Executes the requested tool with typed arguments and returns structured results

Servers can communicate over **HTTP** or **STDIO** transports and must publish either a [`manifest.json`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/manifest.json) or `mcp_manifest` file describing their capabilities. When Claude Desktop initializes, it fetches each manifest, merges the tool definitions, and presents them to the model as native functions available in the conversation context.

## Configuring Claude Desktop for MCP Servers

Integration requires editing Claude Desktop's user configuration file to register each MCP server endpoint.

### Locating the Configuration File

Claude Desktop stores MCP server definitions in the user configuration directory:

```json
~/.claude/desktop/config.json

```

Alternatively, you can manage entries through the UI via the "MCP Servers" panel, which writes to this same file.

### Defining the mcpServers Array

The configuration file expects a top-level `mcpServers` key containing an array of server objects. Each entry requires a `name` and `url`, with optional authentication parameters:

```json
{
  "mcpServers": [
    {
      "name": "MySQLiteServer",
      "url": "http://localhost:8000/mcp",
      "auth": {
        "type": "Bearer",
        "token": "PLACEHOLDER"
      }
    },
    {
      "name": "WayStation",
      "url": "https://mcp.waystation.ai",
      "auth": null
    }
  ]
}

```

When Claude Desktop starts, it parses this array, validates connectivity to each endpoint, and aggregates the tool manifests into the model's context window.

## MCP Server Requirements and Manifest Structure

For successful integration, MCP servers must meet specific protocol requirements.

**Protocol Compliance:**
- Implement JSON‑RPC 2.0 over HTTP or STDIO
- Expose the three core methods (`list_tools`, `get_schema`, `call_tool`)
- Serve a valid manifest at a well-known location or respond to manifest discovery requests

**Manifest Discovery:**
The server must provide a [`manifest.json`](https://github.com/punkpeye/awesome-mcp-servers/blob/main/manifest.json) (or equivalent `mcp_manifest`) that Claude Desktop fetches during initialization. This manifest describes available tools, their descriptions, and parameter schemas, enabling the model to understand when and how to invoke specific functions.

## Authentication and Security Models

Claude Desktop supports multiple authentication schemes while maintaining secure execution boundaries.

**Authentication Configuration:**
The `auth` object in the configuration supports Bearer tokens and other credential types. These credentials are sent with RPC requests but remain isolated from the model's context, ensuring sensitive tokens do not leak into conversation history.

**Sandboxed Execution:**
All tool calls execute within isolated sandboxes per-tool. Servers can enforce additional security measures including:
- Rate limiting
- Token-based pay-per-call schemes (e.g., x402)
- IP restrictions

Because authentication headers are handled at the transport layer, MCP servers maintain full control over authorization logic without exposing secrets to Claude Desktop's UI or model context.

## Practical Integration Examples

The `punkpeye/awesome-mcp-servers` repository catalogs several working implementations, including WayStation and aimarket-plugins, which demonstrate real-world integration patterns.

**Local Development Server:**
A Python-based SQLite MCP server running locally exposes tools for database queries:

```json
// RPC request from Claude Desktop
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "call_tool",
  "params": {
    "tool": "sqlite_query",
    "arguments": {
      "sql": "SELECT name, email FROM contacts WHERE active = true"
    }
  }
}

```

**Server Response:**

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "rows": [
      { "name": "Alice", "email": "alice@example.com" },
      { "name": "Bob",   "email": "bob@example.com" }
    ],
    "count": 2
  }
}

```

Claude Desktop receives this structured result and injects it into the conversation, allowing the model to generate a natural language response: "Here are the active contacts: Alice (alice@example.com) and Bob (bob@example.com)."

## Summary

- Claude Desktop integrates MCP servers through a JSON‑RPC interface defined in `~/.claude/desktop/config.json`
- The `mcpServers` array registers endpoints with optional Bearer token authentication
- Servers must implement `list_tools`, `get_schema`, and `call_tool` methods over HTTP or STDIO
- Tool execution occurs in sandboxed environments with server-controlled authentication
- The `punkpeye/awesome-mcp-servers` repository provides curated examples including WayStation and local development servers

## Frequently Asked Questions

### What file format does Claude Desktop use for MCP configuration?

Claude Desktop uses a JSON configuration file located at `~/.claude/desktop/config.json`. This file contains a top-level `mcpServers` array where each object specifies the server's name, URL, and optional authentication credentials. The UI's "MCP Servers" panel provides a graphical interface for editing this same configuration structure.

### Do MCP servers require specific authentication headers?

Authentication is optional but supported through the `auth` object in the configuration. Servers can require Bearer tokens, API keys, or other credential types. These headers are attached to JSON‑RPC requests by Claude Desktop but remain invisible to the model, ensuring secure credential handling while maintaining the ability to enforce rate limits or pay-per-call schemes like x402.

### Can I run MCP servers locally or only as hosted services?

MCP servers can run locally or as remote hosted services. The protocol is transport-agnostic, supporting both HTTP endpoints (for local development on `localhost` or remote APIs) and STDIO for subprocess communication. The `punkpeye/awesome-mcp-servers` repository lists implementations in Python, Node.js, Go, and Rust that can operate in either deployment mode.

### How does Claude Desktop discover available tools from an MCP server?

On startup, Claude Desktop sends a `list_tools` JSON‑RPC request to each configured endpoint. The server returns a manifest describing available tools, their descriptions, and input schemas. Claude Desktop merges these definitions into the model's context, enabling the AI to request `call_tool` operations with properly typed arguments when the conversation requires external data or computation.