Model Context Protocol is the open standard Anthropic published in November 2024 to unify how AI clients discover and invoke external capabilities. The bottom line: write one Server, connect it from Claude Desktop, Cursor, or any MCP-compatible client — swap the underlying LLM without rewriting your tool layer.

┌────────────────────┐         ┌─────────────────────┐
│   MCP Client       │ ◄─────► │   MCP Server        │
│  (Claude / Cursor) │  JSON   │  (you build this)   │
│                    │  -RPC   │                     │
└────────────────────┘         └─────────────────────┘
                                        │
                          ┌─────────────┼─────────────┐
                          ▼             ▼             ▼
                       Tools       Resources      Prompts
                    (actions)     (data reads)   (templates)

Wire format is JSON-RPC 2.0. Lifecycle: initialize handshake → capability negotiation → request/response loop → graceful shutdown. Two transport modes dominate: stdio (local subprocess, zero network deps) and HTTP + SSE (remote, multi-client, team-shared).

You can have a working MCP Server running in under ten minutes. Python with FastMCP is the recommended starting path; TypeScript mirrors the same concepts with @modelcontextprotocol/sdk.

python -m venv .venv
source .venv/bin/activate
pip install mcp

npm init -y
npm install @modelcontextprotocol/sdk

Recommended project layout:

my-mcp-server/
├── server.py
├── tools/
│   ├── calculator.py
│   └── web_search.py
├── resources/
│   └── file_reader.py
├── prompts/
│   └── templates.py
├── tests/
│   └── test_tools.py
└── pyproject.toml

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-first-server")

@mcp.tool()
def say_hello(name: str) -> str:
    return f"Hello, {name}! This is your first MCP tool."

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

Run and verify with the official MCP Inspector:

python server.py
npx @modelcontextprotocol/inspector python server.py

Connect to clients: add the Server launch command in Claude Desktop claude_desktop_config.json or point Cursor mcp.json at the same command. After restart, confirm the tool appears in the client tool list and responds to a test invocation.

A production Server registers Tools for actions, Resources for readable data, and Prompts for reusable templates. Function signatures and docstrings become the AI-facing documentation — no separate OpenAPI doc required.

Tool structure: name from function name, parameters from type hints, description from docstring. Use Pydantic models for complex inputs:

from pydantic import BaseModel, Field

class SearchInput(BaseModel):
    query: str = Field(description="Search keywords")
    max_results: int = Field(default=5, description="Max results")
    language: str = Field(default="en", description="Result language")

@mcp.tool()
def web_search(input: SearchInput) -> list[dict]:
    ...

import httpx

@mcp.tool()
async def fetch_url(url: str) -> str:
    async with httpx.AsyncClient(timeout=30.0) as client:
        response = await client.get(url)
        response.raise_for_status()
        return response.text

Error handling: return structured error dicts for recoverable failures; raise only for unrecoverable states. Always set timeouts on I/O tools. Validate permissions before filesystem or database access.

Resources differ from Tools: Resources supply data via URI, Tools execute actions. Static resources use fixed URIs; dynamic resources accept path parameters.

@mcp.resource("config://app-settings")
def get_app_settings() -> str:
    return json.dumps({"version": "1.0", "env": "production"})

@mcp.resource("user://{user_id}/profile")
def get_user_profile(user_id: str) -> str:
    user = db.query_user(user_id)
    return json.dumps(user)

A filesystem resource Server lists directories, reads file contents, and can subscribe to change events. Prompts ship pre-built conversation templates with dynamic parameter injection:

from mcp.types import PromptMessage, TextContent

@mcp.prompt()
def code_review_prompt(language: str, code: str) -> list[PromptMessage]:
    return [
        PromptMessage(
            role="user",
            content=TextContent(
                type="text",
                text=f"Review this {language} code for bugs, security, and performance:\n```{language}\n{code}\n```"
            )
        )
    ]

Multi-turn Prompts mix user and assistant roles — useful for interview simulations, debug walkthroughs, and onboarding flows that need consistent structure across sessions.

Local STDIO covers dev; team-shared or SaaS deployments need HTTP + SSE. FastMCP supports streamable-http transport with minimal code change.

mcp = FastMCP("remote-server", transport="streamable-http")

if __name__ == "__main__":
    mcp.run(host="0.0.0.0", port=8000)

Production HTTP Servers need auth and guardrails: Bearer Token or API Key middleware, CORS restricted to known client origins, and rate limiting on tool endpoints that hit external APIs or databases.

MCP Inspector remains the primary debug UI: launch it against your Server command, call Tools interactively, inspect JSON-RPC request/response pairs, and simulate error paths before wiring a client.

import pytest
from mcp.client.session import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client

@pytest.mark.asyncio
async def test_calculator_tool():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"]
    )
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("calculate", {"expression": "2 + 2"})
            assert result.content[0].text == "4"

Moving from Hello World to production means containerization, observability, version negotiation, and a reference project that proves real value. The capstone below is a personal knowledge-base MCP Server — semantic search over local Markdown notes inside Cursor.

Deployment options: Docker wraps Python deps cleanly. Railway and Render offer one-click deploys for personal projects. AWS Lambda and Google Cloud Run suit bursty serverless workloads. Self-hosted VPS plus Nginx reverse proxy fits teams with existing infra. Add structured logging, Prometheus metrics on tool call counts, Sentry for error alerts, and a /health endpoint. Declare MCP protocol version and negotiate capabilities at handshake so clients degrade gracefully on upgrades.

Knowledge-base project: Index local Markdown with ChromaDB or Qdrant, embed with text-embedding-3-small, watch file changes via watchfiles. Expose three Tools — index notes, semantic search, write/update note — plus a Resource listing indexed files. In Cursor, ask "What did I write about MCP last week?" and the Agent calls your search tool, returning relevant snippets.

By 2026 every major AI client ships native MCP support. Marketplace directories list thousands of Servers; enterprise adoption is driving OAuth 2.0 auth standards and security audits on exposed endpoints. Next steps: read the full protocol spec at modelcontextprotocol.io, publish your first Server, combine MCP with Agent Skills for orchestrated workflows.

Lay out the alternatives honestly. Running HTTP+SSE on a primary MacBook breaks on lid close and OS updates. Serverless without session affinity drops multi-step Agent context. Exposing MCP endpoints without auth invites prompt-injection and unauthorized tool calls — roughly 1,000 unprotected Servers were indexed in 2026 audits. For teams that need Apple Silicon, 24/7 uptime, and isolation between MCP Server, iOS CI, and Agent Gateway workloads, renting a dedicated KVMNODE Mac Mini M4 or M4 Pro is often the better answer: flexible daily, weekly, or monthly terms, launchd-managed processes, snapshot rollback. Compare tiers on the pricing page, setup details in the help center, and provision through the order page when your MCP stack needs a host that stays up after you close the laptop.