MCP: Why the Model Context Protocol Is the TCP/IP of AI Agents

Written by Ty Sutherland in AI Agents

diagram

Every time you connect Claude to your company’s Notion workspace, or watch an AI agent pull live data from a database and then write a ticket in Linear without being explicitly programmed to do either — that’s MCP doing the quiet work underneath. The Model Context Protocol, which Anthropic released as an open standard in late 2024, has in the roughly 18 months since become the connective tissue of the agentic AI layer. It’s not flashy. It doesn’t have a product launch video with dramatic music. But if you want to understand why AI agents are suddenly actually useful in production environments, you need to understand MCP the same way early web developers needed to understand HTTP. You don’t have to love the plumbing. You do have to know it exists.

What MCP Actually Is (Without the Jargon)

Before MCP, every AI integration was a bespoke nightmare. You wanted Claude or GPT-4 to talk to your internal database? Someone had to write custom glue code. You wanted your agent to interact with GitHub and then Slack and then your CRM? Three separate integration projects, three different maintenance burdens, zero standardization. Every model provider had their own way of doing tool calls. Every platform had its own format for exposing capabilities. The result was a fragmented mess that worked fine in demos and broke constantly in production.

MCP is a client-server protocol that standardizes how AI models connect to external data sources, tools, and services. The model (or the application running it) is the client. The thing it wants to talk to — a file system, a database, a web browser, a SaaS API — runs an MCP server. The protocol defines exactly how they communicate: how the server exposes its capabilities, how the client requests actions, how results come back. Clean, documented, consistent.

The TCP/IP comparison isn’t just a catchy headline. TCP/IP didn’t make the internet interesting by itself — it made it possible for countless different systems built by countless different people to reliably talk to each other. That’s exactly what MCP is doing for the AI agent ecosystem. When a developer writes an MCP server for, say, their PostgreSQL database, any MCP-compatible AI client — Claude Desktop, Cursor, a custom agent built with LangChain — can use it without any additional integration work. Write once, connect everywhere.

Why This Matters More Now Than It Did at Launch

When Anthropic first released MCP, the reaction in most developer circles was somewhere between cautious interest and polite skepticism. A new standard is only as good as its adoption, and the AI ecosystem in late 2024 was already littered with would-be standards that went nowhere. What’s changed in the months since is adoption — real, broad, not-just-startups adoption.

OpenAI, which had every competitive reason to ignore or counter-program against an Anthropic-originated standard, instead announced support for MCP in their agents. That was the signal. When the two largest model providers in the world converge on the same protocol, it stops being Anthropic’s standard and starts being the industry’s standard. Cursor built MCP into their development environment. Replit followed. Block, Sourcegraph, and a growing list of enterprise software companies have shipped MCP servers for their platforms. The GitHub MCP server alone has seen significant developer adoption, because being able to give an AI agent real read/write access to repositories — with a consistent, auditable interface — is genuinely useful for engineering workflows.

Aravind Srinivas, who has been increasingly vocal about how Perplexity thinks about agentic workflows, has pointed toward protocol standardization as a prerequisite for agents that can actually complete multi-step tasks reliably. The problem was never that models weren’t smart enough to use tools — GPT-4 could make API calls in 2023. The problem was that the scaffolding was too brittle. MCP addresses the scaffolding.

The Architecture: Servers, Clients, and What Actually Runs Where

It helps to have a concrete mental model. Here’s how the pieces fit together:

An MCP server exposes a set of capabilities — called tools, resources, and prompts in the protocol spec. A tool is something the AI can invoke: run this query, create this file, send this message. A resource is data the AI can read: the contents of a document, a database record, a webpage. A prompt is a pre-built instruction template the server provides for common tasks. The server doesn’t care what model is on the other end. It just responds to properly formatted requests.

An MCP client is the AI-side of the connection — typically either the model interface itself (like Claude Desktop) or an agent framework that’s orchestrating the model. The client discovers what tools and resources a server exposes, decides which ones are relevant to the current task, and calls them.

