Cursor MCP Tools: 15 Best Servers to Supercharge Your AI

Cursor MCP tools are servers that give the AI agent executable powers—filesystem read/write, browser automation, screenshot capture, database queries—so your prompts turn into real changes instead of code suggestions you copy-paste. The @filesystem server lets Cursor read and edit files across your project; @playwright drives a headless browser; @postgres runs SQL; and screenshot servers like PinVari capture UI context with named accessibility elements. Most developers install 3–5 MCP servers and never touch raw Cursor rules again, because the agent already knows how to use the tool when the task needs it.

The problem: Cursor ships with three built-in servers (@filesystem, @brave-search, @memory), but the other 500+ MCP servers published on GitHub require manual JSON config in ~/.cursor/mcp.json, and half of them error silently when you forget the --scope user flag or point to the wrong binary path. You waste an hour fixing "command not found" instead of shipping.

What are Cursor MCP tools and why does every vibe coder need them?

MCP (Model Context Protocol) is Anthropic's open standard for giving AI agents executable tools—not just context, but actions. A server exposes tools (functions the LLM can call), prompts (reusable templates), and resources (dynamic data like file trees or API responses). Cursor's AI calls the tool, the server runs it on your machine, and the result flows back into the chat.

Before MCP, you pasted file contents into chat or wrote a custom script every time you needed the agent to read a database. After MCP, you install the @postgres server once, and every "show me users with role=admin" runs SELECT * FROM users WHERE role='admin' automatically.

Why vibe coders care: you describe what's wrong ("the signup form doesn't validate email"), and the agent uses @filesystem to read signup.tsx, @playwright to test the form in a real browser, and a screenshot server to see the actual error state—no manual file hunts, no trial-and-error in DevTools.

The 15 best Cursor MCP servers in 2026

Install pattern for third-party servers: every npx @modelcontextprotocol/server-* needs a JSON block in ~/.cursor/mcp.json. Example for @playwright:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-playwright"
      ]
    }
  }
}

Restart Cursor (Cmd+Q, reopen), and the server appears in the MCP panel. If it doesn't, check ~/.cursor/logs/mcp-*.log—usually a missing npx in PATH or a typo in the server name.

How PinVari's MCP connector beats generic screenshot servers

Generic screenshot MCPs (like @screenshot or @mcp-server-screenshot) return a PNG and maybe OCR text. PinVari returns the named accessibility element you circled—role, label, frame, confidence score—plus the screenshot cropped to that region. When you say "fix this button" and circle a <button> in your browser, the agent gets:

{
  "element": {
    "role": "AXButton",
    "label": "Submit",
    "frame": {"x": 820, "y": 340, "width": 120, "height": 44},
    "confidence": 0.94,
    "provenance": "circled"
  },
  "instruction": "fix this button",
  "screenshot": "<base64 crop of the 120×44 button region>"
}

No guessing which of six buttons you meant. No "I circled the login form but the agent changed the navbar." The AX tree gives the real DOM identity (AXDOMIdentifier, AXDOMClassList on Chromium elements), and Cursor agent mode can trace it back to the source file.

The workflow: hold ⌥⌘A, circle the broken UI, speak "the padding is wrong, should be 16px." PinVari sends the capture to Cursor's pinvari_next_instruction tool. Cursor reads the element path, opens Button.tsx, fixes padding: 8px → padding: 16px, and calls pinvari_mark_done. You never typed a filename.

Install: open PinVari → Connect → Cursor (one click writes the JSON config). Or CLI:

cursor mcp add --scope user pinvari -- "$HOME/.pinvari/mcp/pinvari-mcp"

The app must be running (the connector talks to it on 127.0.0.1:3402). Full docs: pinvari.com/mcp.

When to use @filesystem vs @playwright vs a screenshot server

@filesystem: every task that touches code. Read package.json to check dependencies, search *.tsx for a component name, write a new migration file. The agent calls read_file, write_file, search_files, list_directory—no manual copy-paste. Enable this first.

@playwright: testing user flows (signup, checkout, form validation) or scraping dynamic content. The agent spins up a headless Chromium, navigates to localhost:3000/signup, fills the email field, clicks Submit, and screenshots the error state. Slower than a screenshot server (5–10s to launch the browser), but you get real DOM access and network logs.

Screenshot server (PinVari or generic): when you need to show the agent what's wrong now, on the live page in your actual browser with real data. Generic servers OCR the screen; PinVari resolves the named element. Use PinVari when you're pointing at a specific button/input/table row and want the agent to know which one. Use a generic server for full-page context where the element identity doesn't matter (e.g., "the homepage layout is broken").

Combining them: "The user list table has a broken sort button" → PinVari screenshot captures the AXButton[label="Sort"] + AXTable context → @filesystem reads UserList.tsx → @playwright tests clicking the button in a headless browser → agent sees the console error, fixes the onClick handler.

How to configure cursor mcp json without breaking your setup

Cursor reads ~/.cursor/mcp.json on startup. The file is a single JSON object with a mcpServers key. Each server is a named block with command (the executable) and args (arguments passed to it). Common errors:

