MCP Servers and Configuration

This page covers the two levers that connect Claude Code to the outside world and tune it for daily use: MCP, which lets the agent reach external tools and data, and settings.json, where you control permissions, environment, models, and automation. Both are grounded in this team's actual setup.

Who this is for. MCP is a concept everyone benefits from understanding; the settings.json section is hands-on for engineers configuring their machine or sharing config with teammates.

Reaching external systems with MCP, and the settings scopes that share config — 1 min 19 s.

What MCP is and why it matters

The Model Context Protocol (MCP) is an open standard for connecting AI applications to external systems — data sources, tools, and workflows. The official description is apt: MCP is "like a USB-C port for AI applications." One standard plug, and the agent can read your docs, query a database, drive a browser, or hit an internal API.

This matters because a model on its own only knows what's in its prompt and its (fixed, dated) training. MCP closes that gap: instead of you copying data out of another tool and pasting it into chat, Claude reads and acts on that system directly. Connect a server whenever you find yourself ferrying information back and forth by hand.

The MCP servers in this setup

Server	What it unlocks	Reach for it when
context7	Fetches current, version-accurate documentation for libraries, frameworks, and SDKs by name	You're using a fast-moving library and don't want the model guessing stale API syntax. Installed via the context7 plugin.
claude-in-chrome	Drives your Chrome browser — navigate, click, fill forms, screenshot, read the console and network requests	Debugging a live web app, reproducing a UI bug, or automating a browser task with real devtools signal.
wake-mcp	Solidity / smart-contract analysis (annotate, search, status, dump)	Auditing or reasoning about Solidity code; pairs well with the entry-point-analyzer plugin.
Google Workspace (Gmail, Calendar, Drive)	Read/search email and threads, manage calendar events, search and read Drive files	Pulling a spec out of Drive, scheduling from a session, or triaging mail without leaving the agent.
stripe	Stripe's hosted MCP server for payments work	Building or debugging a Stripe integration (ships with the stripe plugin).

Some MCP tools are deferred — surfaced by name and loaded on demand — so the agent only pays for what it actually uses in a given session.

How MCP servers are configured

MCP servers are declared in JSON and can live at three scopes:

• User — available across all your projects.
• Project (.mcp.json at the repo root) — checked into git so the whole team gets the same servers. This is the only scope that uses .mcp.json.
• Local — just you, just this repo, not shared. Local-scope servers are stored in ~/.claude.json keyed by the project's path (not in a repo file). Don't confuse this with .claude/settings.local.json, which holds your gitignored settings for the repo — a different file for a different purpose.

Each server entry names a transport. The common ones:

• stdio — Claude launches a local process and talks to it over stdin/stdout. Example, as the context7 plugin ships it:

  {
    "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] }
  }
  

• http (and sse) — Claude connects to a remote URL. Example, as the stripe plugin ships it:

  {
    "mcpServers": {
      "stripe": { "type": "http", "url": "https://mcp.stripe.com" }
    }
  }
  

You can also add servers from the CLI with claude mcp add .... The fastest way to wire up your first one end to end is the official MCP quickstart (see Sources).

Note: several of this team's servers (context7, stripe) arrive bundled inside plugins rather than hand-configured — installing the plugin brings the server with it. That's the easiest way to adopt an MCP server: install a plugin that already packages it.

Practical settings.json

Settings files configure Claude Code's behavior. They live at predictable locations and merge by precedence.

Scope	Location	Affects
User	~/.claude/settings.json	You, across all projects
Project	.claude/settings.json	Everyone on the repo (committed to git)
Local	.claude/settings.local.json	You, this repo only (gitignored)
Managed	IT-deployed policy file	Org-wide, can't be overridden

Precedence, highest to lowest: Managed → CLI args → Local → Project → User. Permission rules merge across scopes rather than replacing each other.

Useful knobs

Permissions allowlist — the single biggest quality-of-life win. Every command you pre-approve is a prompt you never see again. Add the read-only and routine commands you trust to permissions.allow, and block the dangerous or secret-revealing ones in permissions.deny:

{
  "permissions": {
    "allow": [
      "Bash(yarn test:*)",
      "Bash(npm run:*)",
      "Bash(git diff:*)",
      "Bash(grep:*)",
      "mcp__plugin_context7_context7__query-docs"
    ],
    "deny": [
      "Read(./.env)",
      "Read(**/.env.*)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(~/.ssh/**)"
    ],
    "defaultMode": "default"
  }
}

This mirrors the real allow/deny lists in this setup: a broad allowlist of test/lint/build/git/read commands, and a deny list that keeps secrets (.env, .pem, .key, .ssh) off-limits no matter what mode you're in. For the reasoning behind allow/ask/deny rules and how they fit least-privilege, see Security, permissions & sandboxing.

Sandboxing. Claude Code also ships a built-in sandbox setting that isolates the filesystem and network, so commands run inside a confined boundary instead of touching your whole machine — a lighter alternative to spinning up a container for riskier or less-supervised work. See Security, permissions & sandboxing for when to reach for it.

Environment variables apply to every session and spawned subprocess. This setup uses, among others:

{
  "env": {
    "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "64000",
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

• CLAUDE_CODE_MAX_OUTPUT_TOKENS raises the cap on tokens Claude can produce in a single response — useful for large refactors, long plans, or generating sizable files in one pass.
• CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS turns on experimental agent teams, where a lead agent coordinates several subagents working in parallel on different parts of a task.

Model selection and aliasing. model sets the default; you can also remap the named tiers via env vars. This setup aliases the Sonnet and Haiku slots to Opus 4.8 (ANTHROPIC_DEFAULT_SONNET_MODEL / ANTHROPIC_DEFAULT_HAIKU_MODEL both set to claude-opus-4-8), so subagents and lighter tasks that would normally drop to a smaller model instead run on Opus. Heavier on tokens, stronger on results — a deliberate trade. Note that the Haiku slot also powers behind-the-scenes work (auto-memory writes, conversation summaries, and similar background calls), so aliasing it to Opus routes all of that onto Opus too — real results, real token cost. For how to pick the right tier per task, see Choosing Models.

Hooks. Hooks run shell commands at lifecycle events (e.g. PostToolUse after an edit, Stop when a task finishes). This setup uses them for desktop notifications:

{
  "hooks": {
    "Stop": [
      { "hooks": [{ "type": "command", "command": "notify-send 'Claude Code' 'Task completed'" }] }
    ]
  }
}

Common uses beyond notifications: auto-formatting after every edit, running lint before a commit, or a PreToolUse hook that hard-blocks an action regardless of what the model decides (stronger than a CLAUDE.md instruction).

Plugins. enabledPlugins records which installed plugins are active, and extraKnownMarketplaces registers non-default catalogs — see Skills, Plugins, and MCP.

Sane defaults to recommend a teammate

• Start in default permission mode; loosen per-task with Shift+Tab, not globally.
• Build a permissions allowlist over time. Add the test/lint/build/git commands you keep approving. Keep a deny list for .env, keys, and .ssh.
• Commit a project CLAUDE.md with build/test commands and conventions; keep personal tweaks in gitignored CLAUDE.local.md. (See Memory and Project Rules.)
• Install the LSP plugin for your language so diagnostics are real, not guessed.
• Keep secrets in deny, never in allow. Project settings are shared — don't commit anything machine-specific or sensitive there; use local settings for that.

Related

• Getting Started · Skills, Plugins, and MCP · Superpowers and Workflows
• Memory and Project Rules

Sources

• Model Context Protocol — https://modelcontextprotocol.io/introduction
• Connect Claude Code to tools via MCP — https://code.claude.com/docs/en/mcp
• MCP quickstart — https://code.claude.com/docs/en/mcp-quickstart
• Settings — https://code.claude.com/docs/en/settings
• Permission modes — https://code.claude.com/docs/en/permission-modes
• Hooks — https://code.claude.com/docs/en/hooks
• Environment variables — https://code.claude.com/docs/en/env-vars