What makes this interesting architecturally is the local-first option. MCP servers can run locally on your machine, which means sensitive data — your code, your private documents, your internal databases — doesn’t have to go through a third-party cloud to be accessible to an AI agent. You’re not sending your entire codebase to Anthropic’s servers every time Claude helps you debug. The server running on your machine handles the retrieval; the model only sees what’s relevant to the specific request. For enterprise adoption, this distinction matters enormously.

Real-World MCP Use Cases That Are Actually in Production

Let’s be specific, because “AI agents that can use tools” has been promised so many times that the phrase has lost meaning.

Software development: Cursor’s MCP integration lets an AI coding assistant not just read your code but interact with your terminal, run tests, check your Git history, and create pull requests — all through a consistent interface. Andrej Karpathy has talked at length about the idea of AI as a “pair programmer with access to your whole context.” MCP is what makes the “access to your whole context” part practical rather than theoretical.

Business intelligence: Companies are running MCP servers in front of their data warehouses, letting non-technical employees ask questions in natural language and get answers pulled from live data — not from a pre-baked dashboard. The MCP layer handles the translation between “show me last quarter’s churn by region” and the actual SQL query that retrieves it, with proper access controls sitting at the server level rather than having to be re-implemented in every AI interface.

Customer support automation: Agents that can actually look up order status, process refunds, update account details, and escalate to humans when necessary — using MCP servers connected to the relevant backend systems. The agent doesn’t need to be retrained every time a new capability is added. You add a tool to the MCP server, and the agent can use it.

Personal productivity: Claude Desktop with local MCP servers for your file system, calendar, and email is a genuinely different experience from a chatbot. Asking it to “find all the documents I worked on last month related to the Henderson project and summarize the key decisions” and watching it actually do that is the kind of thing that makes people reconsider how they work.

MCP vs. the Alternatives: How It Compares

Approach How It Works Main Strength Main Weakness
Custom API integ

How to Connect Claude to a Real MCP Server (Step-by-Step)

Let’s make this concrete. The filesystem MCP server is the fastest way to get MCP working because it ships with Claude Desktop and requires zero API keys or accounts. Once you understand the pattern here, every other MCP server — GitHub, Slack, PostgreSQL — works the same way. You’re looking at 10 to 15 minutes from zero to working.

What You Need Before Starting

  • Claude Desktop installed (download from claude.ai/download — the web version does not support MCP)
  • Node.js 18 or higher installed (run node --version to check)
  • A terminal you’re comfortable with

Step 1: Find Your Claude Desktop Config File

Claude Desktop reads MCP server definitions from a single JSON config file. Its location depends on your OS:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

If the file doesn’t exist yet, create it. If it exists but is empty, that’s fine too.

Step 2: Add the Filesystem Server Config

Open the config file and paste this exact JSON. Replace /Users/yourname/Documents with whatever directory you actually want Claude to read and write:

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

What this does: when Claude Desktop starts, it runs that npx command as a background process. The MCP server starts up, registers its available tools with Claude, and stays alive for the duration of your session. Claude now knows it has tools like read_file, write_file, list_directory, and search_files available.

Step 3: Restart Claude Desktop Completely

This is not optional. Claude Desktop only reads the config on startup. Quit the app fully — on macOS, right-click the dock icon and choose Quit, don’t just close the window. Then reopen it.

Once it’s back open, look for a small hammer icon or a tools indicator near the chat input. If you see it, the MCP server connected successfully. If you don’t see it, skip to the debugging section below.

Step 4: Test It With a Real Prompt

Try this prompt verbatim:

“List all the files in my Documents folder, find any markdown files, and give me a one-sentence summary of what each one appears to be about based on its filename and the first 200 characters of its content.”

Before MCP, Claude would tell you it can’t access your filesystem. Now it actually does the thing. It calls list_directory, identifies the markdown files, calls read_file on each one, and synthesizes the results. That’s a tool chain that would have required custom code to set up six months ago.

Adding a Second Server: GitHub MCP

Once the filesystem server works, adding GitHub takes three minutes. You need a GitHub personal access token with repo scope — generate one at github.com/settings/tokens.

Update your config file to add a second entry inside mcpServers:

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

