Best Cursor MCP Servers in 2026: 10 That Earn Their Tokens

TL;DR

• Decodo tops the list because it gives Cursor's agent live web access, scraping, search results, and unblocking through one server.
• The rest cover recurring jobs, such as repo work (GitHub), current docs (Context7), browser testing (Playwright), design (Figma), and database queries (Supabase).
• Most servers need one entry in your mcp.json file, or a one-click plugin install from the Cursor Marketplace.
• That token efficiency makes stacking several servers viable, though you still have to manage tool overlap and access as you add more.

What MCP servers do in Cursor

Cursor's agent is only as sharp as what it can see, and by default that's your codebase and nothing else. It doesn't know your live docs and won't touch anything outside the editor. What it can't see, it guesses at. That's the gap Cursor MCP closes.

A Cursor MCP server is a connector, following the Model Context Protocol, that plugs an outside system into the agent, exposing its resources and tools mid-conversation instead of you pasting context in by hand. Unlike a native integration or browser extension, it's client-agnostic, so the same server works in Cursor, VS Code, Codex, Claude Desktop, or any other MCP-compatible client.

Every server answers one of two frustrations. Some address "the agent doesn't know this" by bringing accurate docs, live data, or database records into context. Context7 and Decodo sit here. Others solve "the agent can't do this" with tools that act on real systems, like browsing a page, running a test, or filing an issue. The latter change real systems, so Cursor asks you to approve each call before it runs.

Config lives in a project's .cursor/mcp.json, the global ~/.cursor/mcp.json, or a Marketplace plugin. Where you put it decides who else on your team gets it; more on that next.

Adding an MCP server, and where to find them

Adding an MCP server usually depends on who needs it. There are three common scopes.

• If it's just you, install it from the Cursor Marketplace and skip the config file entirely.
• For a single codebase, add it to that project's .cursor/mcp.json. A database connector tied to one repo stays with that repo instead of following you everywhere.
• When you want it in every project, add it to the global ~/.cursor/mcp.json once, and it's available everywhere.

Whichever scope you pick, the config entry looks the same. A server running on your local machine, connecting over stdio, looks like this:

The block above goes into whichever mcp.json file you chose for the server. A remote one is simpler: skip the command entirely and just point Cursor at a URL:

Notice how this entry drops command and args entirely and adds a url field instead. That's because there's no local process for Cursor to launch, just a connection straight to that address. See a full walkthrough, from credentials to green status dot, in our guide to add an MCP server to Cursor.

Finding a server worth adding is its own small task. The Cursor Marketplace is the fastest path for one-click plugins, while modelcontextprotocol.io has the official MCP examples and docs. Community lists like awesome-mcp-servers surface more options, and vendor docs cover the configuration details.

Wherever you land, stick to official or well-maintained servers, and check the docs for the permission scope before you grant access.

The 10 best MCP servers for Cursor

Over 10k Cursor MCP servers exist to connect to. Some are useful for everyday development, others are highly specific, and some will never get a second install. We narrowed the list down to the top 10 worth looking at:

Web data and context

Your codebase is only part of what an agent needs. Documentation changes, answers live on the web, and sometimes the agent needs to see what a page actually returns. These MCP servers are able to bring that outside context into the coding session:

1. Decodo

The Decodo MCP server gives the Cursor agent a way to reach the live web when it needs information beyond your codebase. For instance, scrape_as_markdown brings a page's content into context, google_search_parsed returns structured search results, and amazon_search_parsed handles product data. Built on Decodo's Web Scraping API, it handles the proxying and CAPTCHA challenges behind each call, so the agent gets the page instead of guessing at what's on it.

The trade-off is usage. Every call counts against your Decodo quota, so repeatedly fetching the same pages can burn through requests quickly. Cache results where you can.

Config:

Swap <basic_auth_token> for a key from your Decodo dashboard. See the setup documentation for other scopes and authentication methods.

Example prompt: "Search for the top 3 alternatives to this npm package, then scrape each one's GitHub README and tell me which has the most recent commit activity."

That chains google_search_parsed for the initial search, then scrape_as_markdown on each result to pull the README content, all inside one agent turn.

2. Context7

Context7 keeps Cursor's library knowledge up to date, so it doesn't hallucinate an API that changed or never existed. It's one of the quietly essential servers on this list. It just does what every developer knows to do but often skips under a deadline: check the official docs before writing the code. The server resolves the library you name, then pulls the relevant documentation into context, including version-specific references where available.

