How to Use MCP Servers in Cursor (No Config Files)

Some links may be affiliate links. We may earn a commission at no extra cost to you.

Every MCP setup guide for Cursor opens with a JSON config file. That's the wrong place to start — and it's why most beginners close the tab. Cursor has a built-in GUI for adding MCP servers, and many popular servers have a one-click "Add to Cursor" button right on their docs page.

If you don't know what MCP is yet, read what MCP is and why it matters first — it's a quick read. If you're already comfortable with the concept, keep going.

What MCP Servers Do Inside Cursor (30-Second Version)

MCP servers give Cursor's AI direct, structured access to external services. Instead of pasting a database schema into chat or copy-pasting GitHub issues by hand, the AI calls a tool that fetches live data from the source.

The result is that Cursor can answer questions like "what's in my users table right now?" or "which issues are blocking this PR?" without you doing any manual copy-paste work.

The Difference from Claude Code's MCP Setup

If you've already set up MCP in Claude Code, one thing will trip you up: your Claude Code servers are not available in Cursor automatically. They use separate config files and separate config paths.

Claude Code uses a global ~/.claude/ config that applies across your whole machine. Cursor uses a project-level .cursor/mcp.json inside each project folder — or a global ~/.cursor/mcp.json for servers you want everywhere. They don't share configs.

For a fuller breakdown of the differences between the two tools, see Cursor vs Claude Code for beginners. If you want to set up the same GitHub MCP in Claude Code, that process is covered separately in how to connect Claude Code to GitHub MCP.

Project-Level vs Global Config — What That Means for You

When you add a server through the GUI, Cursor writes it to .cursor/mcp.json in your current project by default. That means the server is only active when you have that project open.

If you want a server available in every project, you can edit ~/.cursor/mcp.json directly — but the GUI path covered in this guide is project-level. For most beginners, project-level is fine. You can always move the config later.

Before You Start: What You Need

You need a working Cursor installation and access to whichever service you're connecting (a Supabase project, a GitHub account, or a Stripe account). Nothing else.

Cursor Version Check (Keep Cursor Up to Date)

MCP support requires a recent version of Cursor. If the MCP panel doesn't appear in settings, update first: open Cursor → Help → About to check your version, then update via cursor.com if needed.

Where to Find the MCP Settings Panel

Open Cursor Settings (Cmd+, on Mac, Ctrl+, on Windows/Linux). In the left sidebar, look for Tools & MCP. That's where all your MCP servers live. If you don't see this section, your Cursor version is too old.

How to Add an MCP Server Using the GUI (No JSON)

This is the path most guides skip. It works for the majority of servers.

Step 1 — Open Settings → Tools & MCP

Hit Cmd+, / Ctrl+,, then click Tools & MCP in the sidebar. You'll see any servers already configured, plus an Add new MCP server button at the top.

Step 2 — Click "Add new MCP server"

A dialog opens with three fields: Name, Type (transport), and either a command or URL depending on the transport type.

Step 3 — Fill In Name, Transport Type, and URL or Command

Cursor supports three transport types:

• stdio — runs a local process (a CLI command). Use this for locally installed servers like GitHub MCP (Docker) and Stripe MCP (npm).
• SSE — connects to a remote server over HTTP using server-sent events. Older transport; being phased out in favor of Streamable HTTP.
• Streamable HTTP — the modern remote transport. Use this if a server gives you an https:// URL.

For the three examples in this guide: Supabase uses Streamable HTTP (remote URL), GitHub uses stdio with Docker, and Stripe uses stdio with an npm package.

Step 4 — Save and Restart Cursor

After filling in the fields, click Save. Cursor will write the entry to .cursor/mcp.json and prompt you to restart. Restart the editor. When it comes back up, the server status dot should be green.

The One-Click Path: "Add to Cursor" Buttons on MCP Docs Pages

Some MCP servers — and most listings on directories like mcp.so — include an "Add to Cursor" button that pre-fills the GUI dialog for you. Supabase's official docs page includes one. If you see one, click it. It opens Cursor directly and skips manual entry. If the page you're on doesn't have the button, use the manual steps above.

Example 1: Connect the Supabase MCP

The Supabase MCP server is one of the most useful servers for anyone building on a Postgres backend. It's maintained by the Supabase community and works in Cursor, Claude Code, and Windsurf.

For a deeper look at database MCP options including Neon and others, see best MCP servers for databases.

What It Lets Cursor Do

With the Supabase MCP connected, Cursor can query your database tables, describe your schema, insert and update rows, and check auth user records — all through natural-language prompts in chat.

Step-by-Step: Get the Connection URL, Add the Server, Test It

1. Log into your Supabase project at https://supabase.com. Go to the MCP connection tab in the dashboard to get a pre-configured URL — it looks like https://mcp.supabase.com/mcp?project_ref=<your-project-ref>.
2. In Cursor: Settings → Tools & MCP → Add new MCP server.
3. Name: Supabase (or your project name). Type: Streamable HTTP. URL: paste the connection URL.
4. Save, restart Cursor.
5. Test: open Agent chat and type list all tables in my database. If it returns table names, it's working.

Example 2: Connect the GitHub MCP

The GitHub MCP server is official — maintained by GitHub directly, not a community fork. It uses stdio transport and requires a Personal Access Token (PAT).

What It Lets Cursor Do

Cursor can read issues, list pull requests, search repositories, create branches, and comment on PRs — without you leaving the editor. This is especially useful for "fix the bug described in issue #42" style prompts.