Restart Claude Desktop again. Now try this:

“Look at the open issues in my repo yourname/yourrepo, find any that mention a bug, and draft a short triage comment for each one that summarizes the problem and suggests a next step.”

Claude fetches the issues via the GitHub MCP server, reasons over them, and drafts comments it could post back. You can take it further and tell it to actually post the comments — it has that tool available now too.

When MCP Breaks: The Actual Failure Points

MCP setup fails in predictable ways. Here’s what actually goes wrong and how to get past it fast.

The Hammer Icon Never Appears

This means Claude Desktop either didn’t find the config file or the MCP server process failed to start. Check these in order:

  1. Confirm the config file path is exactly right — one wrong folder name and Claude silently ignores it.
  2. Run the npx command manually in your terminal to see if it errors. For the filesystem server: npx -y @modelcontextprotocol/server-filesystem /Users/yourname/Documents. If Node isn’t installed correctly or the package can’t download, you’ll see the error here instead of a silent failure inside Claude.
  3. Validate your JSON. Trailing commas, missing brackets, wrong quote types — any of these will cause a silent parse failure. Paste your config into a JSON validator before blaming anything else.

The Server Connects But Claude Says It Can’t Find Files

Almost always a path issue. The MCP server only has access to the directory you explicitly passed in the config args. If you passed /Users/yourname/Documents but you’re asking Claude about files in /Users/yourname/Desktop, it genuinely can’t see them. Either update the config to point at the right directory, or pass a higher-level path like /Users/yourname to give it broader access.

GitHub MCP Returns 401 Errors

Your token either doesn’t have the right scopes or it’s been pasted with extra whitespace. Go back to github.com/settings/tokens, confirm the token has repo scope enabled, and regenerate it if you’re unsure. Paste it fresh into the config. Token strings are easy to accidentally truncate when copying.

The Server Works Once and Then Stops Responding

The underlying Node process occasionally crashes, especially with the GitHub server under heavy use. Claude Desktop doesn’t always surface this clearly. The fix is to fully quit and restart Claude Desktop — it will relaunch the server processes fresh. If this happens repeatedly, check whether you’re hitting GitHub API rate limits, which the server doesn’t handle gracefully by default.

Checking the Logs

Claude Desktop writes MCP logs you can actually read. On macOS, open Console.app and filter by “Claude” — you’ll see the server stdout and stderr there. On Windows, check the logs folder at %APPDATA%\Claude\logs\. These logs will tell you exactly what the server process did and where it failed, which saves significant guesswork.

How to Connect Claude to a Real MCP Server in Under 15 Minutes

The fastest way to understand MCP is to actually run it. We’ll connect Claude Desktop to the filesystem MCP server — one of the reference implementations Anthropic ships — so Claude can read, write, and navigate files on your machine directly. No custom code. No API keys beyond what you already have. Just a config file and a working example you can build on.

This unlocks something concrete: instead of copy-pasting file contents into Claude and manually applying its suggestions, Claude can open the file, make the edit, save it, and confirm the result — all in one conversation turn. That’s the difference between an assistant and an agent.

What You Need Before Starting

  • Claude Desktop installed (Mac or Windows — download from claude.ai/download)
  • Node.js 18 or higher installed (run node --version to check)
  • About 10 minutes

Step 1: Install the Filesystem MCP Server

Anthropic maintains a set of official MCP servers in a public repository. The filesystem server is the simplest starting point because it has zero external dependencies. Open your terminal and run:

npm install -g @modelcontextprotocol/server-filesystem

This installs the server globally. Verify it worked:

npx @modelcontextprotocol/server-filesystem --version

Step 2: Edit the Claude Desktop Config File

Claude Desktop looks for MCP server definitions in a single JSON config file. Find it here depending on your OS:

  • Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Open that file in any text editor. If it doesn’t exist yet, create it. Paste in the following, replacing /Users/yourname/projects with the actual directory you want Claude to access:

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

