How to Use MCP: Beginner Setup With Claude, Cursor and ChatGPT

Your AI assistant can draft an email in seconds, yet ask it to read the spreadsheet sitting on your desktop and it hits a wall. MCP removes that wall. The Model Context Protocol is an open standard that lets an AI app reach your files, databases, calendars and other tools through one shared connection format. You set a tool up once, and every compatible app can use it.

This article shows you how to use MCP from zero. You will meet the three moving parts, build a first working config in Claude, Cursor and ChatGPT, pick up the safety habits worth forming on day one, and fix the errors almost every beginner hits. Plan on roughly an hour for all three apps, or ten minutes for just one.

What MCP Does

MCP stands for Model Context Protocol. Anthropic introduced it in November 2024, and the project now lives under the Agentic AI Foundation, a directed fund of the Linux Foundation co-founded by Anthropic, Block and OpenAI. The official docs describe it as a USB-C port for AI applications: one plug shape that works with many devices.

Before MCP, every integration was custom work. A connector built for one app did nothing for another. Now a server written once runs in any client that speaks the protocol, and Claude, ChatGPT, Cursor and Visual Studio Code all do.

The Three Parts

Every MCP setup has the same cast:

• Host: the AI app you talk to, such as Claude Desktop, Claude Code or Cursor.
• Client: a connector the host creates for each server. It lives inside the host, so you never configure it yourself.
• Server: a program that offers context and actions, such as a filesystem server, a GitHub server or an image generator.

When you edit a config file below, you are telling a host which servers to start or call.

💡 Beginner shortcut: most tutorials call the app itself (Claude, Cursor, ChatGPT) the "client". The difference only matters when you build your own server.

Tools, Resources and Prompts

A server can offer three kinds of things:

Tools are what you will use first. When you ask Claude to rename a folder of files, it picks a tool from the server's list and waits for your approval before it runs.

Local and Remote Servers

Servers come in two flavors, and the difference decides which apps can use them:

Claude Desktop and Claude Code can start local servers. Cursor handles both kinds. ChatGPT connects to remote ones only. Keep this table in mind, because it explains most of the confusion in the sections below.

💡 The protocol keeps evolving (the newest revision is dated 2026-07-28), but a beginner setup does not need the spec details. Keep your apps updated and move on.

Prepare Your Machine

Check Node.js

Most community servers start with npx, a tool that ships with Node.js. Open a terminal and run:

node --version

Copy Prompt

If you see a version number, you are set. If the command is not found, install the LTS release from nodejs.org, then reopen the terminal. LTS stands for Long Term Support, and it is the stable choice.

Pick a Safe First Server

Begin with the official filesystem server, published as @modelcontextprotocol/server-filesystem. It lets the assistant read, create, move and search files inside the folders you name.

Create a throwaway folder called mcp-sandbox and drop two or three text files in it. Use that folder for every test in this article.

⚠️ A local server runs with your user account's permissions. Only list folders you are comfortable letting the assistant read and change. Your whole home directory is a poor first choice.

Set Up MCP in Claude

Anthropic's apps give you two routes. Claude Desktop uses a JSON config file. Claude Code, the terminal app, uses a command. Pick the one you use daily, or do both.

Edit the Desktop Config

1. Open the Claude menu in your system menu bar (not the settings inside the chat window) and choose Settings.
2. Open the Developer tab and click Edit Config.
3. Claude creates the file if it does not exist. It lives here:

Replace the contents with the snippet for your system, swapping in your own username. On macOS:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/mcp-sandbox"]
    }
  }
}

Copy Prompt

On Windows, use double backslashes:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\username\\mcp-sandbox"]
    }
  }
}

Copy Prompt

Each piece has a job:

• "filesystem" is the friendly name that appears in the app.
• "command": "npx" runs the server through Node.js.
• -y confirms the package download so the launch does not stall on a prompt.
• The last argument is the one folder the server may touch. Use an absolute path, never a relative one.

Restart and Test

Save the file, then fully quit Claude Desktop and reopen it. Closing the window is not enough, because the app reads the config at launch.

Click the Add files, connectors, and more button in the bottom-left corner of the message box, hover over Connectors and choose Manage connectors. Select filesystem to see its tools. Then try a plain request:

List the files in my mcp-sandbox folder and tell me which one changed most recently.

Claude asks for approval before each file operation. Read the request, then approve or deny it.

💡 Remote servers skip the JSON. On claude.ai, go to Settings, then Connectors, click Add custom connector, name it and paste the server's URL. You will usually sign in through OAuth. Free accounts are limited to one custom connector.

Add Servers in Claude Code

Claude Code adds servers from the terminal. The shape of the command depends on the server type:

# Remote server over HTTP
claude mcp add --transport http example https://example.com/mcp

# Local server over stdio (note the double dash)
claude mcp add --transport stdio files -- npx -y @modelcontextprotocol/server-filesystem /Users/username/mcp-sandbox

# See what is configured
claude mcp list
claude mcp get files
claude mcp remove files

Copy Prompt

The -- separates Claude's own options from the command that launches the server. Forget it and the arguments get misread. Inside a Claude Code session, type /mcp to check each server's status or to finish an OAuth sign-in.

