Master MCP in 5 Minutes: The USB‑C‑Like Connector for AI Tools

What Is MCP?

MCP (Model Context Protocol) is an open standard released by Anthropic at the end of 2024 that connects AI applications to external systems, data sources, and tools. Anthropic likens it to the USB‑C of the AI era because it standardizes communication across diverse AI clients such as Claude, ChatGPT, and Cursor.

Problems Solved by MCP

Before MCP, each AI tool required custom integration code, handling of disparate APIs, and maintenance of multiple adapters. With MCP, developers implement a single MCP Server, and any AI client that supports MCP can use it, enabling a "write once, run everywhere" model.

Core Concepts

MCP follows a client‑server architecture with three roles:

MCP Host : the AI application itself (e.g., Claude Desktop, VS Code).

MCP Client : lives inside the Host and handles communication with the Server.

MCP Server : a lightweight service that provides concrete capabilities and can run locally or remotely.

The protocol defines three primitives:

Tools (model‑driven): functions the model can actively call, such as "get weather".

Resources (application‑driven): data the model can read passively, like file contents or database records.

Prompts (user‑driven): predefined workflow templates.

In short, Tools = what the AI can do, Resources = what the AI can read, Prompts = templates the AI can use.

Hands‑On: Building a Weather MCP Server in 5 Minutes

1. Create the Project

mkdir weather-mcp && cd weather-mcp
uv init --package
uv add mcp
uv add httpx aiofiles

2. Write the Server Code

# weather_mcp.py
from mcp.server.fastmcp import FastMCP
import httpx

mcp = FastMCP("Weather")

# Free weather API for demonstration
WEATHER_API = "https://wttr.in/{city}?format=3"

@mcp.tool()
async def get_weather(city: str) -> str:
    """Query the weather forecast"""
    async with httpx.AsyncClient() as client:
        response = await client.get(WEATHER_API.format(city=city))
        return response.text

@mcp.resource("weather://{city}")
async def weather_resource(city: str) -> str:
    """Weather resource template"""
    return await get_weather(city)

3. Configure Claude Desktop

Add the following entry to

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

:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": ["--directory", "/absolute/path/weather-mcp", "run", "weather_mcp.py"]
    }
  }
}

After restarting Claude Desktop, you can ask the model "Help me check the weather in Beijing" and it will invoke the server.

Mainstream MCP Servers

File & Development

filesystem : local file read/write with safe path restrictions.

git : Git repository operations (commit, push, log).

everything : a comprehensive test server that includes examples of all primitives.

Data & API

fetch : fetch web content, supporting HTML and Markdown.

sqlite : SQLite database queries.

postgres : PostgreSQL database operations.

Tools & Efficiency

time : time and timezone conversion.

memory : knowledge‑graph persistent memory.

sequential-thinking : chained problem‑decomposition.

Practical case: After configuring filesystem and git servers, Claude Code can read project files, view Git history, and commit code without leaving the chat interface.

Community Ecosystem

The GitHub repository modelcontextprotocol/servers has over 85 k stars and hosts community‑maintained servers for integrations such as GitHub, Slack, Google Drive, Puppeteer browser automation, and vector‑database connectors.

MCP Apps: Running Applications Inside AI Conversations

In 2025 MCP introduced MCP Apps , allowing servers to return interactive HTML interfaces that render directly in AI dialogs. Examples include data‑visualization dashboards, forms, real‑time monitoring panels, and PDF viewers, turning AI responses into actionable applications.

Conclusion

MCP is becoming the infrastructure layer of the AI toolchain. Major tools—from Claude Desktop to VS Code, Cursor, and Goose—are rapidly adopting the protocol. The protocol is stable (v1.0 released), SDKs exist for TypeScript, Python, C#, Go, and Rust, and the community is expanding quickly.

Learning MCP now gives developers the key connector for the AI‑driven tooling era.