MCP Tutorial: Complete Beginner's Guide to Model Context Protocol

MCP Tutorial: Complete Beginner's Guide to Model Context Protocol

You've probably heard people talking about MCP, but nobody explains it simply. Let's fix that.

This tutorial takes you from zero to your first working MCP connection in about 10 minutes. No prior experience needed.

What Is MCP?

MCP stands for Model Context Protocol. It's an open standard created by Anthropic that lets AI apps connect to external tools and data sources.

Think of it like a USB port for AI. Before USB, every device had its own connector. Before MCP, every AI tool had its own way of connecting to things. MCP is the universal plug.

Without MCP: You copy data from your database, paste it into Claude, ask a question, copy the answer back. With MCP: Claude connects directly to your database, reads the data it needs, and gives you answers — all in one conversation.

How MCP Works (The Simple Version)

MCP has three parts:

1. MCP Client — The AI app you're using (Claude Desktop, Cursor, VS Code)
2. MCP Server — A small program that connects to a specific tool or data source
3. The Protocol — The standard language they use to talk to each other

Here's how they work together:

You → MCP Client (Claude Desktop) → MCP Server → Your Data (database, GitHub, etc.)

When you ask Claude a question, it checks which MCP servers are available, picks the right one, and uses it to get the data it needs. You approve each action before it runs.

What You Need

• Claude Desktop (free download from claude.ai/download)
• Node.js installed on your computer (download from nodejs.org — version 18 or newer)
• A text editor (any will work)
• About 10 minutes

Step 1: Install Claude Desktop

Download Claude Desktop from claude.ai/download. Install it like any other app. You'll need a free Claude account to sign in.

Step 2: Find Your Config File

Claude Desktop uses a JSON config file to know which MCP servers to load. Here's where to find it:

On Mac:

~/Library/Application Support/Claude/claudedesktopconfig.json

On Windows:

%APPDATA%\Claude\claudedesktopconfig.json

If the file doesn't exist yet, create it.

Step 3: Add Your First MCP Server

Let's start with the Filesystem MCP Server. It lets Claude read and write files on your computer (only in folders you specify).

Open your config file and paste this:

json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents"
      ]
    }
  }
}

Important: Replace /Users/yourname/Documents with the actual folder path you want Claude to access. On Windows, use C:\\Users\\yourname\\Documents.

Save the file.

Step 4: Restart Claude Desktop

Close Claude Desktop completely and reopen it. Look for the hammer icon (🔨) in the bottom-left of the chat input. If you see it, your MCP server is connected.

Click the hammer icon to see the available tools. You should see tools like readfile, writefile, list_directory, and others.

Step 5: Test It

Type something like:

> "What files are in my Documents folder?"

Claude will ask for your permission to use the list_directory tool. Click Allow and it'll show you the files.

Try something more useful:

> "Create a file called meeting-notes.md in my Documents folder with today's date as the header"

Claude will use the write_file tool to create the file. You approve each action.

That's it. You just set up your first MCP connection.

Adding More MCP Servers

One server is useful. Multiple servers are powerful. Here's how to add more.

Just add more entries to the mcpServers object in your config file:

json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents"
      ]
    },
    "brave-search": {
      "command": "npx",
      "args": [
        "-y",
        "@anthropic-ai/mcp-server-brave-search"
      ],
      "env": {
        "BRAVEAPIKEY": "your-api-key-here"
      }
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUBPERSONALACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

Restart Claude Desktop after adding new servers.

Understanding the Config Format

Every MCP server entry has the same structure:

json
"server-name": {
  "command": "npx",
  "args": ["-y", "package-name", ...extra-args],
  "env": {
    "API_KEY": "your-key"
  }
}

• command — How to run the server (usually npx for Node.js servers)
• args — The package name plus any configuration
• env — Environment variables (API keys, tokens, connection strings)

Some servers use Docker instead of npx. The server's documentation will tell you which.

Common Beginner Mistakes

"The hammer icon doesn't appear"

• Make sure you saved the config file
• Make sure the JSON is valid (no trailing commas, matching brackets)
• Restart Claude Desktop completely (quit, don't just close the window)
• Check that Node.js is installed: run node --version in your terminal

"Server connected but tools don't work"

• Check that API keys and tokens are correct
• Some servers need specific permissions (GitHub tokens need repo access)
• Check Claude Desktop's logs: Help → Show Logs in the menu bar

"Permission errors"

• Make sure the file paths in your config actually exist
• On Mac, you may need to grant terminal access in System Settings → Privacy

MCP's Three Building Blocks

MCP servers can expose three types of things:

1. Tools — Actions the AI can take (like readfile or createissue). These require your approval.
2. Resources — Data the AI can read (like a database schema or a file listing). Think of these as context.
3. Prompts — Pre-built prompt templates that help the AI use the server effectively.

Most servers you'll use focus on tools. As you get more advanced, resources and prompts become useful too.

What to Try Next

Now that you've got MCP working, here are the most popular next steps:

1. Connect to a database — The PostgreSQL MCP server lets Claude query your data directly. See our best MCP servers for databases guide.

1. Set up MCP in your code editor — Cursor and VS Code both support MCP. See our Cursor MCP setup guide or VS Code MCP setup guide.

1. Browse available servers — The official repository at github.com/modelcontextprotocol/servers lists reference servers. Community directories like mcpservers.org and Glama catalog over 1,200 servers.

1. Build your own server — Anthropic's official tutorial at modelcontextprotocol.io walks you through building a custom MCP server in Python or TypeScript.

We track MCP support across 500+ AI tools in our directory. Browse MCP-compatible tools to find servers that fit your workflow.

The Bottom Line

MCP removes the copy-paste barrier between AI and your tools. Setup takes 10 minutes, and once it's working, you'll wonder how you worked without it.

Start with one server. Get comfortable. Then add more as you find workflows where AI + your data makes sense. The ecosystem is growing fast — new servers launch every day, and the major platforms (Claude, Cursor, VS Code, Windsurf) all support it.

The future of AI isn't chatting in a box. It's AI that actually connects to your world. MCP makes that possible today.