Best Cursor Plugins and MCP Tools for Developers in 2026

Want Cursor's agent to search and read the live web? Add TinyFish to Cursor. TinySearch and TinyFetch are free.

TL;DR

The best Cursor MCP servers in 2026 are the ones that give Cursor's agent something it can't do on its own: read the live web, open your GitHub issues, see your production errors, query your database, check a deployment, or pull current library docs. Here is the short version:

• Live web research and browser access: TinyFish. One MCP server gives the agent web search, clean page reading, multi-step browser automation and remote browser sessions. Search and page reading are free.
• Testing your own app in a browser: Chrome DevTools MCP.
• Code and GitHub: the official GitHub MCP Server.
• Errors: Sentry MCP.
• Databases: Supabase MCP or Neon MCP, ideally in read-only mode.
• Deployment: Vercel MCP.
• Docs: Context7.
• Issues and design: Linear MCP and Figma MCP.

Start with three or four, not ten. Every tool you switch on is one more option the agent has to read and choose from.

A quick disclosure: I work at TinyFish, and TinyFish is first on this list. I've tried to be straight about where each tool, ours included, is the right pick and where it isn't. Every setup step and price below comes from the vendor's own docs or pricing page, checked in November 2026.

At a glance

Cursor plugins, MCP servers and extensions: what's the difference?

These three words get used interchangeably, but they mean different things in Cursor:

• MCP servers expose tools the agent can call. The Model Context Protocol is an open standard, so the same server usually works in Cursor, Claude Code, Codex and other clients. An MCP server is where the actual capability lives: "search the web", "list my open pull requests", "run this SQL".
• Cursor plugins are bundles. According to Cursor's plugin docs, a plugin can package rules, skills, agents, commands, MCP servers and hooks into one install. Most vendor plugins wrap the vendor's MCP server and add skills that teach the agent when and how to use it. Cursor supports both its own plugin format (.cursor-plugin/plugin.json) and the open Agent Plugins standard (a plugin.json at the plugin root).
• Cursor extensions are VS Code-style editor extensions: themes, linters, language support, GitLens and so on. They improve the editor you work in. They don't give the agent new tools.

So when people search for the best Cursor plugins or the best Cursor extensions for AI coding, what they usually want is new abilities for the agent. That means MCP servers, often installed as plugins.

How to add MCP servers and plugins to Cursor

There are three ways, and they all end up in the same place.

1. From the Cursor Marketplace. The Cursor Marketplace lists official plugins. Open Customize in the sidebar, search for a plugin, select Install, and choose project or user scope. Cursor says every marketplace plugin is manually reviewed before it's listed. For community plugins and MCP servers, Cursor points to cursor.directory.

2. With `mcp.json`. For any server that isn't in the marketplace, add it to a config file:

• .cursor/mcp.json in your repo, for tools only that project should have
• ~/.cursor/mcp.json in your home folder, for tools you want everywhere

A remote server is just a URL:

{
  "mcpServers": {
    "tinyfish": {
      "url": "https://agent.tinyfish.ai/mcp"
    }
  }
}

A local server is a command Cursor starts for you:

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

3. With an install link or CLI. Many vendors publish an "Add to Cursor" button, which uses Cursor's deeplink format, or a one-line installer that writes the config for you.

A few details from Cursor's MCP docs that save time:

• Cursor supports three transports: stdio (local), SSE and Streamable HTTP (local or remote). Remote servers can sign you in with OAuth.
• You can reference secrets with ${env:NAME} instead of pasting keys into the file.
• Cursor asks for approval before running MCP tools by default. MCP tools follow the same Run Modes as terminal commands.
• If a server doesn't show up, open the Output panel and pick MCP Logs.
• You can toggle servers on and off in Customize without deleting them.

How I grouped these

I grouped the tools by the job they do for the agent, not alphabetically. For each one I checked four things, all against the vendor's own docs:

• Who maintains it. Every pick is maintained by the vendor itself (or, for Chrome DevTools, by the Google team behind Chrome).
• How easy it is to connect. A hosted URL or a one-line local install.
• How narrowly you can scope it. OAuth, read-only modes, project scoping, or a way to turn tool groups off.
• What it costs. The MCP server itself is usually free. The service behind it may not be, so I list the real plan prices.

