# Best MCP Servers for Cursor (2026): Ranked

> The best MCP servers for Cursor in 2026, ranked — with the exact .cursor/mcp.json config for each and the component server other lists miss.

Source: https://designrevision.com/blog/best-mcp-servers-for-cursor

---

The best MCP servers for Cursor turn its Agent into one wired directly into your repos, your database, your browser, and your component library. The strongest picks in 2026 are GitHub, Context7, Playwright, Supabase, and Filesystem — plus DesignRevision MCP for installing real shadcn/ui components. This guide ranks the best MCP servers for Cursor, and unlike every other list, it gives you the **exact `.cursor/mcp.json` config for each one** — remote or local, auth and all — so you can copy, paste, and go.

*Last updated: July 2026. MCP servers move fast — remote endpoints, package names, and auth flows change; every config here was verified in July 2026, but confirm each against its source before adding.*

New to MCP in Cursor? Start with our guide on [how to add an MCP server to Cursor](/blog/add-mcp-server-to-cursor) for the three setup methods. Otherwise, straight to the rankings.

## The Best MCP Servers for Cursor at a Glance

| # | Server | Category | Transport | Best for |
|---|--------|----------|-----------|----------|
| 1 | GitHub | Integration | Remote | Repos, issues, and PRs in the editor |
| 2 | Context7 | Documentation | Remote | Up-to-date, version-specific library docs |
| 3 | Playwright | Browser & testing | Local | Driving a real browser for E2E tests |
| 4 | Supabase | Database | Remote | Querying and managing a Postgres backend |
| 5 | Filesystem | Files | Local | Sandboxed access outside the project |
| 6 | DesignRevision MCP | UI components | Remote | Installing real shadcn/ui components |
| 7 | Figma | Design | Local | Turning selected frames into code |
| 8 | Sentry | Monitoring | Remote | Pulling real errors and traces into context |
| 9 | Sequential Thinking | Reasoning | Local | Structured, step-by-step planning |
| 10 | Brave Search | Search | Local | Privacy-first web search from the Agent |

## How We Picked

This is an opinionated, hands-on ranking rather than a benchmark. We weighed four Cursor-specific signals: **real utility in Cursor's Agent** (a server the Agent never calls is clutter, especially under Cursor's ~40-tool cap), **provenance** (official vendor servers over anonymous forks), **setup friction in `.cursor/mcp.json`** (a clean remote `url` beats a fragile local toolchain), and **breadth** (integration, docs, browser, data, design, and UI — not ten variations on one job). Every config was verified against its source in July 2026, and each entry carries a plain verdict plus who should skip it.

**A quick note on Cursor's config.** Servers live under `mcpServers` in `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global). Cursor infers the transport from the shape: a `url` key means a **remote** server, a `command` key means a **local** one — no `type` field needed. Each entry below is ready to drop into that `mcpServers` object.

## The Best MCP Servers for Cursor

### 1. GitHub

