10 MCP servers every developer should know in 2026

The Model Context Protocol (MCP) lets AI coding assistants call external tools. Instead of pasting output into a chat window, your AI assistant calls an API directly and works with the structured response. Claude Desktop, Cursor, VS Code Copilot, and Windsurf all support MCP servers.

The ecosystem has grown fast. There are now MCP servers for developer utilities, databases, browsers, error trackers, project management tools, and payment platforms. Finding the right ones takes time you could spend writing code.

This post covers 10 MCP servers worth adding to your setup. For each one: what it does, when you'd reach for it, and the config to get it running.

1. Botoi (49 developer utility tools)

Botoi exposes 49 tools through a single remote MCP endpoint: DNS lookups, WHOIS queries, JWT signing and verification, Base64 encoding, hashing, PII detection, email validation, JSON formatting, regex testing, and more. It's a Swiss Army knife for the small tasks that pull you out of your editor.

Transport: Streamable HTTP (remote, no install).
Auth: Works without a key at 5 req/min and 100 req/day. Add a key for higher limits.
When to use it: You need a quick DNS lookup, hash comparison, JWT decode, or format conversion during a coding session and don't want to open a browser tab or remember CLI flags.

{
  "mcpServers": {
    "botoi": {
      "type": "streamable-http",
      "url": "https://api.botoi.com/mcp"
    }
  }
}

Full tool list: api.botoi.com/v1/mcp/tools.json

2. GitHub (official)

The official GitHub MCP server gives your assistant access to repositories, pull requests, issues, branches, and file contents. You can search code, create PRs, review diffs, and manage issues without leaving your conversation.

Transport: stdio (runs locally via npx).
Auth: GitHub personal access token with the scopes you need (repo, read:org, etc.).
When to use it: You want to create issues, review PRs, search across repos, or read file contents from GitHub without switching to a browser.

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

3. Filesystem (official)

The Filesystem server gives your assistant controlled read and write access to directories on your machine. It can list files, read contents, create files, move files, and search by name. Access is sandboxed to the directories you specify in the config.

Transport: stdio.
Auth: None. Access is restricted to the allowed directories.
When to use it: You need your assistant to read config files, edit templates, or organize files outside your current project directory.

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

Pass multiple directory paths as additional arguments to allow access to several locations.

4. Postgres

The Postgres MCP server connects your assistant to a PostgreSQL database. It can list tables, describe schemas, and run read-only SQL queries. Your assistant sees the database structure and can answer questions about your data without you writing queries by hand.

Transport: stdio.
Auth: PostgreSQL connection string.
When to use it: You're debugging a data issue, exploring an unfamiliar schema, or need quick counts and aggregations during development.

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

Queries run in read-only mode by default. Connect to a development or staging database, not production.

5. SQLite

Similar to Postgres but for SQLite files. Your assistant can query local database files, inspect schemas, and run analytical queries. Useful for mobile app databases, embedded systems, and local development.

Transport: stdio.
Auth: None. Path to the .db file is the only argument.
When to use it: You're working with a local SQLite database and want to inspect data, run queries, or explore the schema from your AI assistant.

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "/path/to/database.db"
      ]
    }
  }
}

6. Playwright (browser automation)

Playwright's MCP server launches a browser that your assistant controls. It can navigate to pages, click elements, fill forms, take screenshots, and read page content. This turns your assistant into a browser automation tool for testing and scraping.

Transport: stdio.
Auth: None.
When to use it: You're debugging a frontend issue, testing a form flow, scraping data from a page, or need a screenshot of a deployed page.

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

Run npx playwright install first to download browser binaries if you haven't used Playwright before.

7. Sentry (error monitoring)

Sentry's MCP server connects your assistant to your Sentry organization. It can list recent errors, search issues by query, read stack traces, and get event details. When you're debugging a production error, your assistant pulls the stack trace and context directly from Sentry.

Transport: stdio.
Auth: Sentry auth token with project:read and event:read scopes.
When to use it: A user reports a bug. You ask your assistant to find the error in Sentry, read the stack trace, and suggest a fix. All in one conversation.

{
  "mcpServers": {
    "sentry": {
      "command": "npx",
      "args": ["-y", "@sentry/mcp-server"],
      "env": {
        "SENTRY_AUTH_TOKEN": "sntrys_your_token_here"
      }
    }
  }
}

8. Slack (messaging)

The Slack MCP server lets your assistant read channels, search messages, and post updates. It can find conversations, read thread histories, and send messages on your behalf.

Transport: stdio.
Auth: Slack bot token and team ID.
When to use it: You want to search for a decision made in a Slack thread, post a deployment update to a channel, or find who mentioned a specific topic.

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/slack-mcp-server"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token",
        "SLACK_TEAM_ID": "T0123456789"
      }
    }
  }
}