1. Forgetting --scope user: cursor mcp add playwright writes to workspace .cursor/mcp.json instead of global config—next project won't see the server.
2. Wrong binary path: "command": "playwright" fails if npx isn't in PATH. Always use "command": "npx" and "args": ["-y", "@modelcontextprotocol/server-playwright"].
3. Trailing commas: JSON doesn't allow them. One trailing comma breaks the whole file, and Cursor shows "MCP initialization failed" with zero details.
4. Missing server package: if you write the JSON by hand but never ran npx @modelcontextprotocol/server-git, the first call hangs while npm downloads it. Pre-install: npx -y @modelcontextprotocol/server-git --version.

Template for three must-have servers (filesystem, playwright, git):

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-playwright"]
    },
    "git": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-git"]
    }
  }
}

Save, restart Cursor, open the MCP panel (icon in the chat sidebar)—all three should show "Connected." If one says "Failed," check ~/.cursor/logs/mcp-<server>.log for the error (usually ENOENT = command not found).

What cursor context used actually means and how MCP affects it

Cursor context used is the token count of everything the agent reads before generating a response—your selected code, open files, cursor rules, and MCP tool results. MCP tools ADD to context used because every tool call returns data (file contents, SQL rows, screenshot base64) that gets appended to the chat.

Example: you ask "why is the login form broken?" and the agent:

1. Calls @filesystem.read_file("app/login.tsx") → 2,400 tokens added
2. Calls @playwright.screenshot("http://localhost:3000/login") → 8,000 tokens (base64 PNG)
3. Calls pinvari_next_instruction (you circled the submit button) → 1,200 tokens (element JSON + cropped screenshot)

Total context used: ~12,000 tokens before the agent even starts writing code. On Cursor's Pro plan (GPT-4 or Claude Sonnet), you have a ~24,000-token context window, so half is gone after three tool calls.

How to control it:

• Disable unused servers: if you installed @postgres but aren't querying a database, remove it from mcp.json. Fewer available tools = faster responses.
• Crop screenshots: PinVari auto-crops to the circled region (saves ~6,000 tokens vs. a full-screen PNG). Generic servers send the whole screen.
• Use @sequential-thinking sparingly: it forces the agent to write a reasoning chain before every action, adding 500–1,500 tokens per turn. Great for complex refactors, wasteful for "change this color."

The MCP panel shows per-server token usage in Cursor 0.42+. If one server dominates (cursor context used meaning: it returned a huge file or API response), you know where to optimize.

Should you use cursor rules or MCP servers for repeatable tasks?

Cursor rules (.cursorrules file in your project root) are instructions the agent reads on every chat—coding style, file structure, testing patterns. Example:

Use Tailwind classes, never inline styles.
All components go in `app/components/`.
Write Vitest tests in `*.test.tsx` files.

MCP servers are executable tools the agent calls when needed—no manual setup per-task. Example: the @git server exposes git_commit, so "commit this fix with message 'fix button padding'" runs the command automatically.

When to use rules:

• Project-specific conventions (naming, folder structure, tech stack)
• "Always do X" patterns (e.g., "always add use client to interactive components")
• Context that never changes (e.g., "this is a Next.js 15 app router project")

When to use MCP:

• Actions that depend on external state (filesystem, database, browser, APIs)
• Repeatable workflows that cross tools (read file → test in browser → commit → screenshot result)
• Anything you'd otherwise do manually in the terminal or DevTools

Combining them: a .cursorrules line like "Use @playwright to test every form before committing" tells the agent to call the MCP server. Rules are the policy; MCP is the execution.

Most vibe coders end up with a 20-line .cursorrules file (stack + style) and 5–7 MCP servers (filesystem, git, playwright, postgres, screenshot). The agent reads the rules, decides which tool to call, and executes.

How to debug "MCP server not working" in 60 seconds

Check 1: Is the server listed in the MCP panel? Open Cursor, click the MCP icon (chat sidebar). If your server isn't there, it's not in ~/.cursor/mcp.json or the JSON has a syntax error. Fix: cat ~/.cursor/mcp.json | jq . (if jq errors, you have invalid JSON).

Check 2: Does the server show "Connected"? If it says "Failed," click it—Cursor shows the last error. Common ones:

• ENOENT: command not found → wrong command path (use "npx" instead of bare "playwright")
• Error: Cannot find module → the npm package isn't installed; run npx -y @modelcontextprotocol/server-<name> --version to pre-download it
• ECONNREFUSED 127.0.0.1:3402 → PinVari-specific: the app isn't running (launch it from /Applications/PinVari.app)

Check 3: Do tool calls execute? In chat, force a tool call: "read the package.json file" (@filesystem) or "take a screenshot of example.com" (@playwright). If the agent says "I don't have access to that," the server is connected but the tool isn't exposed—check ~/.cursor/logs/mcp-<server>.log for initialization errors.

Check 4: Restart Cursor. Cmd+Q, reopen. MCP servers initialize on startup, and edits to mcp.json don't hot-reload.