Where the server is saved depends on its scope:

Add --scope project to write a .mcp.json file you can commit, so teammates get the same servers. Use --scope user for the tools you want everywhere.

Set Up MCP in Cursor

Pick Project or Global

Cursor reads a JSON file at one of two levels:

• Project: .cursor/mcp.json in the project root, for tools tied to one codebase.
• Global: ~/.cursor/mcp.json in your home directory, for tools you want in every project.

The format matches Claude Desktop's:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/mcp-sandbox"]
    }
  }
}

Copy Prompt

Cursor supports three transports, so you can mix local and remote servers in the same file:

By default, Cursor asks for approval before it runs an MCP tool. Run modes can auto-approve tools you have allowlisted, so start strict and loosen later.

Add a Remote Server

For a hosted server, swap command and args for a URL:

{
  "mcpServers": {
    "example": {
      "url": "https://example.com/mcp"
    }
  }
}

Copy Prompt

The Cursor Marketplace and cursor.directory also offer an Add to Cursor button that installs a server and handles the OAuth sign-in in one step. If a server needs a token, use ${env:NAME} interpolation rather than pasting the secret into the file. Cursor also accepts ${userHome} and ${workspaceFolder} in config values.

Set Up MCP in ChatGPT

What ChatGPT Requires

ChatGPT works differently from the other two apps. It connects to remote servers that are reachable over HTTPS. A server you start with npx on your own machine will not appear, because ChatGPT cannot launch a process on your computer.

The flow, as OpenAI describes it:

1. Use a paid plan. Free accounts are excluded.
2. Turn on developer mode in ChatGPT's settings.
3. Open the Plugins settings, press the plus button and choose Add custom MCP server.
4. Enter the server's URL and pick an authentication method, usually OAuth.
5. Accept the risk warning, then switch the connector on in a new chat.

OpenAI states that custom MCP servers are third-party services, not developed or verified by OpenAI. Menu names have moved around several times, so if a label differs, search OpenAI's developer docs for "developer mode". Some plans also limit write actions, so a connector may read data but refuse to change anything. Check your plan before you debug what is really a plan limit.

Developers who build with the API can attach the same server through the Responses API with a tool entry of type: "mcp", plus a server_label, a server_url, an allowed_tools list and a require_approval setting.

💡 One server, three apps. Host a single remote server and you can paste its URL into Claude's custom connectors, Cursor's mcp.json and ChatGPT. That is the payoff of a shared protocol.

Stay Safe With Tools

An assistant with tools can act, and acting has consequences. Two habits remove most of the risk.

Give the Least Access

• Share one folder, not your home directory.
• Start with read-only tools and add write access only when you need it.
• Read each approval prompt before you click. It shows what is about to happen.
• Treat any server you did not write or check as third-party code. Anthropic and OpenAI both warn that custom connectors are not verified by them.
• Remember that text inside files and web pages can contain instructions aimed at the assistant. If a tool returns something odd, stop and read it yourself.

Keep Tokens Out of Files

Never paste a secret into a config file you might commit or share. Pass it through an environment variable instead. In Cursor, use ${env:NAME}. In Claude Code, add --env NAME=value when you register a local server. Before you commit .mcp.json or .cursor/mcp.json, open the file and confirm that no token is sitting in it.

Fix the Common Errors

Start with the logs. Claude Desktop writes MCP logs to ~/Library/Logs/Claude on macOS and %APPDATA%\Claude\logs on Windows. The file mcp.log records connection attempts and failures, and each server also gets its own mcp-server-NAME.log with whatever it printed to stderr.

On Windows, if a log mentions ${APPDATA} inside a path, add the expanded value to the server's env block, for example "APPDATA": "C:\\Users\\username\\AppData\\Roaming\\", then relaunch the app.

When nothing else works, run the server command by hand. If it fails in a terminal, it will fail inside the app too, and the terminal shows you the full error.

Try It on PicassoIA

Once the filesystem test works, add a server that produces something you can see. Image generation is a good second step because you can judge the result at a glance.

PicassoIA offers an MCP connector that gives your assistant four models: PicassoIA Image for text to image, PicassoIA Image Editor Pro for edits, PicassoIA Video for video from text or an image, and Seedance 2.5 Lite for video with audio. You manage connections from your PicassoIA account after you sign in.

Generations are asynchronous. The assistant starts a job, receives a prediction ID with an estimated time, then checks the status after the suggested wait until the job reports success or failure. A failure is final, so the assistant simply starts a new generation. Each account runs up to five predictions at once, shared across all of its connections.

Use a first prompt like this to test the link:

Generate a photorealistic image of a wooden desk with a laptop and a coffee mug in soft morning light, then show me the link.

Curious how different models handle the same setup question? Paste a broken config into Claude Sonnet 5 and GPT 5.6 Sol and see which one explains the JSON error more clearly.

Your next ten minutes are simple. Pick one app from this article, add the filesystem server and run the test prompt. Then open Picasso IA, choose a model from the full model list and generate your first image. A working setup is only the beginning. The fun starts when your assistant builds things with the tools you gave it.