Devops Monk

The MCP (Model Context Protocol) ecosystem now has over 14,000 servers. Most of them you do not need. Installing too many slows responses, inflates your context window with tool definitions that never get used, and turns debugging into a guessing game across a dozen integrations.

This guide applies a simple filter: only install a server if it replaces a daily copy-paste workflow. It is organised by role — developers, QA testers, and DevOps/platform engineers — because the right stack is different for each.

How MCP Fits Into Your Workflow

flowchart TD
    User[Developer / Tester / DevOps] -->|natural language query| Claude[Claude Code]
    Claude -->|tool call| MCP[MCP Server]
    MCP -->|authenticated request| Service[External Service\nGitHub / Playwright / AWS etc]
    Service -->|structured data| MCP
    MCP -->|response| Claude
    Claude -->|answer + action| User

Without MCP, you copy-paste data into Claude. With MCP, Claude pulls it directly — no context switching, no stale information. The same applies whether you are querying a GitHub PR, running a browser test, or reading a Kubernetes pod log.

For Developers

These servers eliminate the most common interruptions in a coding session: switching to the browser to check docs, copy-pasting database output, and manually verifying what your code actually does at runtime.

1. GitHub MCP

The single most-used MCP server across all roles. GitHub MCP lets Claude search your entire codebase, create and review pull requests, read issue comments, and check CI status — without leaving the editor.

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

Useful queries:

What PRs need my review today?
Search the codebase for all uses of the old auth middleware
Summarise the failing CI checks on PR #342
Create an issue for the memory leak we discussed — assign it to me
What did we merge in the last 3 days?

2. Figma MCP (Dev Mode)

Figma’s official Dev Mode MCP server exposes the live structure of the selected layer — hierarchy, auto-layout, variants, text styles, and token references — so Claude can generate code against the real design instead of a screenshot.

Before this existed, the workflow was: screenshot the Figma frame → paste into Claude → get approximate code → iterate. Now Claude reads the actual design spec.

{
  "mcp": {
    "servers": {
      "figma": {
        "transport": "http",
        "url": "https://api.figma.com/v1/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_FIGMA_TOKEN"
        }
      }
    }
  }
}

Useful queries:

Generate a React component for the selected card in Figma
What spacing tokens does this layout use?
Implement the checkout form exactly as designed — use our existing design system tokens

3. E2B MCP (Sandboxed Code Execution)

E2B gives Claude a secure cloud sandbox to run Python or JavaScript, execute shell commands, install packages, and inspect outputs — all inside an isolated microVM. This is the right answer to “I want Claude to verify this migration script before it touches the real database.”

{
  "mcp": {
    "servers": {
      "e2b": {
        "transport": "http",
        "url": "https://api.e2b.dev/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_E2B_KEY"
        }
      }
    }
  }
}

Useful queries:

Run this data transformation script on the sample CSV and show me the output
Test this regex against these 20 edge case strings
Execute the migration dry-run and tell me what it would change

4. Database MCP (Match to Your Stack)

Pick one. All of these follow the same pattern: Claude translates natural language into queries, executes them, and explains the results.

Important: Point database MCP at a read replica with a read-only user. Never give Claude write access to a production database through MCP — destructive queries do happen.

{
  "mcp": {
    "servers": {
      "postgres": {
        "transport": "stdio",
        "command": "mcp-postgres",
        "args": [
          "--connection-string",
          "postgresql://readonly_user:pass@read-replica.example.com/db"
        ]
      }
    }
  }
}

5. Context7 / Docs MCP

Claude’s training data has a cutoff. For libraries that change frequently — React Router, Next.js, Prisma — Claude might suggest deprecated APIs, miss new features, or give you code that doesn’t compile against the current version. This is not carelessness; it is how LLMs work.

Context7 solves it. It indexes official documentation for thousands of libraries, keeps them continuously updated, and serves only the relevant section — in a format optimised for LLMs, not humans browsing a docs site.

claude mcp add --transport http context7 --scope project https://mcp.context7.com/mcp

Note the transport: this is a remote HTTP MCP server, not a local npx process. No installation needed — Claude reaches out over HTTP.

Real-world example: your app eagerly imports all page components at startup. Users who never visit admin pages still pay the bundle cost. The fix is React Router v7 lazy loading — but the API changed from v6 and you don’t want to guess.

