MCP Servers Worth Installing for Claude Code

TLDR verdict: MCP (Model Context Protocol) is the open standard for extending Claude Code with external data and actions. Eight servers cover the daily patterns of most teams: file system beyond CWD, GitHub, Postgres, Slack, web search, browser automation, SQLite, and Supabase. Install them in .claude/settings.json, restart the session, check /mcp to confirm they loaded.

This page walks through each server, the install command, the JSON config, and what it actually lets Claude do.

Quick recap of MCP

MCP is an open protocol Anthropic released in late 2024 and now co-maintains with the wider community. An MCP server exposes a set of tools and resources over stdio or HTTP. Any MCP-compatible client (Claude Code, Claude Desktop, Cursor, Cline, and others) can load the server and use its tools.

The win is that tool code lives in one place, gets reviewed, versioned, and reused across every AI client a team uses. No rewriting integrations for each new agent.

Servers are installed per project via .claude/settings.json under the mcpServers key, or globally in ~/.claude/settings.json. Project-level wins when both are set.

Server 1: filesystem

Gives Claude file-system access beyond the current working directory. Useful for cross-repo work or for reading config files that live outside the project.

Install and config:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects", "/Users/me/notes"]
    }
  }
}

The paths at the end are the roots the server can access. List every directory the agent should be able to read or write. Anything outside the list is blocked at the server level.

Key use cases: pulling a shared config from another repo, referencing a design spec in a notes folder, copying a file across projects.

Server 2: github

Full GitHub API access: read PRs and issues, create comments, open PRs, manage labels, list workflows. Saves the agent from calling gh as a shell command for every operation.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${GH_TOKEN}" }
    }
  }
}

Create a fine-grained Personal Access Token with only the scopes you need (repo read, pull requests write, issues write). Store it in an env var loaded from .env.local or a password manager; never commit the token itself.

Key use cases: auto-labeling issues, drafting PR descriptions from commit history, pulling the diff of a related PR to understand context, triaging bug reports.

Server 3: postgres

Read-only query access to a Postgres database. Claude can answer questions about schema or data without needing a separate SQL client.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgres://user:pass@localhost/mydb"]
    }
  }
}

The server is read-only by default. For a production database, use a read-only role with schema privileges limited to the tables the agent should see.

Key use cases: "how many rows in orders since Monday", "what columns does the users table have", "find duplicate emails in the signup log".

Server 4: slack

Send messages to Slack channels and read recent history. Useful for end-of-session notifications or for the agent to answer questions that need channel context.

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}",
        "SLACK_TEAM_ID": "${SLACK_TEAM_ID}"
      }
    }
  }
}

Create a Slack app with chat:write and channels:history scopes. Install to your workspace, copy the bot token, store in env.

Key use cases: "post a summary of the last merged PR to #eng", "check if anyone in #support has asked about this error today", "message @ayush that the deploy is done".

Server 5: brave-search

Web search from inside a session. Lets the agent look up current information, verify quotes, or find docs that are not already in the repo.

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "${BRAVE_API_KEY}" }
    }
  }
}

Brave offers a free tier with 2000 queries a month, generous for occasional use. Higher tiers start at 5 dollars a month.

Key use cases: looking up an error message, finding the latest API docs for a library, checking the release notes of a dependency before upgrading.

Server 6: puppeteer

Browser automation. The agent can open a URL, fill a form, click a button, and screenshot the result. Heavyweight but sometimes the only way.

{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Puppeteer downloads a Chromium binary on first run, which is about 170 MB. Keep that in mind for low-bandwidth environments.

Key use cases: scraping a dashboard that has no API, testing a login flow end to end, capturing a screenshot of a deployed page for a PR comment.

Server 7: sqlite

Query and edit SQLite databases. Lighter than the Postgres server and great for local dev databases or for the many apps that use SQLite under the hood.

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": ["-y", "mcp-server-sqlite", "--db-path", "./data/app.db"]
    }
  }
}