Each entry follows the same template: what it is, what it adds to Cursor's agent, setup, where it struggles, pricing, and who it's for.

Web research and browser access

1. TinyFish: live web search, page reading and browser automation

What it is. TinyFish is one API that lets AI agents use the live web. In Cursor it connects as a single MCP server at https://agent.tinyfish.ai/mcp, with one account and one key behind everything: TinySearch for web search, TinyFetch for reading pages, TinyAgent for multi-step tasks on real websites, and TinyBrowser for remote browser sessions. TinyFish is also listed in the Cursor Marketplace.

What it adds to Cursor's agent. Cursor's agent knows your codebase. It doesn't know what changed on the web after its model was trained. TinyFish closes that gap with a handful of tools (full list in the docs):

• search returns structured results with titles, snippets and URLs. You can filter by date, recency, news or research papers, location, language and domain.
• fetch_content reads up to 10 URLs per request and returns clean markdown, HTML or JSON. It renders JavaScript-heavy pages when needed and can scope extraction with CSS selectors.
• run_web_automation takes a URL and a plain-English goal, then clicks, navigates, fills forms and logs in on a real site, streaming progress as it goes. There's an async version for long runs.
• Deep research tools start a multi-source run that comes back as a cited report, built on TinyResearch.
• Monitor tools watch a page or a search topic on a schedule and send a webhook when something changes, using TinyMonitor.

In practice, these are the prompts I use it for in Cursor:

• "Find the official migration guide for this library's new major version, read it, and update our code to match."
• "Read this vendor's API changelog and tell me whether the endpoint we call is deprecated."
• "Check this competitor's pricing page and write the numbers into our comparison table."
• "Search for open GitHub issues about this error message and summarize the workarounds people found."

The split between search and fetch matters for context. Search finds the right pages; fetch pulls back only the clean text, not the navigation, ads and scripts around it. That keeps long research sessions from filling Cursor's context window, which is the same problem we wrote about in context rot.

Setup. Pick one of three ways.

Option 1: in Cursor, open Customize, search for TinyFish and install it.

Option 2: run the one-line installer from the TinyFish docs:

npx -y install-mcp@latest https://agent.tinyfish.ai/mcp --client cursor

Option 3: add it to ~/.cursor/mcp.json (or .cursor/mcp.json for one project):

{
  "mcpServers": {
    "tinyfish": {
      "url": "https://agent.tinyfish.ai/mcp"
    }
  }
}

Then sign in with your TinyFish account when Cursor prompts you. The For Coding Agents page has a single-page context dump you can hand to Cursor if you're building on the API directly.

Where it struggles.

• TinyAgent runs take time. TinyFish's docs list a typical 15 to 60 seconds for an agent run, against 1 to 3 seconds for a search. Use search and fetch first, and keep the agent for sites that genuinely need clicking and typing.
• It runs in the cloud, so it can't reach a dev server on your localhost. For testing your own app locally, use Chrome DevTools MCP below.
• Accounts start at 2 concurrent TinyAgent runs and 5 concurrent TinyBrowser sessions. Higher limits are set by talking to sales, not by paying more.

Pricing. From the TinyFish pricing page:

• TinySearch: free, within 30 requests a minute and 500 an hour
• TinyFetch: free, within 150 URLs a minute and 1,000 URLs a day
• TinyAgent: $0.016 per step
• TinyBrowser: $0.002 per minute
• TinyMonitor: $0.005 per check
• New accounts start with $8 in Wallet funds, so you can try TinyAgent and TinyBrowser before adding a card. There's no subscription or monthly minimum.

We've written about why search should be free for agents and published a search API benchmark if you want the reasoning and the numbers.

Who it's for. Any Cursor user whose agent needs current information from the open web: library docs that changed last week, a changelog, a pricing page, a form on a site with no API. If you only add one tool from this list, this is the one that changes what the agent can answer.

Building something that reads the web? Get a free TinyFish key. TinySearch and TinyFetch cost nothing to start.

2. Chrome DevTools MCP: debugging a live Chrome

