1. What is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard, published by Anthropic in November 2024, that defines exactly how AI agents connect to external tools and data sources. Think of it as USB-C for AI integrations: one standard connector that works everywhere, instead of a different cable for every device.

Before MCP, connecting an AI assistant to your database meant writing custom integration code specific to that AI tool. If you switched from Claude to Cursor, your integration broke. If the AI provider changed their API, your code needed updates. Every integration was a one-off that only worked in one place.

MCP fixes this by defining a universal language. An MCP server exposes capabilities using a standard schema. Any MCP-compatible client — Claude Desktop, Cursor, VS Code, Windsurf — can discover those capabilities and call them without any custom glue code. Build the server once, use it everywhere.

The protocol has three primitives:

• Tools — functions the AI can call. A tool has a name, a description, and a JSON Schema for its input. The AI decides when to call it based on the description. Example: search_web, create_github_issue, query_database.
• Resources — read-only data the AI can fetch, like files or database records. Example: file://project/README.md.
• Prompts — pre-built prompt templates the AI can invoke by name. Useful for complex repeatable workflows.

For a deeper dive into the protocol itself, see our full MCP explainer. This guide focuses on the practical side: finding, installing, and using MCP servers.

2. What are MCP servers and why they matter

An MCP server is a lightweight process — usually a Node.js or Python script — that implements the server side of the Model Context Protocol. It runs locally on your machine (or remotely over HTTP) and exposes a set of tools your AI assistant can discover and call.

Here is the architecture in plain terms: your AI client (Claude Desktop, Cursor) contains an MCP client. When you start the client, it launches the MCP servers you've configured and asks each one: "what tools do you have?" The server responds with a list of tool definitions. Now the AI knows about those tools and can call them when relevant to the task at hand.

When you ask Claude to "check if there are any open issues blocking the login feature," it can call a GitHub MCP server tool to search issues — and return real data instead of guessing. When you ask Cursor to "look up the latest docs for this API," it can call a web search MCP server to fetch live results instead of relying on its training cutoff.

That's why MCP servers matter: they close the gap between what AI assistants know and what they can actually do. The AI stops being a smart autocomplete and starts being an agent that takes actions in the real world.

As of March 2026, there are over 25,000 MCP server repositories on GitHub. They cover databases, file systems, web browsers, search engines, communication tools, cloud providers, and more. The ecosystem has grown faster than almost any other developer tooling category in the past two years.

3. How to find the right MCP server for your use case

With 25,000+ servers available, the discovery problem is real. A GitHub search for "mcp server" returns thousands of results with no way to tell which are actively maintained, widely used, or safe to install. Most search results are abandoned side projects or low-quality forks.

The AgentRank leaderboard is built specifically to solve this. It crawls GitHub nightly, scores every MCP server on five quality signals, and surfaces the best ones by category. You can browse by use case:

• Database — PostgreSQL, MySQL, MongoDB, Redis, Neon, DynamoDB
• Browser automation — Playwright, Puppeteer, headless Chrome
• DevOps — Docker, Kubernetes, GitHub Actions, CI/CD
• Code generation — language servers, linters, test runners
• Productivity — Slack, Notion, calendar, email

If you already know the tool you want (say, you want a Postgres MCP server), use the AgentRank Health Checker: paste any GitHub URL and get an instant quality breakdown — score, freshness, issue health, and contributor count. No login required.

If you're choosing between two similar servers, the comparison tool shows full signal breakdowns side by side. See which one was updated more recently, which has a better issue close rate, and which has more contributors before you commit.

For first-timers: start with the official servers maintained by the MCP working group at @modelcontextprotocol on GitHub. They have the highest scores, the most contributors, and the most consistent update cadence. They're a safe baseline before you explore third-party options.

4. Step-by-step: installing your first MCP server

We'll install the filesystem MCP server — which gives your AI access to read and write local files — in Claude Desktop. The same pattern applies to Cursor, VS Code, and Windsurf with minor config path differences.

Prerequisites

• Claude Desktop installed (or another MCP-compatible client)
• Node.js 18+ installed (node --version to check)
• A text editor to modify JSON config files

Step 1: Find the config file

Claude Desktop uses a JSON config file to know which MCP servers to launch. Its location depends on your OS:

# macOS
~/Library/Application Support/Claude/claude_desktop_config.json

# Windows
%APPDATA%\Claude\claude_desktop_config.json

# Linux
~/.config/Claude/claude_desktop_config.json

If the file doesn't exist, create it. It must be valid JSON — a single typo will prevent Claude Desktop from loading any servers.

Step 2: Add the server entry

Open the config file and add (or merge) the following:

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

Replace /Users/yourname/projects with the directory you want the AI to access. You can pass multiple paths as additional arguments. Restrict this to directories you're comfortable granting read/write access — the AI can create, modify, and delete files in any path you specify.

Step 3: Restart Claude Desktop

