Getting started with MCP in Cursor

AI-powered development environments are rapidly transforming how we write and interact with code. Among these, Cursor stands out as a next-generation editor that deeply integrates AI assistance directly into your coding workflow.

However, Cursor’s true potential goes beyond autocomplete and chat prompts. It lies in how it can connect with your tools, data, and context through MCP (Model Context Protocol).

This guide walks you through everything you need to know to get started with MCP in Cursor, from understanding the core concepts to setting up your first connection and testing real-world integrations.

Before jumping into setup, let’s first understand what MCP actually is and why it matters when using Cursor.

At its core, MCP is a way for AI tools and agents like Cursor to connect with other apps, services, and data sources. Normally, an AI model only knows what’s in your open files or what you tell it in a prompt. With MCP, the model can access external systems and obtain more useful, real-time information.

Think of MCP as a bridge between the AI and the rest of your development world. It allows Cursor’s AI to ask questions, pull data, or perform actions using different “tools”, all defined through MCP servers.

Here’s how it works in plain terms:

• MCP Server: This is where the logic or data lives. It can connect to an API (such as GitHub, Jira, or Notion) or a local service you build yourself.

• MCP Client: This is the part that talks to the AI. It sends your requests to the MCP server and shows the responses in the editor. Cursor is an MCP client.

So instead of just guessing based on code context, Cursor can use MCP to:

• Get information from APIs.
• Access your project’s internal docs or databases.
• Run custom tools or scripts that you define.

In short, MCP makes Cursor smarter by giving it access to the same tools and data you use every day. It’s like giving your AI assistant an internet connection, but one that you control completely.

Before you start setting up MCP in Cursor, make sure you have a few things ready:

1. Cursor Installed: You’ll need the latest version of Cursor. If you haven’t installed it yet, head to cursor.sh and download it for your operating system.

2. Node.js or Python Installed: Most MCP servers are built using Node.js or Python, so you’ll need one of them installed to run an MCP server locally. You can check if Node.js is installed by running node -v or for Python python --version.

3. A Basic Terminal Setup: You’ll need to use your terminal or command line for installing packages or running a local MCP server. Nothing too complex, but it helps to be comfortable typing a few commands.

4. API Keys (Optional): If you plan to connect Cursor to external tools (like Notion, GitHub, or Jira), you’ll need their API keys or access tokens.

Now that you know what MCP is and what you need to get started, let’s set it up in Cursor using the Filesystem MCP Server.

This server lets Cursor’s AI read and manage files on your computer in a controlled way. With it, you can ask the AI to open files, create folders, move things around, or search your project, all safely within allowed directories.

Step 1: Open Cursor’s MCP settings

Start by opening Cursor. To use Cursor, you’ll need to either be on a free trial or have an active plan.

Next, go to Settings > Tools & MCP (you can also open the Command Palette and search for “MCP”).

You’ll see a list of configured MCP servers. If this is your first time setting it up, the list will be empty like the image above.

To add a new MCP server, click the “Add Custom MCP” button. This opens a global configuration file called mcp.json, where you’ll define the server connection details.

Each MCP server you add here tells Cursor how to communicate with that specific tool or service.

Step 2: Add the Filesystem MCP Server

There are two ways to add an MCP server to Cursor. You can configure it globally (available for all projects) or locally (only for a specific project).

When you click the “Add Custom MCP” button in the Tools & MCP settings page, the mcp.json file that opens up is in ~/.cursor/mcp.json in your home directory. To configure an MCP only needed for a specific project, create a file named .cursor/mcp.json inside your project folder.

Both options work the same way. For example, to add the Filesystem MCP Server, you’d include something like this in your chosen mcp.json file:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/path/to/other/allowed/dir"
      ]
    }
  }
}

This tells Cursor to start the Filesystem MCP Server with Node.js (npx) and allow access to the directories you specify.

Make sure to replace /Users/username/Desktop with your actual local directories.

Step 3: Start the MCP Server

Once configured, Cursor will automatically try to start the MCP server when you open the app or interact with the AI.

If everything is set up correctly, Cursor should detect the Filesystem MCP Server and connect automatically. You’ll see it appear in your MCP server list, and you can start using it right away.

Step 4: Try it out

Once connected, try asking the AI something like:

"List all files in my project folder."
"Open and read the contents of README.md."
"Create a new folder called assets/images."

The Filesystem MCP Server supports many file operations, such as:

• Reading and writing files
• Creating and deleting directories
• Moving files or folders
• Getting file metadata
• Searching and listing files

All operations are restricted to your allowed directories, so the AI can’t touch anything outside those paths.

This is just a very basic example of using an MCP in Cursor. In reality, you can use multiple MCP servers at the same time to make Cursor even more powerful.

For example, you can connect the GitHub MCP Server to interact with your repositories, issues, and pull requests, while also using tools like Prisma MCP for database operations or Playwright MCP for automated testing. Together, these integrations let you build, test, and manage projects directly through AI commands, all without leaving your editor.

What we’ve covered here is just the start.

If you want to take things even further, you can create your own MCP server. This is where it gets really powerful. You could build a simple server that connects to your own APIs or tools.

For example, if you host a WordPress site (or use any other CMS that provides an API), you could create an MCP server that lets Cursor:

• Fetch and edit posts or pages,
• Manage comments or users,
• Or even trigger deployments, all through natural language commands.

That’s the beauty of MCP: it’s flexible, secure, and designed to grow with your workflow.