MCP server tutorial 2026: install, configure, run

What MCP actually is

The Model Context Protocol is a specification published by Anthropic in November 2024. It defines a standard way for language models to call external tools — and for external tools to expose themselves to models. Before MCP, every AI tool integration was custom; MCP makes integrations composable.

The architecture is simpler than the name suggests. An MCP server is a process that runs on your machine (or remotely, for hosted servers). When Claude Code starts, it launches each configured MCP server, receives a list of the tools that server provides, and can then call those tools by name during any session. All communication happens over stdin/stdout using JSON-RPC 2.0. No HTTP, no ports, no network configuration for local servers.

A deeper conceptual treatment is in the What is MCP primer. This post focuses on the practical setup.

Where the config lives

MCP server configuration lives in a settings.json file. There are two locations:

• ~/.claude/settings.json — global; applies to every Claude Code session on this machine
• .claude/settings.json (in a project directory) — project-level; applies only when Claude Code runs in that directory, and overrides the global config for the named keys

The project-level file is the one to prefer for project-specific servers (a database server scoped to one project's connection string). The global file is for servers you want everywhere (Fetch, GitHub).

The basic config structure

The mcpServers key in settings.json is a map from server name to server configuration. Each server configuration specifies how to start the server process.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/directory"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_fine_grained_token_here"
      }
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

A few notes on this structure:

• The -y flag on npx installs the package if it is not already present. This is convenient during setup but slightly slower on first launch. You can pin a version to avoid this: @modelcontextprotocol/server-filesystem@0.6.0.
• Credentials go in the env object, not as command-line args. Args are logged; environment variables are not (by default).
• Server names (the keys) are arbitrary — they are only used in error messages and Claude's tool descriptions.

The five servers to install first

{
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_TOKEN": "github_pat_..."
    }
  }
}

{
  "playwright": {
    "command": "npx",
    "args": ["-y", "@playwright/mcp@latest"]
  }
}

{
  "fetch": {
    "command": "uvx",
    "args": ["mcp-server-fetch"]
  }
}

Verifying a server is working

After editing your settings.json, start a new Claude Code session. At the prompt, ask Claude to list the available tools:

What MCP tools do you have access to?

Claude should list the servers you configured and their available tools. If a server is missing, the failure is usually one of three things:

1. The package is not installed. The -y flag on npx will install it, but the first run can fail if npm's registry is slow or your network has a firewall. Run the npx command manually in a terminal to see the error.
2. The path is wrong. The Filesystem server takes an absolute path. A relative path or a path with a typo will cause a startup failure. Claude Code logs MCP server errors to ~/.claude/logs/ — check there first.
3. The credential is invalid. If the server starts but its tools return errors, the most common cause is an expired or misconfigured API key. Test the credential directly in curl or the provider's API playground before debugging the MCP layer.

Project-level vs. global configuration

A common pattern at Septim: global config has Fetch, Memory, and Playwright — servers that are useful in any project. Project-level config has Filesystem (with the project root as the allowed path), the project's database server, and GitHub (scoped to the project's repo).

This structure means you can drop into any project directory and have Claude Code automatically pick up the right servers without manually toggling configs. The project-level file overrides the global file for servers with the same name, so you can have different database connections per project without them conflicting.

Remote MCP servers

Anthropic added support for remote MCP servers (accessed over SSE rather than stdio) in early 2026. The configuration uses a url key instead of command and args:

{
  "mcpServers": {
    "stripe": {
      "url": "https://mcp.stripe.com",
      "headers": {
        "Authorization": "Bearer sk_live_..."
      }
    }
  }
}

Remote servers are convenient for services that maintain their own hosted MCP endpoints (Stripe and several others do). The tradeoff is a network round-trip per tool call and the credential going over the wire — use HTTPS-only remotes and treat the authorization header the same way you would an API key in an environment variable.

Security considerations before you add more servers

Each server you add expands the attack surface of your Claude Code session. The MCP server vulnerability checklist covers the 24-point evaluation framework. The short version for tutorials:

• Only install servers with an active organizational maintainer or a backing company
• Read the tool descriptions in the source before installing — malicious instructions embedded in tool metadata are a documented attack vector (arXiv 2603.22489)
• Use the minimum credential scope — a GitHub token for reading one repo should not have write access to all repos
• Keep .claude/settings.json out of git if it contains credentials

The full curated list of servers worth running — each with its security caveat — is in the best MCP servers 2026 post.