It works best with libraries that have good documentation. A small internal package with a thin README won't get the same benefit.

Config:

Example prompt: "Set up a nested route using the current React Router API."

The agent pulls the current React Router docs before writing the route, so the nesting syntax matches the version you have installed.

3. Playwright

Playwright MCP brings browser automation and end-to-end testing into Cursor. Built by the Microsoft Playwright team, the server lets the agent control a real browser, navigate pages, fill forms, click elements, and inspect results, including console errors that source code alone can't reveal.

Running a browser adds overhead, so Playwright suits interactive testing better than tasks like reading documentation or inspecting code.

Config:

The first run downloads browser binaries.

Example prompt: "Log in with the test account and confirm the dashboard loads without a console error."

Developer tools

The agent can write the code, but shipping it often means checking a failed build, following up on a review comment, or updating a ticket in another tab. These MCP servers bring those steps into Cursor, so the agent can work across the development workflow without the context switching.

4. GitHub

GitHub's official MCP server connects Cursor to the parts of GitHub that live outside your local clone. Cursor handles local git, but issues, PR reviews, and Actions runs live on github.com. GitHub's official server brings them into the chat, so the agent can read an issue or check a failed workflow without leaving Cursor.

Watch the token, however. Its scopes set the agent's ceiling, so grant only what you'd hand an AI tool, or point Cursor at a read-only toolset endpoint such as /mcp/x/repos/readonly.

Config:

Replace YOUR_GITHUB_PAT with a personal access token. The server requires Cursor v0.48.0+.

Example prompt: "List the open PRs that touch this file and summarize the unresolved review comments."

The agent finds the relevant PRs, reads each thread, and maps the comments to your code.

5. Sentry

Sentry's MCP server gives Cursor access to your project's production errors, including unresolved issues, their culprits, timestamps, and links back to Sentry.

That focus changes how you debug. Instead of manually pasting a stack trace into the Cursor chat, you can have the agent retrieve the Sentry issue through MCP and trace it to the relevant code in your project.

That said, the server is built for developer workflows and debugging specifically, not as a general-purpose way to manage Sentry, so don't expect it to touch settings or billing.

Config:

Example prompt: "Show the 5 most frequent unresolved errors in the checkout project this week, trace each to this repo, and propose a fix."

The agent locates the project with find_projects, pulls the errors with search_issues, then opens the relevant code.

6. Linear

Most tickets end with the same chore. You ship the fix, then switch to Linear to update the status and leave a comment. Linear's official MCP server hands that step to the agent, with tools to find, create, and update issues, projects, and comments in Cursor.

The default endpoint is read-write, which means the agent can close or reassign anything you can. For context only, point Cursor at /mcp/readonly and it gets read tools and nothing else.

Config:

Sign in through OAuth, or install Linear from Cursor's MCP tools page.

Example prompt: "Read ENG-123, implement the fix, then move it to In Review and comment with the files you changed."

Paired with Sentry, that closes the entire loop from production error to reviewed ticket.

Design and docs

Design and documentation often live outside the codebase, out of the Cursor agent's reach. The next couple of servers bring that context into the development workflow, so the agent can work directly with the source material and not have to rely on pasted screenshots:

7. Figma

Figma's official MCP server gives Cursor structured access to your design files, including variables, components, and layout data. That gives the agent the design context it needs to generate code from the actual design rather than approximating it from an image.

The usual way to get a design into Cursor is to drop a screenshot into the chat. But a screenshot only shows what the design looks like. It doesn't give the agent the underlying variables, components, or layout data, leaving it to reconstruct those details and potentially leaving you to fix the differences in review.

Config:

Click Connect under Cursor's Tools & MCP settings to sign in with your Figma account, or run /add-plugin figma to install the server with Figma's skills.

Figma's MCP server is currently free during the beta period, but the write-to-canvas feature will eventually become usage-based and paid. Read-oriented tools are also subject to rate limits that vary by plan and seat, so check the limits that apply to your account before building a workflow around it.

Example prompt: "Build the pricing card from this Figma link using our existing Button component and color tokens."

Cursor can then use the frame's structure and variables to generate the implementation against your existing components.

8. Notion