What it is. Chrome DevTools MCP, from the Chrome DevTools team, lets your coding agent control and inspect a live Chrome browser. It's open source under Apache-2.0.

What it adds to Cursor's agent. DevTools access: network requests, console messages with source-mapped stack traces, screenshots and performance traces. Ask it to "check the performance of this page" and it records a trace and pulls out the insights.

Setup.

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

It needs a current Node.js LTS and Chrome stable. The --slim flag exposes a smaller tool set for basic browser tasks.

Where it struggles. It officially supports Google Chrome and Chrome for Testing only. Usage statistics go to Google by default (opt out with --no-usage-statistics), and performance tools can send trace URLs to the CrUX API unless you pass --no-performance-crux. Like any tool that can read the browser, don't point it at sessions with data you wouldn't share with the model.

Pricing. Free and open source.

Who it's for. Frontend developers chasing console errors, slow pages and failing network calls.

How these two fit together. Chrome DevTools is for the app you're building, in a browser on your machine. TinyFish is for the rest of the web: search, reading other sites, and doing tasks on sites you don't control, from the cloud. Most frontend teams end up wanting both. If you want the longer version of that distinction, read computer-use agents vs web agents and what a cloud browser is.

Code and GitHub

3. GitHub MCP Server: repos, issues and pull requests

What it is. The GitHub MCP Server is GitHub's official server, open source under MIT. GitHub is also a plugin in the Cursor Marketplace ("Manage repos, issues, pull requests, and Actions").

What it adds to Cursor's agent. The agent can read issues, open and review pull requests, check Actions runs and search code across repos without you copying links into chat. "Fix the bug in issue 412 and open a PR" becomes one request.

Setup. Install the marketplace plugin, or connect to the hosted server at https://api.githubcopilot.com/mcp/. In mcp.json with a personal access token:

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${env:GITHUB_PAT}"
      }
    }
  }
}

You can also run it locally with Docker or the binary.

Where it struggles. Out of the box it exposes a lot of tools. Use the --toolsets option (for example repos,issues,pull_requests) or individual --tools to keep only what you need, which also helps the agent pick the right tool. For public repos, its lockdown mode limits what content from people without push access the agent sees.

Pricing. GitHub's docs say the server is available to all GitHub users regardless of plan, but individual tools inherit the access rules of the feature they call. Tools that need a paid GitHub or Copilot feature need that subscription.

Who it's for. Anyone whose work starts and ends in GitHub issues and pull requests.

Debugging and errors

4. Sentry MCP: production errors in the agent's context

What it is. Sentry's MCP server connects agents to Sentry for searching errors, analyzing performance, triaging issues and reading Sentry's docs. Sentry is also in the Cursor Marketplace.

What it adds to Cursor's agent. Real stack traces and real error frequency. Instead of describing a bug, you ask the agent to look at the top unresolved issue in a project and fix it.

Setup. All connections use OAuth. Scope the URL to one organization or project, which Sentry recommends:

{
  "mcpServers": {
    "sentry": {
      "url": "https://mcp.sentry.dev/mcp/{organizationSlug}/{projectSlug}"
    }
  }
}

When scoped, tools default to that project and the discovery tools are hidden.

Where it struggles. It's only as useful as your Sentry setup. If your app isn't instrumented, there's nothing to read. Some AI debugging features (Seer) need a paid subscription.

Pricing. From Sentry's pricing page: the Developer plan is free for one user with 5k errors and includes MCP access. Team starts at $26/month and Business at $80/month (billed annually).

Who it's for. Teams fixing bugs that only show up in production.

Databases

5. Supabase MCP: database work with guardrails

What it is. Supabase's MCP server gives the agent access to your Supabase projects: tables, SQL, migrations, logs, edge functions and docs. It's in the Cursor Marketplace too.

What it adds to Cursor's agent. The agent can look at your real schema before writing a query, run it, and check the logs when something fails.

Setup. The hosted server lives at https://mcp.supabase.com/mcp. Supabase's setup page lets you pick a project, turn on read-only mode and choose feature groups, then generates the URL. After you sign in, check the connection in Cursor's MCP settings.