MCP servers are launched on startup. Fully quit Claude Desktop (Cmd+Q on macOS, not just closing the window) and reopen it. On startup, Claude Desktop will launch the filesystem server as a subprocess and request its tool list.

Step 4: Verify it's working

In a Claude Desktop conversation, ask: "What files are in my projects directory?" If the filesystem server is connected, Claude will call the list_directory tool and return the actual contents. You'll see a tool call annotation in the response showing what was executed.

If it's not working, open the developer console: Help → Developer Tools → Console. Look for MCP-related errors — usually a missing Node.js version, a wrong path, or a JSON syntax error in the config.

Adding a second server

To add more servers, add entries to the mcpServers object. Here's a config with both filesystem and GitHub:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

For the GitHub server, create a personal access token at GitHub Settings → Developer settings → Personal access tokens. Grant repo scope for full repository access, or narrow it to the specific permissions you need.

Config for other clients

The config structure is similar across clients, just in different files:

• Cursor: ~/.cursor/mcp.json — uses {"mcpServers": {...}} format
• VS Code: .vscode/mcp.json in your project — uses {"servers": {...}} format
• Windsurf: ~/.codeium/windsurf/mcp_config.json

For detailed per-client setup instructions, see our MCP setup guide for Claude, Cursor, and Windsurf.

5. How to evaluate MCP server quality

Not all MCP servers are worth installing. Some are abandoned prototypes. Some have critical bugs with no maintainer to fix them. Some were written over a weekend, never updated, and will break when the underlying API changes. Installing low-quality servers wastes your time and can introduce reliability issues into your workflow.

The AgentRank score gives every server a single 0–100 quality rating built from five signals:

Scores above 80 are the safest tier — well-maintained, widely used, actively developed. Scores 60–80 are solid but may have gaps (lighter contributor counts or sporadic commit activity). Below 60, look carefully at the freshness signal specifically — if the last commit was six months ago and there are open bug reports, that's a real risk.

To check any server's score: paste its GitHub URL into the AgentRank Health Checker. You'll get the full signal breakdown in seconds.

6. Top 5 MCP servers to start with

These five servers are the highest-signal starting point for any developer. They cover the most common use cases, have the highest AgentRank scores in their categories, and have straightforward installation with no complex dependencies. All scores from the AgentRank index, March 2026.

npx -y @modelcontextprotocol/server-filesystem /path/to/your/projects

npx -y @modelcontextprotocol/server-github

npx -y @playwright/mcp

npx -y @modelcontextprotocol/server-brave-search

npx -y @modelcontextprotocol/server-memory

For a broader look at what's ranked highest across the full ecosystem, see the AgentRank leaderboard or the curated top MCP servers of 2026 list.

7. Common pitfalls and how to avoid them

JSON syntax errors in the config file

The most common installation failure. A single trailing comma, a missing quote, or a mismatched brace breaks the entire config — Claude Desktop silently loads no servers instead of flagging the broken one. Before restarting, validate your config:

# macOS/Linux
cat ~/Library/Application\ Support/Claude/claude_desktop_config.json \
  | python3 -m json.tool

# Or use an online validator: jsonlint.com

Forgetting to fully restart the client

On macOS, clicking the red close button hides the window but keeps the app running. MCP server config is only re-read on full restart. Use Cmd+Q (or File → Quit) to fully exit, then relaunch. In Cursor, use Developer: Reload MCP Servers from the command palette instead.

Installing servers without checking their score

GitHub is full of MCP servers with impressive README screenshots and zero recent commits. Before installing any server from a tutorial, blog post, or Reddit thread, paste its GitHub URL into the AgentRank Health Checker. A quick score check takes ten seconds and can save hours of debugging a broken integration.

Granting excessive file system access

The filesystem MCP server gets read and write access to every path you specify. Don't pass / or ~ as the root path. Pass the specific directories your AI workflow actually needs — your projects folder, not your entire home directory. The AI can create, modify, and delete files anywhere in scope.

Using the wrong Node.js version

Most MCP servers require Node.js 18 or higher. If your system Node is older, npx commands will fail with cryptic errors. Check with node --version and upgrade via nvm if needed.

Installing too many servers at once

Each MCP server is a subprocess that your AI client maintains a connection to. Start with two or three servers and verify each one works before adding more. If something breaks after adding five servers simultaneously, you won't know which one caused the issue. Add servers incrementally and test after each addition.

Not understanding what tools are available

After installing a new server, ask your AI assistant: "What MCP tools do you have available?" A good client will list the connected servers and their tools. Knowing what's available helps you write better prompts — instead of hoping the AI figures out it should use a tool, you can explicitly ask it to use a specific one.

Using servers from untrusted sources

MCP servers run as processes on your machine with whatever permissions you grant them. An MCP server with file access can read your SSH keys, API credentials, and source code. Stick to servers with high AgentRank scores, active GitHub histories, and maintainers with verifiable identities. The official @modelcontextprotocol servers are the safest baseline — they're maintained by the MCP working group and reviewed by Anthropic. For a full discussion of security considerations, see our MCP server security best practices guide.