You want to build an MCP server in Python. What do you install and what does the API look like?

Attempt it

Install the mcp package from PyPI (pip install mcp or uv add mcp), maintained at github.com/modelcontextprotocol/python-sdk. The high-level API is FastMCP: from mcp.server.fastmcp import FastMCP; app = FastMCP("my-server"); @app.tool() def add(a: int, b: int) -> int: return a + b. JSON Schema is auto-generated from Python type hints (and Pydantic models), the docstring becomes the tool description the LLM sees, and JSON-RPC plus lifecycle plumbing is handled internally. stdio and streamable HTTP transports ship in the box. A working server is typically under 30 lines.

Your answer

The official **Python MCP SDK** is the `mcp` package on PyPI. You install it with `pip install mcp` (or `uv add mcp` if you use uv). The source lives at github.com/modelcontextprotocol/python-sdk and is maintained by the protocol team. The SDK's main feature is FastMCP, a decorator-based API styled after FastAPI. A working tool server looks like this: ```python from mcp.server.fastmcp import FastMCP app = FastMCP("my-server") @app.tool() def add(a: int, b: int) -> int: """Add two numbers.""" return a + b if __name__ == "__main__": app.run() ``` That is the complete file. The SDK reads the type hints on `add` and generates a JSON Schema describing the arguments. It uses the docstring as the tool description the LLM sees. All JSON-RPC framing, the initialize handshake, the tools/list and tools/call methods, and lifecycle handling happen inside `app.run()`. The SDK ships with stdio and streamable HTTP transport adapters. Stdio is the default. Point the file path in Claude Desktop's config and the add tool appears in the chat surface. The same decorator pattern extends to `@app.resource()` for readable URIs and `@app.prompt()` for templated prompts, covering all three MCP primitives.

The official **Python MCP SDK** is the `mcp` package on PyPI (`pip install mcp`), maintained at github.com/modelcontextprotocol/python-sdk by the protocol team. Python is overrepresented in ML and data tooling, which makes this the most popular SDK for internal MCP servers. The SDK ships FastMCP, a decorator-driven API borrowing its shape from FastAPI: ```python from mcp.server.fastmcp import FastMCP app = FastMCP("my-server") @app.tool() def add(a: int, b: int) -> int: """Add two numbers.""" return a + b if __name__ == "__main__": app.run() ``` Three things make this concise. First, JSON Schema for tool arguments is auto-generated from Python type hints (Pydantic models work too), so you never hand-write schemas. Second, the docstring becomes the tool description that the LLM sees, keeping documentation in code. Third, all JSON-RPC framing, the initialize handshake, and lifecycle handling are inside `app.run()`. Transports ship in the box. `app.run()` defaults to stdio, which is the transport Claude Desktop, Cursor, and Zed all use for local servers. Pass `transport="streamable-http"` and the same server speaks the remote transport instead. The decorator surface extends beyond tools to `@app.resource()` (readable URIs) and `@app.prompt()` (templated prompt starters), covering all three MCP primitives in one consistent API. Below FastMCP sits a low-level Server API (`mcp.server.lowlevel.Server`) for advanced cases like custom transports or session multiplexing. FastMCP is built on top of it. New code should default to FastMCP and only descend when hitting a genuine wall.

Quick reference

TL;DR

Install the `mcp` package from PyPI. The SDK exposes FastMCP, a decorator-driven API that auto-generates JSON Schema from type hints, uses docstrings as tool descriptions, and ships stdio plus streamable HTTP transports.

Memory aid

Sign in for the mnemonic that makes this stick. See Pro pricing.

Easy to grasp

Imagine you write a small Python file with a few functions that do useful things: add numbers, list files, query a database. The MCP Python SDK is a tiny library that lets you put one decorator above each function and turns the file into a server that any MCP host (Claude Desktop, Cursor, Zed) can connect to and call. The library reads your type hints to figure out what arguments each function expects, so the AI knows how to call you. You write normal Python; the SDK turns it into a tool server.

Key concepts

Python MCP SDK FastMCP Python type hints

Detailed answer & concept explanation

~5 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.

Sign in for 5 free unlocks/day or go Pro for unlimited. See Pro pricing.

Quick scan · 2–4 min

Everything important, quickly.

3 min: PyPI name and install command, GitHub repo, FastMCP decorator API with a code example, type-hint schema generation, three primitive decorators, default transport and how to switch.

Real-world examples

Real products, models, and research that use this idea.

A data team wraps their internal feature-store query API as a FastMCP server in roughly 50 lines, letting engineers ask Claude Desktop questions about feature freshness and data quality.
An ML engineer exposes a Hugging Face datasets browser as MCP resources so the model can read dataset cards and metadata on demand without hardcoded URLs.
An on-call team wraps PagerDuty incident search and acknowledge as FastMCP tools so an agent-mode assistant in Cursor can triage alerts during production incidents.

Interviewer follow-ups

What an interviewer would ask next. Try answering before peeking at the approach.

QHow does FastMCP turn Python type hints into JSON Schema?

Sign in or go Pro to see the approach for this follow-up.

QWhen would you reach for the low-level Server API instead of FastMCP?

Sign in or go Pro to see the approach for this follow-up.

QHow does FastMCP handle async tool functions?

Sign in or go Pro to see the approach for this follow-up.

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Pip-installing model context protocol or mcp-sdk instead of the canonical name `mcp`. The correct PyPI package is just `mcp`, maintained by Anthropic.

Sign in or go Pro to see all red flags and common mistakes. See Pro pricing.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

Sign in for 5 unlocks/day or go Pro for unlimited revision sheets. See Pro pricing.

References

Primary sources. Skim if you want the original framing.