Where it struggles. Supabase's own docs spend a whole section on prompt injection: a malicious string stored in your data could try to make the agent run a query it shouldn't. Their recommendations are to connect to production only when you need production evidence, scope to one project, use read-only mode, and never give the server to your customers, since it runs with your developer permissions. Branching tools need a paid plan.

Pricing. From Supabase's pricing page: the Free plan includes 500 MB of database size and 2 active projects (paused after a week of inactivity). Pro starts at $25/month.

Who it's for. Supabase projects where you want the agent to see the schema, ideally pointed at a development project.

6. Neon MCP: Postgres with branches

What it is. The Neon MCP Server lets the agent manage Neon projects, run queries and make schema changes. Neon is in the Cursor Marketplace as Neon Postgres.

What it adds to Cursor's agent. Neon's branching suits agents well: the agent can try a migration on a branch and you merge it only if it's right.

Setup. Run npx neon@latest mcp to write the config, or point at https://mcp.neon.tech/mcp and sign in with OAuth. Add ?readonly=true for read-only access, or ?projectId=<id> to scope to one project.

Where it struggles. Neon is direct about the risk: its docs recommend MCP for development and testing only, and say never to connect MCP agents to production databases.

Pricing. From Neon's pricing page: the free plan includes 100 projects, 100 CU-hours per project per month and 1 GB of storage per project. Paid usage is billed per CU-hour.

Who it's for. Teams on Postgres who want the agent to work on branches, not the main database.

Deployment

7. Vercel MCP: deployments and logs

What it is. Vercel MCP is Vercel's official remote MCP server, with OAuth, at https://mcp.vercel.com. Vercel is also in the Cursor Marketplace.

What it adds to Cursor's agent. The agent can search Vercel's docs, manage projects and deployments, analyze deployment logs and query analytics. The common use is "why did the last deploy fail?" answered from the actual build logs.

Setup. Use the "Add to Cursor" button on Vercel's docs, or add this to .cursor/mcp.json:

{
  "mcpServers": {
    "vercel": {
      "url": "https://mcp.vercel.com"
    }
  }
}

Cursor then shows a "Needs login" prompt. Click it to authorize.

Where it struggles. Vercel only allows AI clients it has reviewed and approved, so it won't work in every MCP client. Cursor is supported. What the agent can do also depends on your team permissions.

Pricing. Vercel says MCP is available on all plans.

Who it's for. Teams deploying on Vercel who are tired of copying build logs into chat.

Documentation

8. Context7: current library docs

What it is. Context7, from Upstash, pulls up-to-date, version-specific documentation and code examples into the agent's context. It's in the Cursor Marketplace.

What it adds to Cursor's agent. Fewer invented APIs. It exposes two tools: resolve-library-id to find the right library and query-docs to fetch the relevant docs. Add "use context7" to a prompt, or set a Cursor rule so it's used automatically for library questions.

Setup. Run npx ctx7 setup --cursor (needs Node.js 22.13 or newer), which signs you in and installs a skill. Or connect manually to https://mcp.context7.com/mcp with your API key in an Authorization: Bearer header.

Where it struggles. It covers libraries that are in its index, which is community-contributed, and Context7 itself says it can't guarantee the accuracy of every library's docs. For a vendor page, changelog or blog post that isn't in the index, use TinyFish's search and fetch instead.

Pricing. From Context7's plans: Free includes 1,000 API calls. Pro is $10 per seat per month with 2,000 calls per seat and extra calls at $5 per 1,000.

Who it's for. Anyone writing code against fast-moving libraries and frameworks.

Planning and design

9. Linear MCP: issues in, code out

What it is. Linear's MCP server is hosted and managed by Linear, using Streamable HTTP and OAuth at https://mcp.linear.app/mcp.

What it adds to Cursor's agent. The agent can find, create and update issues, projects and comments. It can read the issue it's fixing and write back what changed.

Setup. Add the URL to mcp.json or install the Linear plugin from the Cursor Marketplace. For read-only access, use https://mcp.linear.app/mcp/readonly, which only exposes read tools.

Where it struggles. Linear notes the tool set is still growing, so some workflows still need the app.

Pricing. From Linear's pricing page: the Free plan includes MCP access, unlimited members, 2 teams and 250 issues. Basic is $10 and Business $16 per user per month, billed yearly.