Using context7, look up the React Router DOM v7 docs for lazy-loading routes
with React.lazy() and Suspense. Then refactor src/App.jsx to lazy-load all
page components instead of eagerly importing them. Keep provider nesting and
error boundaries intact. Add a simple fallback (spinner or "Loading..." text).

Context7 fetches the exact current API, not a cached version from training data.

Other useful queries:

Show me the current React Query v5 useQuery signature
What changed in Next.js 15 App Router between RC and stable?
Give me the Prisma docs for nested transactions

For Testers

These servers give Claude the ability to actually run your application, observe its behaviour, and report what it finds — rather than reason about what should happen.

6. Playwright MCP

The most important testing MCP. Playwright MCP drives a real browser using Claude — it navigates, clicks, fills forms, and reads the resulting DOM and accessibility tree. Claude can verify its own code changes by actually running the app.

npx @playwright/mcp@latest

Or configure in .claude/settings.json:

{
  "mcp": {
    "servers": {
      "playwright": {
        "transport": "stdio",
        "command": "npx",
        "args": ["@playwright/mcp@latest", "--headless"]
      }
    }
  }
}

Once connected, Claude can navigate, click, fill forms, intercept network requests, take screenshots, and generate Playwright test files from its own actions. It runs across Chrome, Firefox, and Safari.

Ready-to-use prompts:

"A user reported that clicking 'Add to Cart' sometimes shows a 500 error.
Open the app, test with real data, figure out what's actually happening,
and tell me what's broken."

"Navigate through the main user flows at localhost:3000 (signup, login,
dashboard, settings). Collect every console error and warning. Propose
fixes ranked by severity."

"Take screenshots at 1920×1080, 768×768, and 375×667. Compare against
./baseline/. Tell me which pages have visual regressions and what changed."

"Walk through my checkout flow as a real user would. Record what you do,
then generate a Playwright test file covering this flow with proper
assertions. Save it to tests/e2e/checkout.spec.ts"

"The tests in tests/e2e/login.spec.ts are failing. Run them, inspect the
DOM at /login, figure out whether the app or the test is broken, and fix
whichever side is actually broken."

"Crawl every page linked from my homepage (up to 2 levels deep). For each
page capture: title, meta description, H1, word count, broken links, load
time. Give me a table sorted by problems found."

"Test the signup form with: empty fields, SQL injection strings, extremely
long inputs, unicode/emoji, mismatched passwords, already-taken emails.
For each, report what happened and whether the app handled it gracefully.
Fix any validation issues you find."

Playwright MCP uses the accessibility tree rather than screenshots — which means tests are more stable, not tied to visual layout, and explain why something is failing rather than just that it is.

7. Chrome DevTools MCP

Where Playwright MCP drives the browser, Chrome DevTools MCP inspects it. You can read console errors, examine network requests, check performance metrics, and debug JavaScript — all through Claude.

{
  "mcp": {
    "servers": {
      "chrome-devtools": {
        "transport": "stdio",
        "command": "mcp-chrome-devtools",
        "args": ["--port", "9222"]
      }
    }
  }
}

Useful queries:

What JavaScript errors appeared on the checkout page during my last test run?
Are there any failed network requests when I load the dashboard?
What is the Largest Contentful Paint score on the homepage?
Which API calls are taking more than 500ms?

8. BrowserStack MCP

For cross-browser and cross-device testing without maintaining local device labs. BrowserStack MCP runs your tests on real browsers (Safari, Firefox, Edge) and real mobile devices.

{
  "mcp": {
    "servers": {
      "browserstack": {
        "transport": "http",
        "url": "https://api.browserstack.com/mcp",
        "headers": {
          "Authorization": "Basic BASE64_USERNAME_ACCESSKEY"
        }
      }
    }
  }
}

Useful queries:

Run the login test on Safari iOS 17 and tell me if it passes
Check whether the payment form renders correctly on Samsung Galaxy S23
What is the test pass rate across browsers this week?

9. Sentry MCP

Sentry MCP bridges the gap between a test failure and its production origin. When a test reproduces a bug, Claude can immediately check whether the same error pattern has appeared in production and how many users it affects.

{
  "mcp": {
    "servers": {
      "sentry": {
        "transport": "stdio",
        "command": "mcp-sentry",
        "env": {
          "SENTRY_AUTH_TOKEN": "YOUR_TOKEN",
          "SENTRY_ORG": "your-org"
        }
      }
    }
  }
}

