MCP servers worth setting up in 2026 (filesystem, git, databases)

MCP (Model Context Protocol) lets AI agents call local services — filesystem, git, databases, browsers. By 2026 the ecosystem has matured enough to have actual best-practice patterns. This post is the practical "which servers actually earn their setup cost" guide.

What MCP is, briefly

MCP is a protocol for AI agents to discover and call tools. An MCP server exposes a set of "tools" (functions the agent can invoke). Claude Code reads MCP server configs and makes the tools available to the agent.

# In ~/.claude/mcp-config.json or similar
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem", "/Users/me/dev"]
    }
  }
}

The agent can now invoke filesystem operations through the MCP server.

The seven MCP servers worth setting up

1. Filesystem (official Anthropic)

What it does: scoped filesystem operations — read, write, list, search within a directory tree.

npx @modelcontextprotocol/server-filesystem /Users/me/dev

Why it matters: agents get filesystem access scoped to a directory. More precise than blanket file access; safer than full shell.

When you don't need it: if you only use Claude Code's built-in file tools, skip. The official server is for cases where you want explicit scoping or non-Claude-Code clients.

2. Git (official Anthropic)

What it does: git operations — status, log, diff, blame, branch list. Read-only by default.

npx @modelcontextprotocol/server-git

Why it matters: agents can investigate git history without shelling out. "What did this file look like 2 months ago?" becomes a tool call instead of git show <ref>:<path>.

When you need it: code archaeology workflows, commit-history-aware reviewing, blame-driven debugging.

3. Postgres (community, well-maintained)

What it does: SQL queries against a Postgres DB.

npx @modelcontextprotocol/server-postgres "postgres://user:pass@host:port/db"

Why it matters: agents can answer "what's in our DB?" without you manually pasting query results. For data-aware development (debugging production issues, designing migrations), this is daily value.

Security: scope to read-only credentials. Never give the agent write access to a production DB.

4. SQLite (community)

What it does: SQL queries against SQLite files.

Why it matters: SQLite is everywhere — config dbs, app state, cache files. Agents can inspect them.

Use case: debugging "why is this app caching the wrong thing?" by reading the cache db directly.

5. Puppeteer / Playwright (community)

What it does: browser automation — navigate, screenshot, interact, extract content.

Why it matters: agents can verify their own UI changes by taking screenshots. "Refactor this React component" → agent can npm run dev + screenshot → confirm the visual didn't break.

Setup is involved (Chromium download, configuration). Worth it for UI-heavy work; skip if you don't do frontend.

6. GitHub (community)

What it does: GitHub API access — read PRs, issues, comments, repos.

Why it matters: "summarize the discussion on PR #1234" → agent reads via the MCP server. Without it, you'd paste the comments manually.

Security: use a fine-grained PAT with read-only scope. Don't give the agent write access to issues/PRs unless you specifically want that.

7. Slack (community, niche)

What it does: read Slack channels and threads.

Why it matters: "what did the team discuss about the rate-limiting issue last week?" → agent searches Slack history.

Use case is narrow but the value is real for teams that conduct technical discussions in Slack. Privacy: be careful what's in scope.

What we don't recommend

A few server categories to skip:

"Run arbitrary shell commands" servers

Some MCP servers expose exec() to the agent. Don't. If you need shell, Claude Code already has it built-in (with confirmation prompts). Custom shell servers bypass the safety prompts.

Generic "file I/O" servers from random authors

Use the official Anthropic filesystem server. Random ones may have bugs or unintended scopes.

Servers that auth with cloud services using full-access tokens

If a server wants aws_access_key_id or gcp service account JSON, audit carefully. Write-access to cloud accounts via AI is high-risk.

"All-in-one" mega-servers

Servers that bundle 50 tools are harder to audit and have bigger blast radius. Prefer focused single-purpose servers.

Setting up MCP — the realistic path

Step 1: don't start with MCP

Use Claude Code's built-in tools first. They cover most workflows. Don't add MCP until you feel a specific gap.

Step 2: add servers one at a time

When you hit a gap (e.g., "I keep pasting query results"), add one MCP server (Postgres). Use it for two weeks. Decide if it's worth keeping.

Step 3: audit each server's source

Before installing, read the server's source. Look for:

• What scopes it claims (filesystem? network? shell?).
• What credentials it needs.
• Who maintains it (official? popular community? unknown?).

Step 4: scope credentials minimally

Read-only DB credentials for read-only use cases. Fine-grained GitHub PATs. Limited filesystem scopes.

Step 5: review periodically

Every quarter, list installed MCP servers. Remove ones you haven't used. Audit ones you keep for new permissions.

Concrete config for AI dev work

A typical 2026 MCP config for an AI dev:

{
  "mcpServers": {
    "filesystem-dev": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem", "/Users/me/dev"]
    },
    "git": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-git"]
    },
    "postgres-local": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres",
               "postgres://localhost/dev_db"]
    },
    "github": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "<read-only-PAT>"
      }
    }
  }
}

Four servers, all official or well-maintained. Covers the daily AI dev surface.

What MCP doesn't fix

For balance:

• Bad prompts: MCP gives the agent more tools but doesn't make it smarter. Vague prompts still produce vague results, just with more tool calls.
• Tight CLAUDE.md scope: still essential. MCP doesn't replace this.
• Review discipline: still essential. Agents with more capability can drift further.

MCP is a capability multiplier, not a substitute for workflow discipline.

Trade-offs of running an MCP setup

For honesty:

Pro

• Specific gaps in agent capability filled (DB, browser, niche services).
• Less manual paste-of-data into prompts.
• More structured agent interactions.

Con

• Setup time (each server: 10-30 minutes).
• Maintenance (servers update; configs drift).
• Security surface (each server is a potential vector).
• Cognitive overhead (knowing what tools are available, how to invoke them).

For casual users: the cons outweigh the pros. Stick with built-in tools.

For heavy users with specific gaps: pros win for the right servers.

File-manager setup for MCP-heavy workflows

When agents have more tools, they produce more artifacts (screenshots from Puppeteer, query results from Postgres, etc.). mq-dir's per-tab preview helps:

• Pane 1: session directory.
• Pane 2: artifacts folder (screenshots, exports). Per-tab preview shows them inline.
• Pane 3: source repo.
• Pane 4: cmux session.

This is the same setup as without MCP, but the artifact pane fills up faster.

Verdict

For AI dev workflows in 2026, MCP is worth setting up if you have specific gaps:

• Database-aware development → Postgres / SQLite servers.
• UI-heavy work → Puppeteer / Playwright server.
• GitHub-integrated workflow → GitHub server.
• Code archaeology → Git server.
• Generic filesystem scoping → Filesystem server.

For casual users without these gaps, skip MCP entirely. The built-in tools are enough.

The seven servers above cover ~95% of the legitimate use cases. The other 5% (custom services) might warrant writing your own server, but that's a much larger project.

mq-dir doesn't have an MCP integration today and probably won't soon — it's a file manager, not an agent runtime. The MCP setup lives in your Claude Code or Cursor configuration; mq-dir is what you use to navigate the resulting work.