A few things worth noting about this config. The command field is what Claude Desktop actually executes to start the server — it’s just a process running locally on your machine. The path in args is the root directory you’re exposing. Claude will be able to read and write anything inside it, and nothing outside it. Start narrow. You can always add more paths later by adding them as additional arguments.

Step 3: Restart Claude Desktop and Verify the Connection

Fully quit Claude Desktop — not just close the window, actually quit it — and reopen it. When it starts, it will launch the filesystem server as a subprocess in the background.

To confirm it’s working, open a new conversation and ask:

What files are in my projects directory?

If MCP is connected, Claude will call the list_directory tool and return actual file names from your disk. You’ll see a small tool call indicator in the UI showing that Claude is using an external capability, not just generating from memory. That indicator is your confirmation that the protocol handshake worked.

What Claude Can Now Do That It Couldn’t Before

With the filesystem MCP server connected, a single conversation can now do all of the following without you touching the keyboard again after the initial prompt:

  • Read a config file, identify a bug, write the fix back to disk, and confirm the change was saved
  • Scan a directory of markdown files, summarize each one, and write those summaries to a new file
  • Find all files modified in the last 24 hours and list which ones have TODOs in them
  • Refactor a function across multiple files and show you a diff before committing anything

To try a concrete one, paste this prompt into Claude after connecting:

Look at the files in my projects directory. Find any file with "config" in the name, read its contents, and write me a plain-English summary of what it configures. Save that summary as config-summary.txt in the same directory.

Claude will chain multiple tool calls — list directory, read file, write file — without you directing each step. That chaining is what makes it agentic rather than just conversational.

Common Failure Points and How to Fix Them

Symptom Likely Cause Fix
Claude says it can’t access files and shows no tool call indicator Config file not being read, or JSON is malformed Run the config through a JSON validator. One misplaced comma breaks the whole file. Also confirm you fully quit and relaunched Claude Desktop — closing the window is not enough.
Tool calls appear but fail with a path error The directory path in your config doesn’t exist or has a typo Run ls /Users/yourname/projects in your terminal to confirm the path resolves. Use the absolute path, not a relative one like ~/projects.
npx command not found error in Claude Desktop logs Node.js isn’t on the PATH that Claude Desktop inherits Replace "command": "npx" with the full path to npx, which you can find by running which npx in your terminal. It’ll look something like /usr/local/bin/npx.
Claude can read files but not write them File permissions on the target directory Check that your user account has write access to the directory. Run ls -la /Users/yourname/projects and confirm your user owns the files.

If you want to see exactly what’s happening under the hood, Claude Desktop writes MCP logs to ~/Library/Logs/Claude/mcp-server-filesystem.log on Mac. That file will show you the raw protocol messages — tool calls going out, results coming back, and any errors with their full context. When something breaks, that log is where you look first.

Connecting the GitHub MCP Server: A More Production-Relevant Example

The filesystem server is clean for learning the mechanics, but the GitHub MCP server is where this starts feeling like something you’d actually use at work. With it connected, Claude can search your repositories, read code, create issues, open pull requests, and leave comments — all from a conversation. No context switching, no copy-pasting URLs, no manually formatting issue descriptions.

Step 1: Get a GitHub Personal Access Token

Go to GitHub Settings → Developer settings → Personal access tokens → Tokens (classic). Generate a new token with these scopes: repo, read:org, and read:user. Copy the token — you’ll only see it once. If you’re working with private repos, repo is what gives read and write access. If you only need public repos, public_repo is enough.

Step 2: Add the GitHub Server to

Ty Sutherland

Ty Sutherland is the Chief Editor of AI Rising Trends. Living in what he believes to be the most transformative era in history, Ty is deeply captivated by the boundless potential of emerging technologies like the metaverse and artificial intelligence. He envisions a future where these innovations seamlessly enhance every facet of human existence. With a fervent desire to champion the adoption of AI for humanity's collective betterment, Ty emphasizes the urgency of integrating AI into our professional and personal spheres, cautioning against the risk of obsolescence for those who lag behind. "Airising Trends" stands as a testament to his mission, dedicated to spotlighting the latest in AI advancements and offering guidance on harnessing these tools to elevate one's life.

Recent Posts