Tips on how to Join MCP Servers to Claude (Desktop & Code)

Connecting MCP servers to Claude permits it to work with exterior instruments, information, databases, repositories, and different techniques as an alternative of working solely inside the chat window. The setup differs barely between Claude Desktop and Claude Code, however each will be configured in just some steps.

On this article, you’ll learn to join MCP servers with Claude Desktop and Claude Code, a sensible step-by-step information for getting every setup operating accurately.

What Is MCP and Why Does It Matter?

MCP (Mannequin Context Protocol) is the common connector layer that lets any AI mannequin speak to any exterior instrument by means of a single standardised interface with out customized integration code for each mixture.

Earlier than MCP, connecting Claude to GitHub required one customized integration. Connecting it to Slack required a distinct one. Connecting it to your database required a 3rd. Anthropic referred to as this the “N×M downside”: N AI fashions occasions M exterior instruments meant N×M bespoke connectors. MCP solves it by turning that into N+M. Construct one MCP server for GitHub, and each MCP-compatible AI consumer Claude, Cursor, Windsurf, and dozens extra can use it instantly.

How MCP Works in 3 Easy Elements

Understanding the 3-part structure takes 2 minutes and prevents 90% of setup confusion.

Once you ask Claude to “test my open GitHub PRs”, here’s what occurs behind the scenes:

Claude identifies it wants an exterior instrument to fulfil the request.

The MCP consumer in Claude sends a JSON-RPC request to the GitHub MCP server.

The server queries GitHub’s API and returns structured information.

Claude incorporates that information into its context and generates your reply.

The entire move takes below a second. You by no means see the plumbing.

As of April 2026, Streamable HTTP is Anthropic’s official advisable transport, and the older SSE transport is being deprecated.

Claude Desktop: Step-by-Step MCP Setup

Claude Desktop reads its MCP configuration from a single JSON file. There are two methods to put in servers: the brand new one-click Desktop Extensions (.mcpb information, previously .dxt) and the standard JSON config technique. Use Extensions for supported servers; use JSON config for something customized.

Technique 1: Desktop Extensions (One-Click on, No JSON)

As of early 2026, Claude Desktop helps Desktop Extensions, pre-packaged MCP servers distributed as .mcpb information (MCP Bundle; older guides might name these .dxt information, which nonetheless work however are the legacy title). These set up with a double-click. No JSON modifying, no Node.js PATH points.

Open Claude Desktop.

Click on the “+” button within the bottom-left of the chat enter.

Choose “Connectors” to open the connectors menu.

Discover your server (e.g., GitHub, Google Drive) and click on Set up (or Click on onn add connectors to search out one on the connectors listing).

Restart Claude Desktop. The server prompts robotically.

Desktop Extensions are the precise alternative for non-technical customers or servers you wish to “set and overlook.” The JSON config technique beneath is correct for customized servers, non-public servers, or full management over arguments and surroundings variables.

Technique 2: JSON Config (Full Management)

Claude Desktop reads its MCP configuration from claude_desktop_config.json. The file location is determined by your OS:

macOS: ~/Library/Utility Assist/Claude/claude_desktop_config.json

Home windows: %APPDATApercentClaudeclaude_desktop_config.json

On Home windows, which folder really has this file is determined by the way you put in Claude Desktop, and this journeys up lots of people. There are two fully completely different areas:

Direct .exe installer (from claude.ai/downloads): %APPDATApercentClaudeclaude_desktop_config.json

Microsoft Retailer, WinGet, or MSIX set up: %LOCALAPPDATApercentPackagesClaude_pzs8sxrjxfjjcLocalCacheRoamingClaudeclaude_desktop_config.json

If %APPDATApercentClaude doesn’t exist in your machine, you virtually definitely have the Retailer/MSIX set up, and your actual file is at that second, uglier path. Home windows’ app-packaging mannequin silently redirects it there as an alternative of the usual location each piece of documentation assumes.

If neither path has the file but, open Claude Desktop itself, go to Settings → Developer → Edit Config. That creates the file at whichever path your particular set up really makes use of, so that you don’t must guess.

One Home windows-specific lure: paths inside JSON want double backslashes. C:UsersyournameDocuments in a JSON string have to be written as C:CustomersyournamePaperwork, a single backslash breaks the JSON parser. Right here’s what a whole, accurately escaped config seems like:

Modifying the Config File

Open Claude Desktop → high menu bar → Settings → Developer → Edit Config. This opens the file in your default editor and creates it if it doesn’t exist.