Notion's hosted MCP server lets Cursor search your workspace, read pages as Markdown, and create or update pages and databases. This is useful when the information Cursor needs to work from lives outside the repo, such as specs, PRDs, and decision logs.

But since Cursor connects to Notion through your account, it has the same permissions you do. That means it can also edit any page you can access. The way to go is to start with read-only prompts while you establish the workflow. Also keep in mind that workspace owners can revoke the connection under Settings.

Config:

Save, restart Cursor, and sign in to Notion the first time Cursor calls one of its tools. Add it to .cursor/mcp.json to share the configuration with your team.

Example prompt: "Read the checkout redesign PRD, list its acceptance criteria, and check which ones the current implementation misses."

Cursor can then pull the requirements from Notion and compare them with the code it's working on, without you having to move the PRD into the chat manually.

Data and files

Connecting Cursor to your database and to folders outside the project lets it query real data and read other repos directly:

9. Supabase

Supabase maintains an MCP server that lets Cursor list tables, run SQL, and check logs and advisors in your projects. That access pays off when the code and the database disagree. Instead of hallucinating column names from a model file that's drifted from the database, Cursor queries the table it's writing against and works from the actual schema.

Config:

Generate the URL from your Supabase dashboard, which fills in project_ref and read_only for you, or edit YOUR_PROJECT_REF by hand. Cursor opens a browser sign-in on first connect, so pick the organization that holds the project you want.

The 2 query parameters matter because the defaults are broad. Without project_ref, the server can reach every project in your account, and without read_only=true, it can write data and apply migrations. Supabase recommends both and advises keeping the server away from production data.

Example prompt: "Compare the orders table schema with the Order type in this file and list any columns that don't match."

Cursor reads the live schema, then diffs it against your type definition.

10. Filesystem

Filesystem gives Cursor read, write, and search access to the directories you specify when the server starts. It's one of the original MCP reference servers, and another quietly useful one, valuable once your work extends beyond the project you have open in Cursor.

Cursor already handles files in your open project, so Filesystem is mainly useful for directories outside it, such as a shared config repo or a sibling service in another folder. You can give the server access to those directories when you configure it, and Cursor can then work with the files inside them.

Config:

Each path you add after the package name becomes an allowed directory, while requests outside those paths are turned away. Because Cursor can write and move files within the allowed directories, not just read them, keep the list as narrow as the task requires.

Example prompt: "Read the shared ESLint config in platform-config and update this project's config to match."

Cursor can then read the config from the other repo and apply the relevant rules to the project you're working on.

Getting more out of a stacked setup

Running several MCP servers in Cursor is less about how many you can add and more about how well you configure the stack. Once you have several servers connected, you need to manage which tools Cursor can choose from, where each server applies, and what it can access or change.

Since Cursor's dynamic context discovery update in January 2026, it initially exposes only tool names and fetches full definitions on demand. That makes stacking servers more practical, but it doesn't remove the need to manage the stack. More servers mean more tools for Cursor to choose from, and some may cover the same task.

Give each server a clear role. For instance, Decodo and Playwright can both fetch web content. If you don't need both for the same workflow, name the server you want or disable the other under Customize > MCPs.

Keep each server at the right scope. The project's .cursor/mcp.json is shared with the team, while ~/.cursor/mcp.json is local to your machine. The project configuration wins when both define the same server. For instance, a Supabase server scoped to one project belongs in the first, and Filesystem for your local folders belongs in the second.

Keep credentials out of shared configs and state-changing tools behind approval. For instance, use environment variables for GitHub tokens and automate read-only tools, while keeping actions like creating Linear issues or running Supabase migrations behind confirmation.

The same servers can also work in VS Code, Windsurf, and Claude, although each client handles MCP configuration differently. See the Claude MCP setup guide for the equivalent setup.

Final thoughts

The right Cursor MCP stack isn't the one with the most servers. It's the one that gives the agent what it can't already see, plus the tools it needs for the work you actually do.

Start with the two servers that change what the agent can know: Decodo for the live web and Context7 for accurate library docs. Then add the rest per workflow, keeping project-specific connections scoped to the repo and using read-only access where you don't need writes. Ten good servers beat thirty installed ones, because even with dynamic context, every tool is still an option the agent has to weigh.

If your Cursor workflows involve live web data, Decodo can give your agent direct access to search results and web pages through MCP, without leaving the editor. Connect Decodo to Cursor to get started.

Reviewed by Abdulhafeez Yusuf