How to Use MCP (Model Context Protocol)

MCP (Model Context Protocol) lets an AI tool call your files, GitHub, and databases through one standard interface - and in this guide you’ll connect two real servers, verify they work, and fix the errors that actually happen. If you set up Claude Code or built your first agent, MCP is the socket those tools plug into - no more copy-pasting data into chat.

What MCP is, in one breath

From the official docs: MCP is “an open-source standard for connecting AI applications to external systems.” The docs’ own analogy is the cleanest: “Think of MCP like a USB-C port for AI applications.” One standard connector, and any compatible device plugs in.

Every setup has two roles:

• MCP server - a small program that exposes capabilities (tools, resources, prompts). Examples: a filesystem server, GitHub’s server, a memory server.
• MCP client - your AI application (Claude Desktop, Claude Code, ChatGPT, VS Code/Copilot, Cursor, Codex, n8n). It discovers the server’s tools and calls them on your behalf, with your approval.

Before you start

• Node.js 18+ - the Filesystem and most reference servers run via npx. Check with node --version.
• An MCP-capable client. This guide uses Claude Desktop (config-file client) and Claude Code (command-line client) because they cover both configuration styles. The concepts carry to every other client.
• A client-version warning: MCP config schemas change between product versions. Every JSON block below was verified against the current official docs (MCP spec 2026-07-28) on 13 August 2026. If a screen doesn’t match, check your client’s version first.

Step 1: Connect the official Filesystem server

The Filesystem server is the protocol’s “hello world”: read, create, move, and search files - every action awaits your approval. Start it via the official package @modelcontextprotocol/server-filesystem.

Where you configure it depends on your client:

Claude Desktop - from the Claude menu, open Settings → Developer → Edit Config. Replace the contents of claude_desktop_config.json with this (macOS shown; on Windows the file is %APPDATA%\Claude\claude_desktop_config.json and paths use backslashes):

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/YOUR_USERNAME/Desktop",
        "/Users/YOUR_USERNAME/Downloads"
      ]
    }
  }
}

The args array’s trailing entries are the ONLY directories the server can touch. The official docs are blunt: “Only grant access to directories you’re comfortable with Claude reading and modifying.”

Claude Code - the same server, added as a local stdio (subprocess) server. Note the -- that separates Claude’s flags from the server’s command:

claude mcp add --transport stdio filesystem -- \
  npx -y @modelcontextprotocol/server-filesystem \
  /Users/YOUR_USERNAME/Desktop /Users/YOUR_USERNAME/Downloads

Other clients - VS Code uses .vscode/mcp.json with the same mcpServers block. The shape is shared; only the file location differs.

Step 2: Verify it worked

1. Restart the client completely - it only loads MCP config at startup.
2. Claude Desktop: click the paperclip/indicator in the input box, open Connectors → Manage connectors, and confirm filesystem is listed with its tools. Claude Code: run /mcp and look for a checked (✔) status.
3. Prove it, don’t trust it: ask Claude “list the files on my Desktop” or “create a file called test.md on my Desktop” - and notice it asks permission before acting. If you approve, the file appears.
4. Tools you see will be namespaced with the server prefix, e.g. mcp__filesystem__... (the exact tool list is visible in the connectors panel).

Every server action is logged. On macOS the logs live in ~/Library/Logs/Claude (mcp.log for connections, mcp-server-filesystem.log for the server’s own output); on Windows, %APPDATA%\Claude\logs. Follow them live:

tail -n 20 -f ~/Library/Logs/Claude/mcp*.log   # macOS / Linux

Step 3: Connect the official GitHub MCP server

GitHub ships its own MCP server (github/github-mcp-server). Two supported routes:

Route A - remote HTTP server (no install): GitHub hosts it at https://api.githubcopilot.com/mcp/. In Claude Code, add it with a personal access token as a header:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
  --header "Authorization: Bearer YOUR_GITHUB_PAT"

Create the token at github.com/settings/personal-access-tokens with fine-grained access to the repositories you want - the official README lists minimum scopes as repo, read:packages, read:org for the local server’s needs.

Route B - local Docker server (OAuth on first use): the official image is ghcr.io/github/github-mcp-server. It runs the browser OAuth login itself on first use, keeping the token in memory; the container needs a fixed callback port published to loopback. The official config (host JSON):

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-p", "127.0.0.1:8085:8085",
        "-e", "GITHUB_OAUTH_CALLBACK_PORT",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_OAUTH_CALLBACK_PORT": "8085"
      }
    }
  }
}

Prefer a token over OAuth? Set GITHUB_PERSONAL_ACCESS_TOKEN - the README states it takes precedence over OAuth.

Step 4: Verify GitHub connected

In Claude Code: run claude mcp list. Official statuses are ✔ Connected, ! Needs authentication, or ✘ Failed to connect - a failure means the client couldn’t reach or authenticate the server, not that the list command broke. claude mcp get github shows details. Then ask it to do something real: “list the open issues in MY_ORG/MY_REPO”.

In Docker: the binary ships a search/debug command. List the tools available to the model:

docker run -it --rm ghcr.io/github/github-mcp-server tool-search "issue" --max-results 5

Default tool groups (toolsets) are context, repos, issues, pull_requests, users - you can shrink the surface with GITHUB_TOOLSETS (e.g. read-only triage) or GITHUB_TOOLS for individual tools.

Troubleshooting

npx -y @modelcontextprotocol/server-filesystem /Users/YOUR_USERNAME/Desktop /Users/YOUR_USERNAME/Downloads

{
  "filesystem": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\YOUR_USERNAME\\Desktop"],
    "env": {
      "APPDATA": "C:\\Users\\YOUR_USERNAME\\AppData\\Roaming"
    }
  }
}

You did it

• You can explain MCP and both roles in one sentence each
• Your client shows the Filesystem server connected, with tools listed
• Claude created/read a file in an allowed directory - after your approval
• You followed a real mcp-server-filesystem.log line during a tool call
• Your GitHub server authenticates (OAuth or PAT) and exposes issues/PRs tools
• No token sits hardcoded in a config file that could be committed

Next: MCP servers are how your own agent gets real tools, and n8n ships a built-in MCP server so an AI tool can build your AI workflows for you. For the benchmark context on why agent tool-calling quality matters so much in 2026, our Terminal-Bench 2.1 explainer is the reference.