Useful queries:

Has this NullPointerException appeared in production? How many users hit it?
Show me the full stack trace for the checkout error from yesterday
What are the top 5 errors in production right now?

For DevOps and Platform Engineers

These are the servers that eliminate the toil: swapping between dashboards during incidents, writing Kubernetes debug commands from memory, and manually correlating deployment times with error spikes.

10. Kubernetes MCP

The most valuable infrastructure MCP for teams running Kubernetes. Natural language diagnostics replace kubectl command lookup for the 80% of debugging you do every week.

{
  "mcp": {
    "servers": {
      "kubernetes": {
        "transport": "stdio",
        "command": "kubectl-mcp-server",
        "args": ["--kubeconfig", "~/.kube/config"]
      }
    }
  }
}

Useful queries:

Why is the nginx pod crashing? Check events, logs, and resource limits
Which pods are not in RUNNING state across all namespaces?
What changed in the last deployment to the payments service?
Scale the api deployment to 5 replicas
Show me nodes with high CPU or memory pressure

11. AWS MCP (Read-Only)

Read-only access to CloudWatch logs, EC2 status, ECS task definitions, S3 bucket policies, and cost data covers 80% of what you need during debugging and incident response. Keep it read-only — destructive AWS operations belong in Terraform or the console.

{
  "mcp": {
    "servers": {
      "aws": {
        "transport": "stdio",
        "command": "mcp-aws",
        "args": ["--profile", "readonly", "--region", "us-east-1"]
      }
    }
  }
}

Useful queries:

What errors appeared in CloudWatch for the payments service in the last hour?
List ECS tasks that are not in RUNNING state
What is the current CPU utilisation on our RDS cluster?
Show me the cost breakdown for this month vs last month
Which S3 buckets have public access enabled?

12. Terraform MCP

Manages Terraform Cloud workspaces, triggers runs, inspects state, and performs cost estimations — without leaving Claude Code.

{
  "mcp": {
    "servers": {
      "terraform": {
        "transport": "http",
        "url": "https://app.terraform.io/api/v2/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_TF_TOKEN"
        }
      }
    }
  }
}

Useful queries:

What would change if I apply the latest run in the staging workspace?
Show me the current state of the production VPC resources
Which workspaces have pending runs?
What is the cost estimate for the new EKS node group?

13. Grafana MCP

Queries dashboards, inspects data sources, and retrieves incident details — the natural language layer on top of your existing Grafana setup.

{
  "mcp": {
    "servers": {
      "grafana": {
        "transport": "stdio",
        "command": "uvx",
        "args": ["mcp-grafana"],
        "env": {
          "GRAFANA_URL": "http://your-grafana:3000",
          "GRAFANA_SERVICE_ACCOUNT_TOKEN": "YOUR_TOKEN"
        }
      }
    }
  }
}

Useful queries:

What does the API latency look like over the last 2 hours?
Show me the error rate for the payments service since the last deploy
Are there any active alerts right now?

14. PagerDuty MCP

During incidents, PagerDuty MCP turns Claude into an effective co-pilot. It reads the timeline, affected services, escalation policy, and past resolution notes without you switching tabs.

{
  "mcp": {
    "servers": {
      "pagerduty": {
        "transport": "stdio",
        "command": "mcp-pagerduty",
        "args": ["--api-key", "YOUR_PD_KEY"]
      }
    }
  }
}

Useful queries:

What services are currently in alert state?
Who is on-call right now for the payments team?
Summarise the last 5 incidents for the checkout service — what were the causes?
Create an incident for the database latency spike

15. Trivy MCP (Security Scanning)

Trivy scans container images and infrastructure code for CVEs, misconfigurations, and exposed secrets. With the MCP server, Claude can run scans and explain findings in context.

{
  "mcp": {
    "servers": {
      "trivy": {
        "transport": "stdio",
        "command": "mcp-trivy",
        "args": []
      }
    }
  }
}

Useful queries:

Scan the payments-service:latest image for critical vulnerabilities
Are there any HIGH or CRITICAL CVEs in our base image?
Check the Terraform configs in infra/ for misconfigurations
Scan for exposed secrets in the repo

16. Linear MCP (or Jira MCP)

Converting Slack threads and incident retrospectives into properly structured tickets is a time sink. With Linear MCP, Claude creates, labels, and assigns tickets from natural language.