Who it's for. Teams that plan in Linear and want issue context without tab-switching.

10. Figma MCP: design context for frontend work

What it is. The Figma MCP server brings Figma into the agent's workflow. Figma recommends the remote server at https://mcp.figma.com/mcp.

What it adds to Cursor's agent. Variables, components and layout data from your files, code generated from a selected frame, and, with the right skills, the ability to write native content back to the canvas.

Setup. Install the Figma plugin from the Cursor Marketplace, or add the remote server URL. The desktop server is meant for specific organization needs and requires a Dev or Full seat on a paid plan.

Where it struggles. Writing to the canvas requires a Full seat to write outside your drafts, and Figma says it's free during the beta but will become a usage-based paid feature. Usage and rate limits depend on your plan.

Pricing. Figma lists the MCP server as available on all plans, with limits by plan and seat.

Who it's for. Frontend developers building from Figma designs and design systems.

How to choose

If you only remember one thing: pick tools by the questions your agent keeps failing to answer.

• "That API changed" or "I can't find that page." Add TinyFish for search and page reading. Add Context7 if most of the gaps are library docs.
• "I can't see what the UI does." Add Chrome DevTools MCP for console, network and performance.
• "Which issue was this again?" Add the GitHub MCP Server or Linear MCP, wherever your issues live.
• "Why is this failing in production?" Add Sentry MCP for errors and Vercel MCP for deploy logs.
• "What does the schema look like?" Add Supabase MCP or Neon MCP, in read-only mode against a development project.
• "Build what's in the design." Add Figma MCP.

Three starter stacks that work well:

TinyFish is in all three for the same reason: whatever you're building, the answer to "what changed?" usually lives on the web, not in the repo.

Mistakes to avoid

Switching everything on. Every enabled tool is another option the model reads and chooses from. The RAG-MCP paper found that filtering tools before the model sees them cut prompt tokens by over 50% and more than tripled tool selection accuracy (43.13% against a 13.62% baseline) on the authors' benchmark. Cursor's own advice is to disable servers you don't need to reduce "tool clutter". Toggle them per project in Customize, and use options like GitHub's --toolsets or Chrome DevTools' --slim to trim tool lists.

Giving tokens more access than the job needs. Prefer OAuth where the server supports it. Where you need a token, make it narrow: a fine-grained GitHub token for one repo, a project-scoped Supabase or Neon connection, a read-only Linear endpoint.

Pointing agents at production data by default. Supabase and Neon both warn about this. Work against a development project or branch, and only connect production when the task needs production evidence.

Forgetting that content can carry instructions. A web page, an issue comment or a database row can contain text written to steer the model. Keep tool approval on for anything that writes, read the arguments before you approve, and be careful which Run Mode you use.

Hardcoding secrets in `mcp.json`. Use ${env:NAME} instead, and keep project configs free of keys if they're committed to the repo.

Putting every server in the global config. A database or deploy tool belongs in .cursor/mcp.json for the project that needs it, not in ~/.cursor/mcp.json where it's active in every repo.

What changed for Cursor plugins in 2026

If you set up MCP in Cursor a year ago, a few things are different now:

• The Cursor Marketplace. Official plugins install from Customize, are manually reviewed, and can bundle MCP servers with skills, rules, agents, commands and hooks.
• The Agent Plugins open standard. Cursor loads spec-conformant Agent Plugins alongside its own format, so more plugins work across coding agents.
• Team marketplaces. On Teams and Enterprise plans, admins can distribute plugins and MCP servers and mark them Default Off, Default On or Required.
• MCP Apps. MCP tools can return interactive UI inside Cursor, and fall back to normal responses where a host can't render it.
• Better OAuth. Remote servers increasingly sign you in with OAuth instead of asking for an API key, which is how most servers on this list now work.

If you're comparing other assistants too, we've done the same exercise for ChatGPT plugins, and there's a walkthrough of TinyFish's official Claude plugin.

Give Cursor's agent the live web. Start free with TinyFish: TinySearch and TinyFetch are free, and new accounts get $8 for TinyAgent and TinyBrowser.