Step-by-Step: Create a PAT, Add the Server, Test with a Real Prompt

1. Go to github.com/settings/tokens and create a Fine-grained PAT with read access to your repositories (add write access if you want Cursor to create branches or comment).
2. In Cursor: Settings → Tools & MCP → Add new MCP server.
3. Name: GitHub. Type: stdio. Command:

   docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server
   

   Note: the npm package @modelcontextprotocol/server-github was deprecated in April 2025. The official method is the Docker image above — you need Docker installed on your machine.
4. You'll need to pass your PAT as an environment variable (GITHUB_PERSONAL_ACCESS_TOKEN=<your-token>). The Cursor GUI does not surface an env vars field for stdio servers; add it via the mcp.json method shown at the end of this guide.
5. Save, restart Cursor.
6. Test: type list open issues in <your-repo> in Agent chat. You should get a live list from GitHub.

Example 3: Connect the Stripe MCP

The Stripe MCP server is official — documented at docs.stripe.com/mcp and published under the @stripe/mcp npm package by Stripe. It uses stdio transport.

What It Lets Cursor Do

Cursor can look up charges by ID, check a customer's subscription status, list recent failed payments, create payment links, and initiate refunds — all from chat. This is most useful when you're debugging production issues and want to query Stripe data without leaving the editor.

Step-by-Step: Get the API Key, Add the Server, Test with a Charge Lookup

1. Go to stripe.com/dashboard → Developers → API keys. Stripe recommends creating a restricted key with only the permissions you need — this limits what the MCP server can do if your key is ever exposed. A standard secret key also works but gives the server full API access.
2. In Cursor: Settings → Tools & MCP → Add new MCP server.
3. Name: Stripe. Type: stdio. Command:

   npx -y @stripe/mcp
   

4. Add your API key as an environment variable: STRIPE_SECRET_KEY=<your-key>.
5. Save, restart Cursor.
6. Test: type look up the last 5 charges in my Stripe account in Agent chat. You should see a live list from your Stripe data.

How to Check If an MCP Server Is Actually Working

After restarting Cursor, go back to Settings → Tools & MCP. Each server has a status indicator next to its name.

The Green Dot and What It Means

A green dot means Cursor has successfully initialized the server and can call its tools. A grey or red dot means the connection failed — usually a wrong command, a missing env var, or a network issue with a remote server.

Green dot does not mean Cursor will use the tools automatically. It means they're available. You still need to prompt Cursor to use them.

A Quick Test Prompt for Any Server

Open Agent mode in Cursor chat (not Inline Edit — Agent mode is what calls MCP tools). Type something that requires live data from that service:

• Supabase: describe my database schema
• GitHub: list open pull requests in <repo>
• Stripe: show me the most recent failed payment

If the AI fetches real data back, the server is working. If it says it doesn't have access or tries to ask you for the information instead, check the troubleshooting section below.

Troubleshooting: 3 Things That Go Wrong

Server Shows "Disconnected" After Restart

This almost always means the command is wrong or a required environment variable is missing. Open .cursor/mcp.json and check that the command matches exactly what the server's docs specify. For stdio servers, make sure the env vars block includes your token or API key.

Cursor logs MCP errors to the developer console (Help → Toggle Developer Tools → Console tab). If the server fails to start, the error message is usually there.

Cursor Doesn't See the Server at All

If the server doesn't appear in Tools & MCP after saving and restarting, the most common cause is that the config was written to the wrong file. Check whether .cursor/mcp.json was created in your project root. If you expected a global config, check ~/.cursor/mcp.json instead.

Commands Work but Cursor Ignores the MCP Tools

Make sure you're using Agent mode, not Ask or Inline Edit. MCP tool calls only happen in Agent mode. If you're in the right mode and Cursor still doesn't use the tools, try being explicit: use the Supabase MCP tool to list my tables.

Also worth knowing: MCP tool calls may count against your Cursor request quota depending on your plan. If you're running low on fast requests, that could explain why the AI avoids calling tools and falls back to asking you for information.

When You Do Need to Edit mcp.json by Hand

The GUI covers most cases. There's one situation where it falls short: stdio servers with multiple custom environment variables where Cursor's GUI doesn't surface an env vars input field.

What the File Looks Like and Where It Lives

Your project-level MCP config lives at .cursor/mcp.json in the project root. Here's what a complete entry looks like:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    },
    "stripe": {
      "command": "npx",
      "args": ["-y", "@stripe/mcp"],
      "env": {
        "STRIPE_SECRET_KEY": "your-key-here"
      }
    }
  }
}

The structure is the same whether you're editing the project-level file or the global ~/.cursor/mcp.json.

The One Case Where the GUI Isn't Enough (stdio with Custom Env Vars)

Cursor's GUI does not surface an env vars input field for stdio servers. You need to open .cursor/mcp.json and add the "env" block manually. It's one edit — paste the JSON structure above, replace the placeholder values, and save. Cursor picks up the change on the next restart without you needing to re-enter anything through the GUI.

---

Once you have a couple of servers running, the next useful step is knowing which ones are actually worth connecting. Best MCP servers for beginners covers the top picks that work well out of the box. If you're going live with a project and want Stripe and Sentry connected, best MCP servers for going live is the natural follow-up.

MCP is also part of how Cursor's agent infrastructure works under the hood — if you're using Cursor 3 specifically, that context is in what's new in Cursor 3: agents window explained.

To try Cursor with MCP, download Cursor here.