Your Slack app needs the channels:history, channels:read, chat:write, and users:read scopes.

9. Linear (project management)

Linear's MCP server gives your assistant access to issues, projects, cycles, and teams. It can create issues, update status, search by label or assignee, and read project roadmaps.

Transport: stdio.
Auth: Linear API key.
When to use it: You finish a feature and want to mark the issue as done, create a follow-up ticket, or check what's assigned to you in the current cycle.

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp-server"],
      "env": {
        "LINEAR_API_KEY": "lin_api_your_key_here"
      }
    }
  }
}

10. Stripe (payments)

Stripe's official MCP server connects your assistant to your Stripe account. It can list customers, read subscription details, look up invoices, check payment intents, and manage products. Useful for debugging billing issues without navigating the Stripe dashboard.

Transport: stdio.
Auth: Stripe secret key (use a test key during development).
When to use it: A customer reports a billing issue. Your assistant pulls up the customer record, checks the latest invoice, and reads the payment status. No dashboard needed.

{
  "mcpServers": {
    "stripe": {
      "command": "npx",
      "args": ["-y", "@stripe/mcp", "--tools=all", "--api-key=sk_test_your_key"]
    }
  }
}

Use sk_test_ keys during development. Never pass a live secret key through an MCP server config in a shared or version-controlled file.

Botoi MCP config for every client

Since Botoi runs as a remote HTTP server, setup is the same across all clients. No npx, no Docker, no local process. Here's the config for each one.

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "botoi": {
      "type": "streamable-http",
      "url": "https://api.botoi.com/mcp"
    }
  }
}

Claude Code

Run in your terminal:

claude mcp add botoi --transport streamable-http https://api.botoi.com/mcp

Cursor

Open Cursor Settings, go to MCP, and add:

{
  "mcpServers": {
    "botoi": {
      "url": "https://api.botoi.com/mcp",
      "type": "streamable-http"
    }
  }
}

VS Code (GitHub Copilot)

Add to your settings.json:

{
  "mcp": {
    "servers": {
      "botoi": {
        "type": "streamable-http",
        "url": "https://api.botoi.com/mcp"
      }
    }
  }
}

The 49 tools appear on first connection. No restart required in most clients.

Practical workflow: checking DNS during a deployment

You're deploying a staging environment. The site isn't loading. You suspect a DNS misconfiguration. Here's how the Botoi MCP server helps without leaving your editor:

You: "Check the DNS A records for staging.acme.com"

Tool call: lookup_dns
Input: { "domain": "staging.acme.com", "type": "A" }

Result:
{
  "domain": "staging.acme.com",
  "type": "A",
  "records": [
    { "value": "76.76.21.21", "ttl": 300 }
  ],
  "resolver": "1.1.1.1",
  "query_time_ms": 14
}

You: "That's Vercel's IP. It should point to 143.204.15.88. Check the TXT records too."

Tool call: lookup_dns
Input: { "domain": "staging.acme.com", "type": "TXT" }

Result:
{
  "domain": "staging.acme.com",
  "type": "TXT",
  "records": [
    { "value": "v=spf1 include:_spf.google.com ~all", "ttl": 3600 }
  ],
  "resolver": "1.1.1.1",
  "query_time_ms": 11
}

Now you know two things: the A record points to Vercel (not your target IP), and the SPF record is present. Your assistant can explain the issue and suggest the correct DNS change. The whole interaction took 10 seconds, with zero context switching.

This pattern works for any lookup tool. Ask your assistant to check SSL certificates, validate an email domain, decode a JWT from a failing request, or detect the tech stack of a competitor's site. The tools are always available in your conversation.

How to choose which servers to install

Don't install all 10 at once. Each MCP server adds tools to your assistant's context, and too many tools can slow down tool selection. Start with the servers that match your daily work:

• Web development: Botoi (DNS, headers, SSL, JWT), Playwright (browser testing), GitHub (PRs and issues).
• Backend and data: Postgres or SQLite (database queries), Sentry (error tracking), Botoi (hashing, encoding, format conversion).
• Full-stack team lead: GitHub (code review), Linear (issue tracking), Slack (team communication), Stripe (billing debugging).
• Solo developer: Botoi (covers 49 common utility needs), Filesystem (file management), GitHub (repo management).

Key points

• MCP lets AI coding assistants call external tools directly. No copy-pasting between windows.
• Remote servers (Botoi, GitHub) need no local install. Local servers (Filesystem, Postgres, Playwright) run via npx.
• Start with 2-3 servers that match your workflow. Add more as you need them.
• Use test credentials for servers that access sensitive systems (Stripe, Postgres, Sentry). Never commit API keys to version control.
• The MCP ecosystem is growing. Check github.com/modelcontextprotocol/servers for the full directory of available servers.