Path resolves against the project directory. Point at the dev database, not the production one; SQLite does not have separate roles.

Key use cases: inspecting a local cache, debugging a session-state table, running a quick aggregation that would be painful to write in code.

Server 8: supabase

Supabase MCP gives Claude access to a Supabase project: run SQL, manage tables, read edge function logs, inspect migrations. Essential if Supabase is your backend.

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase"],
      "env": {
        "SUPABASE_ACCESS_TOKEN": "${SUPABASE_TOKEN}",
        "SUPABASE_PROJECT_REF": "abc123"
      }
    }
  }
}

Generate a personal access token at supabase.com under account settings. The project ref is the short ID in your dashboard URL.

Key use cases: applying a migration, generating TypeScript types from the schema, reading edge function logs to debug a 500, inspecting row-level security policies.

Security considerations per server

Each MCP server runs with whatever credentials you give it. The threat model differs:

• filesystem: widest blast radius on a dev machine. Scope paths tightly; do not include your home directory root.
• github: scope the PAT to the minimum. A full-access PAT on a compromised machine is a supply-chain risk.
• postgres and sqlite: use read-only roles for production-shaped data. Never point the server at a write-enabled prod connection unless you want the agent to be able to drop tables.
• slack: limit the bot scopes. chat:write plus channels:history covers most uses.
• brave-search: low risk; rate-limit at the API key level.
• puppeteer: runs a full browser. Treat its network access the same as any other browser on the machine.
• supabase: same rules as postgres. Use a service role only when you must, and rotate often.

Installing and verifying

Three steps:

1. Edit .claude/settings.json to add the mcpServers block.
2. Make sure env vars are set in your shell or a .env loader.
3. Start a session and run /mcp to see which servers loaded and which failed.

A server that failed to load shows up in /mcp output with an error reason. Common causes: missing env var, npm install failure, wrong path. Fix the cause and restart the session; there is no hot reload.

Running servers in CI

Most of these servers also work in headless mode. The same mcpServers config applies. Just make sure the env vars are present in the runner; GitHub Actions secrets, GitLab masked variables, whatever your CI uses.

For CI-specific workflows, consider a minimal config that only loads the servers that job needs. Loading eight servers takes a few seconds; loading the two you need is instant.

Building custom MCP servers

When nothing off-the-shelf fits, build a custom server. The MCP SDK in TypeScript or Python handles the transport; you write the tool schemas and handlers. A small internal metrics server is usually 100 lines of TypeScript and a day of work.

See the Anthropic MCP docs for the SDK pattern. Start with one tool, ship it, add tools as the agent asks for them.

Cost

Most servers are free to run. The costs to watch:

• Brave Search: after 2000 queries a month, pay per query
• GitHub: API rate limits on the PAT, not a dollar cost
• Supabase: data transfer and compute at the project level, not the MCP server
• Puppeteer: no cost, but longer runs add token cost because the agent reads back large HTML dumps

Total cost for a typical week: about 10 dollars of token spend across all MCP interactions, plus whatever Brave charges if you run heavy search.

A realistic install order

Do not install all eight at once. Pick in this order:

1. filesystem - least risky, biggest immediate value
2. github - once you start running agent-driven PR work
3. brave-search - once you hit a question the agent cannot answer from the repo
4. sqlite or postgres - once you want to query a database from a session
5. slack - once you want notifications or channel context
6. supabase - if Supabase is your backend
7. puppeteer - last, because browser automation is the heaviest setup

Most teams end up with three or four running. That is enough to feel meaningful without drowning the /mcp output in noise.

Closing thought

MCP is the cleanest extension point in Claude Code today. A well-chosen set of servers turns the agent from a file-editor into something closer to a team member who can query data, ship PRs, post in chat, and look things up on the web. Start with one server, confirm it works, add the next. In two hours you have an agent with reach far beyond the repo.