Model Context Protocol (MCP)

Model Context Protocol (MCP) is an open protocol developed by Anthropic that standardizes how AI applications connect to external data sources and tools. It uses JSON-RPC 2.0 over STDIO (local) or HTTP with SSE (remote) for communication.

Architecture:

• MCP Host: the AI application (Claude Desktop, Claude Code, IDE plugin) that initiates connections
• MCP Client: maintains a 1:1 connection with an MCP server
• MCP Server: a lightweight process that exposes tools, resources, and prompts to the AI

Server capabilities:

• Tools: functions the AI can invoke (search files, run queries, send messages, create resources)
• Resources: data the AI can read (file contents, database records, API responses)
• Prompts: pre-built prompt templates the server provides

Protocol flow:

1. Host starts the MCP server process
2. Client and server exchange initialize messages (capability negotiation)
3. Client discovers available tools via tools/list
4. During conversation, the AI decides to call a tool
5. Client sends tools/call with the tool name and arguments
6. Server executes the tool and returns the result
7. AI incorporates the result into its response

Key design principles:

• Servers are stateless: each tool call is independent
• Human in the loop: the host can require user approval before executing tool calls
• Composable: multiple MCP servers can be connected simultaneously
• Local-first: servers run on the user’s machine, keeping data private

# Simple MCP server using FastMCP
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Network Tools")

@mcp.tool()
async def check_port(host: str, port: int) -> str:
    """Check if a TCP port is open on a remote host."""
    import asyncio
    try:
        _, writer = await asyncio.wait_for(
            asyncio.open_connection(host, port), timeout=5.0
        )
        writer.close()
        await writer.wait_closed()
        return f"Port {port} on {host} is OPEN"
    except (asyncio.TimeoutError, ConnectionRefusedError, OSError):
        return f"Port {port} on {host} is CLOSED or filtered"

@mcp.tool()
async def dns_lookup(domain: str) -> str:
    """Resolve a domain name to its IP addresses."""
    import socket
    try:
        results = socket.getaddrinfo(domain, None)
        ips = sorted(set(r[4][0] for r in results))
        return f"{domain} resolves to: {', '.join(ips)}"
    except socket.gaierror as err:
        return f"DNS lookup failed for {domain}: {err}"

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

// claude_desktop_config.json
{
  "mcpServers": {
    "network-tools": {
      "command": "python",
      "args": ["network_mcp.py"]
    }
  }
}