The file has only one top-level key, mcpServers. Consider it as a listing of servers you need Claude to find out about. Every server will get its personal entry inside that listing, and also you choose no matter title you need for that entry (like “filesystem” or “github” beneath).

Inside every server’s entry, there are three issues you may set:

command: the precise program Claude runs to start out that server (often npx, since most servers are distributed as npm packages)

args: the listing of arguments handed to that command, precisely such as you’d kind them in a terminal

env: any surroundings variables the server wants, mostly API keys or entry tokens

Right here’s a sensible starter config for a developer workflow: filesystem entry, GitHub integration, and net search:

{
“mcpServers”: {
“filesystem”: {
“command”: “/usr/native/bin/npx”,
“args”: [“-y”, “@modelcontextprotocol/server-filesystem”,
“/Users/yourname/Documents”, “/Users/yourname/projects”]
},
“github”: {
“command”: “/usr/native/bin/npx”,
“args”: [“-y”, “@modelcontextprotocol/server-github”],
“env”: {
“GITHUB_PERSONAL_ACCESS_TOKEN”: “ghp_your_token_here”
}
},
“brave-search”: {
“command”: “/usr/native/bin/npx”,
“args”: [“-y”, “@modelcontextprotocol/server-brave-search”],
“env”: { “BRAVE_API_KEY”: “your_brave_api_key” }
}
}
}

What’s taking place in every of the three servers:

filesystem doesn’t want any credentials, so it solely has command and args. The args listing tells npx which package deal to run (@modelcontextprotocol/server-filesystem) and which folders in your pc it’s allowed to the touch, on this case Paperwork and initiatives.

github must show who you’re to GitHub’s API, so it has an additional env block. GITHUB_PERSONAL_ACCESS_TOKEN is the place you paste your personal GitHub token. The server reads it as an surroundings variable when it begins up, the identical means a program run out of your terminal would.

Getting a GitHub token, step-by-step:

Go to github.com and sign up. Click on your profile picture within the top-right nook, then click on Settings.

Within the left sidebar, click on Developer settings (it’s close to the underside).

Click on Private entry tokens, then High-quality-grained tokens, then Generate new token. GitHub now recommends fine-grained tokens over the older “basic” ones, since you may restrict them to particular repos as an alternative of your complete account.

Give it a Token title (something memorable, like “claude-mcp”), and set an Expiration. GitHub warns in opposition to “no expiration” for good motive, choose 90 days and put a renewal reminder in your calendar.

Beneath Useful resource proprietor, choose your private account (or the group whose repos you want). Beneath Repository entry, select Solely choose repositories and choose simply those Claude really wants, not all of them.

Beneath Permissions, grant solely what you’ll use. For many workflows, Contents (learn and write) and Points (learn and write) cowl it. Add Pull requests (learn and write) if you’d like Claude opening or reviewing PRs.

Click on Generate token on the backside, then copy it instantly. GitHub exhibits a fine-grained token precisely as soon as, when you navigate away earlier than copying it, you’ll must generate a brand new one.

That token (it begins with github_pat_) is what goes instead of “ghp_your_token_here” within the JSON config above:

“GITHUB_PERSONAL_ACCESS_TOKEN”: “github_pat_your_actual_token”

brave-search follows the identical sample as github: one command, one args listing to run the precise package deal, and one env variable for its API key.

That’s the entire sample. Each server you ever add to this file follows the identical form: a reputation you select, a command to run it, arguments to configure it, and (if it must authenticate) an env block for its secrets and techniques.

Claude Code: Including MCP Servers through CLI

Claude Code has its personal MCP configuration floor separate from Claude Desktop, and it comes with a devoted CLI command that makes setup sooner than modifying JSON manually.

You possibly can set up Claude Code following this information: Claude Code Information

Have already got servers arrange in Claude Desktop? Run claude mcp add-from-claude-desktop (macOS or WSL) to repeat them straight into Claude Code as an alternative of re-adding each by hand.

Including a Server with claude mcp add

The essential syntax is:

claude mcp add — [args…]

That’s the sample for a neighborhood server, one Claude Code runs itself as a subprocess. Hosted servers reached over a URL use –transport http as an alternative and skip the — command solely:

claude mcp add –transport http docs-server https://instance.com/mcp

Hosted servers want no Node.js, no native course of, and nothing to put in. They’re the simplest first server to strive. Native servers, just like the Postgres instance beneath, want a command Claude Code can really run in your machine.

For a Postgres database server:

claude mcp add –transport stdio project-db
— npx -y @modelcontextprotocol/server-postgres
postgresql://localhost:5432/mydb

