How to Set Up Model Context Protocol (MCP) in Claude

MCP is a universal adapter: one protocol connecting Claude to files, databases, repositories, and APIs.

Out of the box, Claude is brilliant but sealed off — it can reason about your problem but can't read your files, query your database, or open a ticket in your system. The Model Context Protocol (MCP) is what removes that wall. It is an open standard, introduced by Anthropic and now supported across the ecosystem, that gives Claude a safe, structured way to reach the tools and data you point it at. This guide is built to be the one you bookmark: the prerequisites, the exact configuration for both Claude Desktop and Claude Code, real interface examples, and the security context a technical reader actually needs. If you are evaluating MCP to connect Claude to business systems rather than a personal setup, ITECS handles that architecture through AI consulting — but this article is about getting it running yourself.

What MCP Actually Is

Think of MCP as a universal adapter. Before it, every AI-to-tool integration was bespoke. MCP standardizes the connection: an MCP server exposes a set of capabilities (tools, resources, prompts), and an MCP client — Claude Desktop or Claude Code — discovers and calls them through the same protocol regardless of what the server does underneath.

Hardware Requirements and Recommendations

MCP is lightweight — the "requirements" are really runtime prerequisites, not horsepower. MCP servers are small processes that sleep until Claude calls them; there is no model to load and no GPU involved. Any machine that comfortably runs the Claude app can run a dozen MCP servers.

Path A: Set Up MCP in Claude Desktop

Claude Desktop is configured through a single JSON file. This is the most common path for connecting Claude to local tools.

Step 1: Open the config file

The fastest route is through the app itself: open Settings → Developer → Edit Config. That opens (and creates, if needed) the configuration file at:

# macOS
~/Library/Application Support/Claude/claude_desktop_config.json

# Windows
%APPDATA%\Claude\claude_desktop_config.json

Here is what the Developer settings panel looks like — the Edit Config button is what opens the file:

Simulated Claude Desktop Developer settings: "Edit Config" opens claude_desktop_config.json.

Step 2: Add a server to the config

Servers live under an mcpServers object. Each entry has a name you choose, a command to launch it, its args, and optional env variables for secrets. This example registers the official filesystem and GitHub servers:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/Projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Step 3: Fully restart Claude Desktop

Config changes are read at launch. Closing the window is not enough — you must completely quit the app (Cmd+Q on macOS, or Exit from the system tray on Windows) and reopen it. On restart, Claude launches each server as a subprocess and discovers its tools.

Step 4: Verify and approve

A working setup shows an MCP/tools indicator in the chat input, and the first time Claude wants to use a tool it asks for your approval. That approval prompt is the security boundary — you see exactly which tool is being called before it runs:

Simulated tool-approval dialog: Claude shows the exact server, tool, and arguments before running anything.

The easier alternative: Desktop Extensions

If editing JSON isn't your preference, Claude Desktop also supports Desktop Extensions — one-click installable packages that bundle an MCP server and its dependencies. They install like a browser extension and write the config for you. Use them for popular servers; drop to manual JSON when you need a custom server, specific arguments, or environment variables an extension doesn't expose.

Path B: Set Up MCP in Claude Code

Claude Code, the terminal-based agent, manages MCP servers through the claude mcp command instead of a hand-edited file — faster for developers already living in the shell.

Add a local (stdio) server

Use claude mcp add, and note the -- separator: everything after it is the command Claude runs, kept distinct from Claude's own flags.

# Syntax: claude mcp add <name> --transport stdio -- <command> [args...]
claude mcp add filesystem --transport stdio -- \
  npx -y @modelcontextprotocol/server-filesystem ~/Projects

# A Python (uvx) server example
claude mcp add serena -- uvx --from git+https://github.com/oraios/serena serena

Add a remote (HTTP) server

Remote servers connect over HTTP. (SSE, the older remote transport, was deprecated in favor of HTTP in early 2026 — use http for new setups.)

claude mcp add --transport http company-tools https://mcp.example.com/mcp

Choose a scope

Scope decides who sees the server. This is the detail teams get wrong most often:

Verify

claude mcp list          # from the shell
# or, inside a Claude Code session:
/mcp                      # shows connection status and available tools

Troubleshooting the Common Failures

• Server shows as failed or never connects: the runtime isn't on PATH. Confirm node --version / uv --version run in the same shell Claude launches from, and use absolute paths to npx/uvx if needed.
• Config edits do nothing: you didn't fully quit Claude Desktop. Close the window and quit the app, then reopen.
• Tools don't appear: validate the JSON — a trailing comma or unquoted key breaks the whole file silently. Paste it through a JSON linter.
• Secrets not working: environment variables go in the server's env block (Desktop) or are passed to the launch command (Claude Code) — never commit them to a shared .mcp.json.
• Remote server rejected: confirm you're using --transport http, not the deprecated sse, and that any auth token is being sent.

The Security Reality of MCP

This is the part that matters most for anyone connecting Claude to real work, and it is easy to skip. An MCP server runs with your privileges. A filesystem server pointed at your home directory can read every file in it; a shell or database server can do whatever your account can do. The tool-approval prompts are a genuine control, but they do not sandbox the server — they gate individual calls.

Practical hygiene: install servers only from sources you trust; prefer official (@modelcontextprotocol/*) or well-known vendors; scope filesystem and database servers to the narrowest path or read-only role that works; keep secrets in env blocks, never in shared config; and review what a server can do before granting "Allow always." Content a server returns should be treated as untrusted input — a malicious document could contain instructions aimed at the model, so the human-in-the-loop approval matters. This is exactly the review discipline a security-managed endpoint program applies to any new software on a business machine.

From Personal Setup to Business Capability

Wiring Claude into your own filesystem and GitHub takes ten minutes and transforms how much it can actually do for you. Connecting Claude — safely — into a company's systems is a different scope: which data it can reach, who approves what, where remote MCP servers are hosted, and how it's all governed. That is the work of turning a clever demo into a dependable internal capability, and it's precisely what ITECS builds as a Managed Integration Provider — operationalizing AI with the access controls, hosting, and oversight a business needs.

Sources

• Model Context Protocol — "Connect to Local MCP Servers"
• Claude Help Center — "Getting Started with Local MCP Servers on Claude Desktop"
• Claude Code Docs — "Connect to MCP Servers"
• Anthropic — "Desktop Extensions: One-click MCP server installation"
• Model Context Protocol — Official Specification & Server Registry