MCP Cursor: install, configure, and connect Cursor to Supabase, API, 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 also provides a solid foundation for vibe coding, but with reliable tools and context (Supabase, API, 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. The AI model can then call these tools during development. Instead of guessing, it can read context, query an API, perform searches, or retrieve useful data.

In practice, MCP Cursor allows you to:

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

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

Getting started quickly: MCP installation and initial configuration in Cursor

The fastest way is to add an MCP server and then verify it appears in Cursor. Cursor reads a JSON configuration, often placed in an mcp.json file. The Cursor documentation specifies 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 may also want a per-project configuration, especially for collaboration. Some use .cursor/mcp.json. Depending on the version, there may be cases where the local file is not taken into account. If in doubt, switch back to global to confirm everything works.

Verifying 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 required 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.

Configuring the Supabase MCP server in Cursor

Supabase provides an MCP guide and explains how to verify 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 needed.

{

"mcpServers": {

"supabase": {

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

}

}

}

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

Scoping Supabase access to stay clean and secure

When you connect an IDE to services, the configuration must remain strict. This is especially true for Supabase, particularly if you want to avoid a misdirected call to 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 relies on authorization, and that the status is visible in the MCP client (such as Cursor).

In your process, think like a developer:

You configure, you test, you validate, then you iterate. You don’t “connect everything” all 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 highly effective workflow looks like this:

Start by asking the AI model to fetch the schema, then ask it to generate the app-side code, then force it to 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 SQL validation query."

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

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

Even with Supabase, you’ll often need to look up docs, a version, an API parameter, or a configuration option. That’s exactly what a search MCP server is for.

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

Why this is useful in Cursor

Cursor excels at writing code. But with fast-changing documentation, search remains critical.

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 docs, then adapt your code accordingly.

It’s a good practice 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 stdio as the default transport.

In Cursor, 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, set BRAVE_API_KEY in your local environment, then restart Cursor. The goal is to have a stable, version-controlled configuration with no secret leaks.

Quickly test the search functionality

To validate, run three simple tests in Cursor:

First, a documentation query, such as “Find the official docs for X, then summarise the useful options.”

Then, a version check: “Verify 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 MCP Brave server is ready for your workflow.

How MCP actually works in Cursor: the essentials

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

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

Tools, resources, prompts: why it’s easy to get started

Depending on the implementation, an MCP server can expose:

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

Resources, which are consultable data sources.

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

In practice, you use them for two things: retrieving reliable context, then generating code that aligns with that context.

Choosing the transport: stdio or HTTP

Transport refers to how Cursor communicates with the MCP server.

Locally, stdio is common and straightforward. It uses the process’s standard input and output. This is practical for a Node tool run 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 specific cases.

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

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

Vibe coding works with short loops, but it becomes powerful when MCP provides 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 you can repeat for each feature.

Step 1: frame the data before writing code

Ask the model to fetch the schema and constraints. Validate what you read.

You can then ask it to reformat the data as types or domain objects. This yields 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 for the logic.

Then an integration test to verify 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 solid, you want useful docs:

A concise, 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: maintaining 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. Restrict 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 as 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 breaks, 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 is it valid JSON?

Is the server actually starting? For a command-based server, are Node and npx available?

Are the 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 points to this on certain versions.

Collaboration: making MCP Cursor useful for a team

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, where possible.

Internal documentation, so everyone sets things up the same way.

A testing protocol, to confirm an MCP server is responding.

In practice, you can document:

How to install Cursor.

Where to place the configuration.

How to configure Supabase, and 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 the work. And you make development smoother.

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

Once Supabase and Brave are in place, you can extend MCP to other services:

An MCP server for your design system, to fetch 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 implement MCP Cursor properly, with a solid configuration, a testing workflow, and a Supabase integration tailored to your product, the Scroll agency can help. We often work on digital transformation and AI in the IDE: MCP server selection, configuration, security, documentation, and setting up a development process that stands the test of time.