MCP Cursor: install, configure, and connect Cursor to Supabase, APIs, and search

If you want Cursor to write code that aligns with your data, services, and documentation, MCP Cursor is the most direct approach. It’s also a solid foundation for vibe coding, but with reliable tools and context (Supabase, APIs, search) to avoid approximate code.
‍

MCP Cursor in 2 minutes: what it is and why it changes your workflow

MCP stands for Model Context Protocol. The idea is simple: in your Cursor IDE, you connect an MCP server that exposes tools. Then, the AI model can call these tools during development. Instead of “guessing,” it can read context, query an API, perform searches, or fetch useful data.

In practice, MCP Cursor lets you:

• Connect Cursor to Supabase to explore tables, understand the schema, and generate code consistent with your data.
• Add an MCP search server (like Brave) to find the right documentation and verify a version.
• Make the coding workflow more reliable: fewer back-and-forths, less “out-of-context” code, more testing and validation.

If you take away one thing: MCP Cursor is the clean bridge between your IDE and your services.

‍

Get started fast: install and initial MCP configuration in Cursor

The quickest path is to add an MCP server, then verify it appears in Cursor. Cursor reads a JSON configuration, often placed in an mcp.json file. The Cursor docs indicate a global configuration via ~/.cursor/mcp.json to make tools available everywhere.

Where to place the configuration file

Start simple: use a global configuration.

• macOS / Linux: ~/.cursor/mcp.json
• Windows: the principle is the same—a mcp.json file in the Cursor config folder.

Cursor documents this file as the main entry point.

You might also want a per-project config, especially for collaboration. Some use .cursor/mcp.json. Depending on the version, there may be cases where the local file isn’t recognized. If in doubt, switch back to global to confirm everything works.

Verify MCP is active in the IDE

Once your MCP server is added, go to Cursor:

Settings, then Cursor Settings, then Tools & MCP.

This is where you see the servers, their status, and available tools. After authorization, a restart may be needed for Cursor to detect all features.

‍

MCP Cursor with Supabase: the most useful connection for coding with your data

If you use Supabase, MCP gives you an immediate edge: Cursor no longer needs to guess your database structure. It can rely on the schema, tables, and reliable documentation. This is exactly the kind of context that improves a development workflow.

Set up the Supabase MCP server in Cursor

Supabase provides an MCP guide and explains how to check the connection in Cursor (Tools & MCP).

In your ~/.cursor/mcp.json, you can start with a very simple configuration. The example below gives you a clear foundation. Adjust the name if you like.

{

"mcpServers": {

"supabase": {

"url": "https://mcp.supabase.com/mcp"

}

}

}

‍

Then, restart Cursor if needed, then go back to Tools & MCP to verify the server is connected. Supabase also recommends testing in natural language, for example by asking the model to list tables via MCP tools.

Scope Supabase access to stay clean and worry-free

When you connect an IDE to services, the configuration must remain strict. This is especially true for Supabase, especially if you want to avoid a bad call on the wrong environment.

Here’s a simple rule: start with read-only access on a dev or test project. Then expand if you have a good reason.

Supabase highlights that the connection uses authorization, and the status is visible in the MCP client (like Cursor).

In your process, think like a dev:

You configure, you test, you validate, then you iterate. You don’t “connect everything” at once.

How to use Supabase MCP daily in Cursor

The goal isn’t to stack commands. The goal is to improve your coding, step by step, with reliable tools.

A very effective workflow looks like this:

You start by asking the AI model to fetch the schema, then you ask it to generate app-side code, then you make it write tests.

Simple, work-focused prompt examples:

• “List the tables and relationships. Use the MCP Supabase tools.”
• “Suggest TypeScript types for this data, then generate the access code.”
• “Write an integration test and a validation SQL query.”

What changes here is the context. Cursor can leverage your data. The code becomes more accurate, faster.

‍

Add a Brave MCP search server for up-to-date web documentation

Even with Supabase, you’ll often need to look up a doc detail, a version, an API parameter, or a configuration option. An MCP search server is exactly for that.

Brave offers an open-source MCP server, requiring a mandatory BRAVE_API_KEY variable. It also supports multiple transport modes, including stdio and http.

Why it’s useful in Cursor

Cursor is great at writing code. But with fast-changing docs, search remains a key step.

With Brave MCP:

• You find the right web documentation without leaving your IDE.
• You reduce version errors.
• You can ask the model to cite or summarize the found doc, then adapt your code.

It’s a good habit for anything related to an API, a config, or a recent change.

Install Brave MCP and configure it in mcp.json

The Brave repository lists supported variables, including BRAVE_API_KEY, and specifies a default stdio transport.

On the Cursor side, you can declare an MCP server “command” via Node. You can also avoid hardcoding a key by using an environment variable. Cursor documents variable usage in mcp.json.

Simple configuration example, using stdio:

{

"mcpServers": {

"supabase": {

      "url": "https://mcp.supabase.com/mcp"

    },

    "brave-search": {

      "command": "npx",

      "args": ["-y", "@brave/brave-search-mcp-server"],

      "env": {

        "BRAVE_API_KEY": "${BRAVE_API_KEY}"

      }

    }

  }

}

‍

Next, you set BRAVE_API_KEY in your local environment, then restart Cursor. The goal is to have a stable, versionable configuration with no secret leaks.