**Category:** Integration · **Transport:** Remote (HTTP) · **Best for:** repos, issues, and PRs without leaving Cursor · **Docs:** [github/github-mcp-server](https://github.com/github/github-mcp-server)

```json
"github": {
  "url": "https://api.githubcopilot.com/mcp/",
  "headers": { "Authorization": "Bearer YOUR_GITHUB_PAT" }
}
```

**Verdict: Install.** The single most useful server for Cursor — it gives the Agent first-class access to repositories, issues, pull requests, and code search, so it acts where your work already lives. Note the Cursor difference: here you use the **hosted remote endpoint** with a personal access token, where many Claude Code guides show the local Docker image. The remote path is lower-maintenance and auto-updated. *Skip if* your team is on GitLab or Bitbucket — add their server instead.

### 2. Context7

**Category:** Documentation · **Transport:** Remote (HTTP) · **Best for:** stopping Cursor from calling old library APIs · **Docs:** [upstash/context7](https://github.com/upstash/context7)

```json
"context7": {
  "url": "https://mcp.context7.com/mcp",
  "headers": { "CONTEXT7_API_KEY": "YOUR_API_KEY" }
}
```

**Verdict: Install.** A Cursor community favorite, because "the model used a deprecated API" is a daily Cursor pain point. Context7 pulls version-specific, up-to-date documentation for thousands of packages into context on demand. It works without a key, but an API key raises your rate limits. *Skip if* you work almost entirely in a frozen internal stack.

### 3. Playwright

**Category:** Browser & testing · **Transport:** Local (stdio) · **Best for:** letting the Agent drive a real browser · **Docs:** [microsoft/playwright-mcp](https://github.com/microsoft/playwright-mcp)

```json
"playwright": {
  "command": "npx",
  "args": ["@playwright/mcp@latest"]
}
```

**Verdict: Install.** Microsoft's official Playwright server lets Cursor's Agent navigate, click, fill forms, and assert against a real browser using the accessibility tree — ideal for end-to-end tests and verifying a UI it just built. Runs locally over `npx`, no account needed. *Skip if* you never touch web interfaces.

### 4. Supabase

**Category:** Database · **Transport:** Remote (HTTP) · **Best for:** querying and managing a Postgres backend · **Docs:** [Supabase MCP](https://supabase.com/docs/guides/getting-started/mcp)

```json
"supabase": {
  "url": "https://mcp.supabase.com/mcp?project_ref=YOUR_PROJECT_REF&read_only=true"
}
```

**Verdict: Install (if you use Supabase).** The official Supabase server lets Cursor inspect your schema, run SQL, and read config — turning "what's in the users table?" into a real query. Setup is browser OAuth (no token to paste), and adding `?read_only=true` and `?project_ref=…` scopes what the Agent can touch. *Skip if* you're not on Supabase — reach for the Postgres server instead.

### 5. Filesystem

**Category:** Files · **Transport:** Local (stdio) · **Best for:** sandboxed access to folders outside the project

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

**Verdict: Install.** The reference filesystem server gives the Agent sandboxed read, write, and search across directories you explicitly allow on the command line — useful for a shared assets folder or a sibling project. *Skip if* everything you need is already inside the current workspace, which Cursor reaches natively.

### 6. DesignRevision MCP

**Category:** UI components · **Transport:** Remote (HTTP) · **Best for:** installing real shadcn/ui components

```json
"design-revision": {
  "url": "https://mcp.designrevision.com/mcp",
  "headers": { "Authorization": "Bearer YOUR_TOKEN" }
}
```

**Verdict: Install (for frontend work).** The category every other Cursor list misses: a server for building UI. [DesignRevision MCP](/mcp) lets Cursor's Agent discover, inspect, and install real, production-grade [shadcn/ui components](/components) straight from the registry — with the install command and dependencies already resolved — instead of hand-writing markup from memory. It's freemium, so you can wire it up and pull components on the free plan. *Skip if* you never build frontends.

### 7. Figma

**Category:** Design · **Transport:** Local (desktop) · **Best for:** turning selected frames into code

```json
"figma": {
  "url": "http://127.0.0.1:3845/mcp"
}
```

**Verdict: Situational.** Figma's Dev Mode server exposes selected frames as structured design context, so Cursor can translate a specific component into code that respects real spacing and tokens. It runs **inside the Figma desktop app** — you must enable Dev Mode + the MCP server there first, and it needs a paid Dev/Full seat. *Skip if* your team doesn't design in Figma or you're implementing from an existing component library.

### 8. Sentry

**Category:** Monitoring · **Transport:** Remote (HTTP) · **Best for:** debugging from real production errors

```json
"sentry": {
  "url": "https://mcp.sentry.dev/mcp"
}
```

**Verdict: Situational.** Sentry's official server pulls real issues, stack traces, and performance data into Cursor, so the Agent debugs from what actually broke in production rather than a pasted snippet. Auth is OAuth in the browser. High value if you already run Sentry, dead weight if you don't. *Skip if* you have no Sentry project.

### 9. Sequential Thinking

**Category:** Reasoning · **Transport:** Local (stdio) · **Best for:** forcing structured planning on hard tasks

```json
"sequential-thinking": {
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
```

**Verdict: Situational.** A Cursor Reddit favorite — this reference server gives the Agent a "think step by step" tool to break a gnarly problem into ordered, revisable steps before acting. On big multi-stage tasks it improves planning discipline; on everyday work it mostly adds ceremony. Free and local. *Skip if* your tasks are routine.

### 10. Brave Search

**Category:** Search · **Transport:** Local (stdio) · **Best for:** privacy-first web search from the Agent

```json
"brave-search": {
  "command": "npx",
  "args": ["-y", "@brave/brave-search-mcp-server"],
  "env": { "BRAVE_API_KEY": "YOUR_KEY" }
}
```

**Verdict: Situational.** Gives Cursor privacy-first web, news, and local search through the Brave Search API. You need an API key (the free tier covers ~2,000 queries a month). *Skip if* Cursor's built-in web tools already cover you.

**Also worth adding — team & comms.** If your work lives in **Linear**, **Slack**, or **Notion**, each has an official remote MCP server (add it as a `url` entry, OAuth on first use). They shine for turning a Cursor task into a real ticket, message, or doc — but they eat into the 40-tool budget, so enable them only when you'll use them.

## Cursor MCP JSON: Project vs. Global

Every one of these Cursor MCP servers is configured in the same file — `.cursor/mcp.json` (see [Cursor's MCP docs](https://cursor.com/docs/mcp)). Two locations decide who gets a server:

- **`.cursor/mcp.json`** in your repo root — applies to that project only. **Commit it** and everyone on your team gets the same servers.
- **`~/.cursor/mcp.json`** in your home directory — applies to every project. Use it for general-purpose servers like GitHub.

A full file looks like this — stack as many entries under `mcpServers` as you like:

```json
{
  "mcpServers": {
    "github": { "url": "https://api.githubcopilot.com/mcp/", "headers": { "Authorization": "Bearer YOUR_GITHUB_PAT" } },
    "design-revision": { "url": "https://mcp.designrevision.com/mcp", "headers": { "Authorization": "Bearer YOUR_TOKEN" } }
  }
}
```

After editing, **refresh the server** in Cursor Settings → Tools & Integrations (a green dot means it's connected). Remember the ~40-tool ceiling: keep the set focused. For the full walkthrough — the Settings UI, one-click installs, and troubleshooting the red and yellow status dots — see [how to add an MCP server to Cursor](/blog/add-mcp-server-to-cursor).

## Best Free MCP Servers for Cursor

Not every one of these Cursor MCP servers is free, but most are. **GitHub** (free with any account), **Playwright**, **Filesystem**, **Context7**, and **Sequential Thinking** are all free and open source. **Supabase** and **Sentry** are free with an account. **DesignRevision MCP** is freemium — the free plan covers browsing and installing components. Only **Brave Search** needs a paid API (with a free tier), and **Figma** needs a paid seat. You can build a strong Cursor setup — integration, docs, browser, files, and UI — without spending anything.

## Conclusion

The best MCP servers for Cursor in 2026 are the ones that close a real gap in the Agent's reach: GitHub for integration, Context7 and Playwright for accuracy and testing, Supabase and Filesystem for data, and DesignRevision MCP for real shadcn/ui components. Drop the two or three that match your biggest pain point into `.cursor/mcp.json`, refresh, and stay under the 40-tool cap — a focused set the Agent actually uses beats a crowded one it doesn't.

---

## Related Resources

- [How to Add an MCP Server to Cursor (2026 Guide)](/blog/add-mcp-server-to-cursor)
- [DesignRevision MCP — the shadcn/ui MCP server](/mcp)
- [MCP Clients Compared: Every AI Coding Agent](/blog/mcp-clients-compared)
- [Best MCP Servers for Claude Code (2026): Tested & Ranked](/blog/best-mcp-servers-for-claude-code)
- [Browse the shadcn/ui component registry](/components)