MCPs Simplified: USB-C for the AI Era 🔌

Posted on by — No Comments ↓

If you’ve ever tried to build an AI agent, you’ve hit the “Connector Wall.” You want your AI to check a Jira ticket, so you write a Jira wrapper. Then you want it to read a Postgres table, so you write a database connector. Then you want it to check Slack… you get the idea. By the time you’re done, you aren’t an AI engineer; you’re a full-time plumber fixing leaky integrations.

MCP (Model Context Protocol), introduced by Anthropic in late 2024, is the industry’s answer to this mess.

1. The Metaphor: The Universal Translator 🎙️

Imagine you are a world-class Chef (the LLM). You have incredible skills, but you are locked in a kitchen with no windows.

To cook, you need ingredients from different shops:

  • The Green Grocer (Your Local Files)
  • The Butcher (Your Database)
  • The Spice Merchant (External APIs like Slack or GitHub)

Before MCP, you had to learn the specific language of every shopkeeper and build a unique delivery path for each. It was exhausting.

MCP is the Universal Delivery App. You (the Chef) just put out a standard request: “I need 5kg of potatoes.” The Delivery App (MCP) knows exactly which shop to go to, how to talk to the shopkeeper, and brings the potatoes back in a standard crate that fits perfectly on your counter.

The Chef doesn’t need to know how the shop works; he just needs the ingredients.

2. The Core Architecture: Client vs. Server 🏗️

MCP splits the world into two simple halves:

A. The MCP Client (The “Brain”)

This is the interface where the AI lives.

  • Examples: Claude Desktop, Cursor, Windsurf, or your own custom-built AI application.
  • Job: To ask questions and use the tools provided by the server.

B. The MCP Server (The “Hands”)

This is a small, lightweight program that sits next to your data.

  • Examples: A script that reads your local Todoist, a bridge to your company’s AWS logs, or a connector to your Google Calendar.
  • Job: To tell the Client: “Here is what I can do, and here is how you call me.”

3. How it Works in Python 🐍

Let’s build a very simple MCP Server. Imagine we want an AI to be able to read “Notes” from a local folder on our machine.

First, you’d install the SDK: pip install mcp

Here is a simplified version of what that server looks like: 

from mcp.server.fastmcp import FastMCP

# 1. Initialize the MCP Server
mcp = FastMCP("MyNotesExplorer")

# 2. Define a "Tool" the AI can use
@mcp.tool()
def read_note(filename: str) -> str:
    """Reads a specific note from the local /notes folder."""
    try:
        with open(f"./notes/{filename}.txt", "r") as f:
            return f.read()
    except FileNotFoundError:
        return "Error: Note not found."

# 3. Define a "Resource" (static data the AI can see)
@mcp.resource("notes://list")
def list_notes() -> str:
    """Provides a list of all available notes."""
    import os
    return ", ".join(os.listdir("./notes"))

if __name__ == "__main__":
    mcp.run()

Why this is powerful:
1. Standardization: You wrote this in Python, but any MCP-compliant Client (even if written in TypeScript or Go) can now use this tool.

2. Discovery: When the Client connects, the Server automatically says: “Hey, I have a tool called read_note. Here are the arguments I need.”

3. Security: The LLM never sees your file system directly. It only sees the read_note function you chose to expose.

4. The Three Pillars of MCP 🏛️

When building an MCP server, you deal with three main things:

1. Resources: Think of these as Read-Only files. The AI can look at them whenever it wants (e.g., a database schema, a documentation file).

2. Tools: These are Actions. The AI can “call” these to make things happen (e.g., “Create a new Jira ticket,” “Run this SQL query,” “Send a Slack message”).

3. Prompts: These are Templates. You can provide the AI with pre-set instructions on how to act when using your server (e.g., “Act as a Senior SRE when analyzing these logs”).

5. Why You Should Care (The “Senior” Take) 🧐

If you are a lead or an architect, MCP solves three massive headaches:

  • Portability: You can build a suite of internal tools for your team. Whether a dev uses Claude, Cursor, or a terminal, they use the same tools. No more fragmented workflows.

  • Security: You can host an MCP server inside your VPN. The AI model (in the cloud) only receives the output of the tools, not access to the internal network itself.

  • Maintainability: When the API for Slack changes, you only update the MCP Server in one place. Every AI agent in your company is fixed instantly.

6. Getting Started Today 🚀

The best way to learn is to see it in action:

  • Download Claude Desktop.

  • Find a pre-made server: Go to the MCP Server Directory.

  • Connect it: Add the server to your claude_desktop_config.json.

  • Watch the magic: Open Claude, and you’ll see a little “plug” icon. Claude can now “see” your local files, your GitHub, or your Google Drive.

The Bottom Line:
In 2026, we are moving away from “Hard-coded Integrations”. MCP is the glue that makes AI actually useful in a professional environment. If you aren’t building with MCP yet, you’re still building with the “proprietary cables” of 2023.

Leave a Reply