claude mcp add linear --api-key lin_YOUR_KEY

Useful queries:

Create a ticket for the memory leak in the auth service — P2, platform team
What tickets are blocking the next release?
Mark PLAT-234 as done and add a comment with the fix summary
Create a post-mortem ticket for this incident with the timeline we discussed

Role-Based Starter Stacks

flowchart LR
    subgraph Dev[Developer]
        D1[GitHub MCP]
        D2[Figma MCP]
        D3[Database MCP]
        D4[Context7 Docs]
        D5[E2B Sandbox]
    end
    subgraph Test[QA Tester]
        T1[Playwright MCP]
        T2[Chrome DevTools MCP]
        T3[BrowserStack MCP]
        T4[Sentry MCP]
    end
    subgraph Ops[DevOps / Platform]
        O1[GitHub MCP]
        O2[Kubernetes MCP]
        O3[AWS MCP read-only]
        O4[Grafana MCP]
        O5[PagerDuty MCP]
        O6[Linear MCP]
    end

Developer starter pack (in priority order):

1. GitHub MCP — daily use for every developer
2. Database MCP matching your stack — debugging and exploration
3. Context7 — stop hallucinated API signatures
4. Figma MCP — only if you implement designs regularly

Tester starter pack:

1. Playwright MCP — core verification tool
2. Chrome DevTools MCP — runtime error inspection
3. Sentry MCP — bridge tests to production error patterns

DevOps starter pack:

1. GitHub MCP — shared with developers, essential for everyone
2. Kubernetes MCP — if you run k8s, this pays for itself in the first week
3. AWS MCP (read-only) — CloudWatch and cost visibility
4. PagerDuty MCP — incident co-pilot
5. Grafana or Prometheus MCP — observability layer

Servers to Skip (and Why)

flowchart LR
    subgraph Skip[Skip or Limit These]
        N[Notion MCP\n3-5s latency per call]
        P[Postgres MCP on prod\nrisk of destructive queries]
        S[Slack MCP inbound\nbetter just to read Slack]
        FS[Filesystem MCP with broad paths\nred flag for security]
    end

Postgres MCP against production — point it at a read replica with a read-only user instead. Claude does issue destructive queries occasionally.

Notion MCP — high latency, low return for most teams. Export relevant pages to markdown and use @ imports in CLAUDE.md instead.

Slack MCP for reading — slower than reading Slack yourself. Use outbound webhooks so Claude can post to Slack; skip inbound retrieval.

Filesystem MCP with broad paths — granting Claude access to your entire home directory or / creates unnecessary risk. Scope it to specific project directories only.

Project-Level vs Global Configuration

~/.claude/settings.json           ← personal servers (your GitHub token, your Figma token)
.claude/settings.json             ← project servers (team Linear workspace, project DB)
.claude/settings.local.json       ← personal project overrides (gitignored)

Put shared servers in .claude/settings.json (committed to git) so the whole team gets them. Put personal credentials in ~/.claude/settings.json.

Check what is actually being used:

claude mcp list          # see all configured servers
/mcp                     # check server status and context cost inside a session
/mcp disable <name>      # disable a server you are not using right now

Every enabled server loads its tool definitions into context on every message — whether you use it or not. If you are not actively using a server in a session, disable it with /mcp disable. This is one of the highest-impact token optimisations available.

Multi-MCP Workflow Scenarios

The real leverage comes from combining servers. Here are four cross-tool workflows that eliminate entire categories of manual work:

Each of these requires no manual copy-paste between tools. Claude reads from the source, acts on the data, and writes back to the destination — across all four systems in one prompt.

The Evaluation Framework

Before installing any new MCP server, answer three questions:

1. Does it replace a daily copy-paste workflow? If yes, install it. If it saves time once a week, skip it.
2. Can it make a destructive change? If yes, either restrict to read-only or skip it entirely.
3. Will Claude actually reach for it, or will I forget it exists? If unsure, skip it for now and revisit in a month.

Security checklist for any server you install:

• Use a dedicated service account, not your personal credentials
• Grant the minimum permissions needed (read-only where possible)
• Rotate credentials on the same schedule as your other service accounts
• Review what data the server can access before connecting it to Claude

Five well-chosen MCP servers outperform twenty poorly chosen ones every time. Start with one stack that matches your role, observe which tools Claude actually uses, then trim the rest.