Quickly test the search functionality

To validate, run three simple tests in Cursor:

First, a documentation query, like “Find the official X documentation, then summarize the useful options.”

Then, a version query: “Check the current version and list the breaking changes.”

Finally, a code-focused test: “Search for an API usage example, then adapt the snippet to my code.”

If all three pass, your Brave MCP server is ready for your workflow.

‍

How MCP really works in Cursor: the essentials you need to know

You don’t need to master the entire theory to be effective, but you should understand three key concepts: server, tools, and transport.

An MCP server exposes tools. Cursor acts as the client. The model can then call these tools in the IDE, whenever it needs them during development.

Tools, resources, prompts: why it’s easy to get the hang of

Depending on the implementation, an MCP server can expose:

Tools, which are actions, like “perform a search”, “list tables”, or “execute a query”.

Resources, which are consultable resources.

Sometimes prompts or helpers, depending on the SDK and server.

In practice, you use them for two things: fetching reliable context, then generating code that fits that context.

The transport choice: stdio or HTTP

Transport is how Cursor communicates with the MCP server.

Locally, stdio is very common and simple. It uses the process’s standard input and output. It’s convenient for a Node tool launched via command line.

For remote services, you can use HTTP variants. Some docs mention that SSE existed and may still be supported, but recent sources indicate the standard is evolving and primarily recommends stdio, with streaming HTTP for certain cases.

My advice: start with stdio for your local tools and search. And use an HTTPS URL when the provider offers a managed server, like Supabase.

‍

A development workflow that works: Supabase, code, tests, then docs

The vibe coding works when the flow is short, but it becomes powerful when MCP delivers the right tools, data, and docs at the right time.

The best use of MCP Cursor is a clear process. Not a demo. Not a gadget.

Here’s a simple workflow guide you can repeat for each feature.

Step 1: Frame the data before writing code

You ask the model to fetch the schema and constraints. You validate what you read.

You can then ask it to rephrase the data as types or domain objects. You get cleaner, more stable code.

Step 2: Generate data access and API-side functions

With Supabase, you can produce:

Read queries.

Filters.

Pagination.

Service functions, with a clear signature.

At this stage, focus on clarity. You want simple code. You want stable names. You want testable functions.

Step 3: Write a test that proves the feature works

This is where MCP Cursor becomes highly cost-effective.

You ask the model:

To write a unit test on the logic.

Then an integration test that checks the query or API.

Then a short checklist of edge cases.

This trio improves your workflow. And it reduces time wasted “guessing” where a bug comes from.

Step 4: update the documentation and internal docs

When the code is good, you want useful docs:

A short, usage-focused README.

A “configuration” section that describes the variables.

A reminder of the test commands.

You use Brave Search if you need to cite a web doc or verify a parameter.

‍

Security and configuration: keeping control when connecting services

MCP makes tools powerful. So your configuration must stay clean.

The most important point is to limit access.

Avoid connecting to production until you have a clear process. Prefer a test project. Use minimal permissions. Limit what’s possible, especially at first.

Supabase notes that authorization and tool detection may require a restart and verification in the client. This highlights a key point: these connections are real, and they must be treated like an integration.

On the Brave side, keep your key out of the file. Use an environment variable. The Brave server explicitly supports BRAVE_API_KEY.

‍

Diagnosing an unresponsive MCP in Cursor without wasting an hour

When it’s stuck, it’s almost never “mystical.” It’s usually the configuration, the command, or the permissions.

Start with these simple questions.

Is the mcp.json file in the right place and properly formatted as JSON.

Does the server actually start. For a command-based server, are Node and npx available.

Are environment variables present, especially for Brave?

In Cursor, does the server appear in Tools & MCP, and is it connected?

If you’ve set a project-level config and Cursor isn’t reading it, try the global config at ~/.cursor/mcp.json to isolate the issue. Community feedback suggests this for certain versions.

‍

Collaboration: making MCP Cursor useful for teams

MCP Cursor isn’t just a personal tool. Properly configured, it helps a team produce more consistent code.

The idea is to have a simple process:

A shared configuration, when possible.

Internal documentation guidelines, so everyone configures it the same way.

A testing protocol, to verify that an MCP server responds.

In practice, you can document:

How to install Cursor.

Where to place the configuration.

How to configure Supabase, which services are allowed.

How to configure Brave, and where to place the key.

Which test commands to run after an update.

You reduce friction. You improve workflow. And you make development smoother.

‍

MCP Cursor: what you can do next to go faster and write better

Once Supabase and Brave are set up, you can extend MCP to other services:

An MCP server for your design system, to retrieve internal documentation.

An MCP server for your backlog, to link coding to tickets.

An MCP server for a monitoring tool, to correlate errors with version changes.

You don’t have to do everything. The right criterion is simple: does it improve your workflow, and does it reduce errors?

MCP Cursor is as much a discipline guide as it is a tool guide.

‍

For an overview of the protocol and essential MCP servers, see our comprehensive MCP 2026 guide.

Go further with Scroll

If you want to properly implement MCP Cursor with a solid setup, a testing workflow, and a Supabase integration tailored to your product, Scroll agency can help. We often work on digital transformation and IDE AI topics: selecting MCP servers, configuration, security, documentation, and establishing a sustainable development process.

‍