Nuclear option: delete ~/.cursor/mcp.json, reinstall servers one by one with cursor mcp add --scope user <name> -- <command>, test each before adding the next. If one server breaks the whole chain, you'll know which.

The fastest Cursor MCP workflow for vibe coders in 2026

1. Install the core three: @filesystem (always), @playwright (if you build web UIs), @git (if you want the agent to commit). One-line install:

   cursor mcp add --scope user filesystem -- npx -y @modelcontextprotocol/server-filesystem .
   cursor mcp add --scope user playwright -- npx -y @modelcontextprotocol/server-playwright
   cursor mcp add --scope user git -- npx -y @modelcontextprotocol/server-git

1. Add PinVari for point-and-speak UI fixes. Open PinVari → Connect → Cursor (writes the config automatically). Now ⌥⌘A + circle + "fix this" resolves to the actual named element, not a pixel guess. Install PinVari (one-time $39, first 500 licenses).

1. Add one domain-specific server: @postgres if you query databases, @sentry if you debug production errors, @slack if you auto-post deploys. Don't install all 15—each server adds decision overhead to every chat turn.

1. Write a 10-line .cursorrules file. Example:

   Next.js 15 app router, React 19, Tailwind, Vitest.
   Components in app/components/, utilities in lib/.
   Use @playwright to test forms before committing.
   Use @filesystem to read/write files.
   Use PinVari MCP for UI feedback—always call pinvari_next_instruction when the user circles something.

1. Test the loop: circle a UI element (PinVari), speak "this button should be blue, not gray." The agent gets the element path, reads the component file (@filesystem), changes bg-gray-500 → bg-blue-500, writes the file, and calls pinvari_mark_done. You preview the change in your browser, approve or tweak. Under 30 seconds from circled element to fixed code.

1. Chain tools for complex flows: "The signup form doesn't validate emails—fix it and test in a browser." Agent: reads signup.tsx (@filesystem) → adds a regex check → writes the file → spins up @playwright → fills an invalid email → screenshots the error → confirms it works → commits the fix (@git). You typed one sentence.

This workflow makes AI agent workflows feel like conversation, not configuration. The agent stops asking "which file?" or "what's the element ID?"—it already knows because the tools tell it.

FAQ

What's the difference between cursor mcp and cursor rules?

Cursor MCP servers are executable tools (filesystem, browser, database, screenshot) the agent calls when a task needs them—they do things. Cursor rules (.cursorrules file) are static instructions the agent reads on every chat—they guide how the agent uses those tools. Example rule: "Use @playwright to test every form." Example MCP call: agent runs playwright.goto("localhost:3000/signup") to execute the test. Use rules for project conventions and MCP for actions.

Can I use Cursor MCP tools with other AI coding agents?

Yes—MCP is an open protocol. Claude Code, Codex, Zed, and Windsurf all support MCP servers (same JSON config format). PinVari's MCP connector works with all four (one-click setup in the app for each). The @filesystem, @playwright, and @git servers are agent-agnostic. Only Cursor-specific feature: the MCP panel UI that shows server status and token usage—other agents log MCP calls to the terminal.

How many Cursor MCP tools should I install?

Start with 3–5: @filesystem (required), @playwright or a screenshot server (for UI work), and one domain tool (@postgres, @git, @sentry). Adding 10+ servers slows every chat turn because the agent evaluates all available tools before responding. Install new servers only when you hit a task they solve—if you never query databases, skip @postgres. Most productive setups use 5–7 servers.

Why does PinVari MCP beat a generic screenshot server?

Generic servers send a full-screen PNG and maybe OCR text—the agent guesses which UI element you meant. PinVari resolves the named accessibility element (AXButton, AXTextField) you circled, with role/label/frame/confidence, plus a cropped screenshot of that exact region. When you say "fix this button," the agent gets {role: "AXButton", label: "Submit", frame: {x: 820, y: 340, ...}} and traces it to the source file—no ambiguity, no pixel guessing. That's the accessibility tree advantage.

Do Cursor MCP servers work offline?

Depends on the server. @filesystem, @git, @sqlite, @sequential-thinking run entirely local—no network. @playwright needs internet to install Chromium on first run, then works offline. @brave-search, @github, @sentry, @slack all require network (they call external APIs). PinVari's screenshot + AX capture is 100% on-device (Apple frameworks), but the MCP connector talks to the app on 127.0.0.1:3402, so localhost must be reachable—no VPN issues.

How do I fix "cursor context used" hitting the limit with MCP?

Each MCP tool call adds tokens (file contents, screenshots, API responses). To control it: (1) disable unused servers in ~/.cursor/mcp.json, (2) use cropped screenshots (PinVari auto-crops; generic servers send full screen), (3) avoid calling @sequential-thinking on simple tasks (it adds reasoning overhead), (4) read small files first—if the agent reads a 10,000-line generated bundle, 80% of your context is gone. The MCP panel shows per-server token usage in Cursor 0.42+—check it after every chat to see which tool dominates.