The Best MCP Servers and Plugins for Claude Code, Codex, and Cursor in 2026

The Model Context Protocol (MCP) has had roughly two years to mature since Anthropic published the spec in late 2024. The server ecosystem is now large enough that the relevant question isn't "does an MCP exist for X?" — it almost certainly does. The real question is which ones are worth keeping installed, and when a full backend Plugin beats stacking individual servers.

This article covers the servers and plugins that power users actually keep, the "short list" principle that makes your AI coding tool faster and cheaper to run, and where a visual backend Plugin fits in the stack versus a single-purpose MCP.

How MCP, Plugins, and Skills Fit Together

Before the list, a quick mental model — because the terms get conflated.

MCP servers are running programs that speak the Model Context Protocol. They give your AI coding tool access to external systems (a database, a GitHub repo, a browser). An MCP server exposes tools, resources, or both.

Skills (in Claude Code and Codex) are instruction sets that teach the agent how to use a tool correctly — the pattern, the order of operations, the error recovery. A Skill doesn't move data; it shapes how the agent thinks about a task.

Plugins bundle a Skill + an MCP server + lifecycle hooks into one installable unit. When a host supports the Plugin format (Claude Code and Codex do natively; Cursor delivers the same capability through MCP), you get the agent intelligence and the tool access together, rather than configuring them separately.

The practical upshot: a Plugin is what you install when you need a backend. A bare MCP server is what you install when you need a single system connection and you'll handle the "how to use it" part yourself.

The "Short List" Principle

Claude Code 2.1.7 shipped MCP Tool Search (lazy loading) by default. Instead of loading every server's schema at the start of each session — which consumed up to 82% of the context window with seven servers active — the system now loads a lightweight index and fetches tool details on demand.

This mostly removes the performance penalty for having many servers configured. But it doesn't remove the cognitive penalty: the agent still has to decide which tool to reach for. A short, coherent list of servers means fewer ambiguous choices. Power users converge on three to six servers that match their daily workflow and disable the rest.

The Servers Worth Keeping

Context7 — Live Documentation

The single highest-leverage install for anyone working with changing APIs. Context7 intercepts the agent's requests for documentation and returns version-specific content pulled from live sources, rather than letting the model recall from training data.

In practice: if you're building on a library that's changed significantly in the last year, Context7 stops your agent from writing code against a version that no longer exists. For anyone using fast-moving tools like the Claude SDK, Vercel AI SDK, or OpenAI Node client, this is the first install.

Works with: Claude Code, Codex, Cursor Install: Available in Claude Code's plugin marketplace; via npx -y @upstash/context7-mcp@latest for Cursor and Codex

GitHub MCP — Repo, Issues, and CI

Direct integration with GitHub without leaving the editor: read and write files, open and close issues, comment on PRs, trigger Actions, and query workflow runs. This is the server that makes AI coding tools useful for actual team development rather than solo prototype sessions.

If you're shipping real code with a CI pipeline, GitHub MCP is a tier-one install — not optional.

Works with: Claude Code, Codex, Cursor Install: Claude Code plugin marketplace; GitHub official MCP server for others

Playwright MCP — Browser Verification

The missing feedback loop in AI-generated code: after the agent writes frontend logic, Playwright lets it load the browser, click through the flow, take screenshots, and verify what actually renders. Without this, you're asking the agent to evaluate its own output from text alone.

Practically, Playwright MCP is where generated UI gets caught before it ships. The agent fills forms, follows redirects, and checks that the UI state matches the expected behavior — all within the same session.

Works with: Claude Code, Codex, Cursor Install: Available in Claude Code's plugin marketplace; npx @playwright/mcp@latest for others

Filesystem MCP — Scoped Local Access

The reference implementation for local file access. Useful when your agent needs to read or write files outside the current project directory — configuration files, shared libraries, external data sources — without giving it unconstrained access to the entire disk.

For most projects, your AI coding tool handles the project directory natively. Filesystem MCP is for the cases where you need to cross that boundary safely.

Works with: Claude Code, Codex, Cursor

Database / Postgres MCP — Direct SQL Access

When you need the agent to query, inspect, or modify a database directly via SQL. This is a lower-level tool: you get raw SQL execution, schema inspection, and data reads, but you're responsible for ensuring the agent uses safe queries, respects permissions, and doesn't treat a production database as a scratch pad.

Postgres MCP is the right choice for developers who want to hand-write their schema and queries and just need the agent to have read access. It's not the right choice when you need auth, permissions, server-side logic, and multiple related tables — that's a different tool category (see below).

Works with: Claude Code, Codex, Cursor

Where a Full Backend Plugin Fits

Single-purpose MCP servers solve one connection problem each. A backend Plugin solves a different problem: it gives your AI coding tool a complete, production-ready data layer — relational tables, typed schema, server-side logic, auth, permissions — and teaches the agent how to use it all correctly.

Momen delivers this as a Plugin for Claude Code, Codex, and Cursor. The Plugin bundles:

• A momen-platform Skill that teaches the agent the connection recipe, schema introspection pattern, and how to call server-side Actionflows
• A momen-mcp CLI (runs via npx) that handles the actual work — schema codegen, typed GraphQL operations, API calls — rather than making the agent generate raw queries from a blank slate
• A SessionStart hook that verifies the backend connection before the first prompt

Claude Code:

/plugin marketplace add momen-tech-org/momen-nocode-plugin
/plugin install momen-nocode@momen

Codex:

codex plugin marketplace add momen-tech-org/momen-nocode-plugin
codex plugin add momen-nocode@momen

Cursor and other MCP-compatible tools — add to your MCP config (.cursor/mcp.json or equivalent):

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

Cursor reads the visual data model through GraphQL introspection and writes accurate queries and mutations against a schema it actually understands, instead of guessing field names.

The difference from a Postgres MCP: Momen's Plugin doesn't expose raw SQL. Instead, it exposes a self-documenting GraphQL API where every table, relation, and server-side flow is typed and queryable. The agent writes correct operations the first time because the schema is machine-readable and unambiguous.

When you need auth, row-level security, server-side business logic, or async background jobs — not just data reads — a backend Plugin is the right choice. A Postgres MCP gets you data access; a backend Plugin gets you a backend.

For real-world examples of what this looks like in practice, see:

• Build a Vision AI Roast App with Claude Code and Momen BaaS
• Build a Vector Search Cocktail Picker with Claude Code and Momen BaaS
• Build a Spirit Pizza Topping Quiz with Codex and Momen BaaS

Putting It Together: A Starting Stack

Need	Tool
Stop API hallucinations	Context7
GitHub access	GitHub MCP
UI verification	Playwright MCP
Complete backend (auth, data, logic)	Momen Plugin or MCP
Raw SQL to an existing DB	Postgres MCP

Summary

The best MCP configuration in 2026 isn't the longest list — it's the most coherent one. Context7, GitHub MCP, and Playwright MCP cover the majority of AI coding workflows. Add a database or backend layer when your app needs persistence, auth, and logic; the choice between a raw Postgres MCP and a full backend Plugin depends on how much of that layer you want to configure yourself.

The Plugin format (where the host supports it) consistently outperforms a bare MCP server for anything complex, because it combines the tool access with the agent intelligence to use it correctly — and that combination is the difference between an agent that generates working code and one that generates plausible-looking code.