Claude Code helps three scopes for server configuration:

To confirm setup, run:

claude mcp listing

The standing column tells you precisely what’s taking place:

If it exhibits something aside from “Linked”, run the precise set up command manually in your terminal. The error it prints is much extra helpful than something within the standing line.

The Finest MCP Servers to Set up First

The MCP ecosystem has over 2,300 public servers in Might 2026. Most are deserted demos. Those beneath are actively maintained, production-tested, and canopy 80% of actual workflows. My trustworthy take: set up 3–5 servers most to start out. Each server provides its instrument definitions to Claude’s context window, and a bloated instrument listing visibly degrades Claude’s tool-selection high quality.

For builders, the sensible starter pack is GitHub + Filesystem + Context7. That mixture covers 80% of coding workflows with out burning context tokens on unused instruments.

Frequent Errors and Fixes

73% of first-time MCP customers hit not less than one connection error. Listed here are the 5 patterns that account for the overwhelming majority of failures, and the repair for every.

Error 1: Standing exhibits “Failed to attach” or “Connection error”

Each statuses imply the server didn’t begin, or an HTTP server’s URL didn’t reply. Run the precise set up command manually in your terminal and browse the error output straight. The three most typical causes: npx not present in PATH (use absolute path), flawed npm package deal title, or lacking surroundings variable. Repair the underlying error earlier than touching the Claude config.

If it’s a neighborhood server timing out on its first run (npx downloading the package deal for the primary time can take some time), elevate the startup timeout as an alternative of assuming it’s damaged:

MCP_TIMEOUT=60000 claude

Error 2: Instruments don’t seem after connecting

Use the /mcp slash command inside a Claude Code session to power a reconnect. If instruments nonetheless don’t seem, run claude mcp get an empty instrument listing means the server began however declared no instruments, often a server-side config error. Restart with the up to date server config.

Error 3: JSON syntax error silently breaks all servers

A single lacking comma or mismatched bracket in claude_desktop_config.json silently disables each server. Run your JSON by means of jsonlint.com or use jq to validate earlier than restarting Claude. That is the one most typical first-install failure mode.

Error 4: Relative paths fail

Claude Desktop begins MCP servers with an undefined working listing, so relative paths like ./mydir by no means resolve. At all times use absolute paths: /Customers/yourname/initiatives as an alternative of ~/initiatives or ./initiatives.

Error 5: Context window will get eaten by instrument definitions

One developer measured 30–40% of their Claude context window going to MCP instrument schemas that had been by no means utilized in that session. If Claude appears unusually gradual or costly, the perpetrator is nearly at all times too many related servers. Prune to the three–5 servers you really use in your present workflow. You possibly can at all times add extra later.

Sizzling take: most individuals who assume they want a higher-tier Claude plan really simply want fewer MCP servers loaded. The context price is invisible however important. For a comparability of Claude plan options and what they really unlock

Superior: Construct Your Personal MCP Server

Constructing a customized MCP server is the quickest technique to give Claude entry to inside instruments, proprietary APIs, or information that no public server covers. The Python SDK makes this surprisingly accessible: you outline instruments with decorators as an alternative of writing JSON schemas by hand.

The minimal viable MCP server in Python:

!pip set up mcp

from mcp.server.fastmcp import FastMCP

mcp = FastMCP(“my-server”)

@mcp.instrument()
def get_data(question: str) -> str:
“””Fetch information from my inside API.”””
return my_api.fetch(question)

if __name__ == “__main__”:
mcp.run()

Register it in your Claude Desktop config the identical means as every other server level command at your Python interpreter and args on the server file path.

One safety be aware that almost all tutorials skip: at all times use scoped permissions when connecting MCP servers. Grant read-only entry first, develop to put in writing entry solely when you could have confirmed the server behaves as anticipated. An MCP server with write entry to manufacturing techniques and a misinterpreted immediate can do actual injury.

Conclusion

Connecting MCP servers to Claude turns it right into a sensible assistant that may work with information, repositories, databases, APIs, and different exterior instruments. Claude Desktop affords easy setup by means of Extensions or JSON configuration, whereas Claude Code makes server set up and administration simple by means of the CLI.

One of the best method is to start out with just a few important servers, use absolute paths, safe your credentials, and grant solely the permissions required. As soon as configured accurately, MCP creates a dependable bridge between Claude and the instruments you already use. With that basis in place, Claude turns into much more succesful, helpful, and prepared for real-world workflows.

Incessantly Requested Questions