Python MCP Servers: The Complete Guide for Developers

If you're choosing a language to build your next MCP server in, Python is one of the two options with a first-party, officially maintained SDK — the other being TypeScript. Seven of the servers listed on DReview right now are written in Python, spanning databases, document conversion, and messaging platforms, and the ecosystem around the language's SDK has matured enough that picking Python is rarely a compromise anymore.

What is a Python MCP server?

A Python MCP server is a program, built with the official mcp package from the Model Context Protocol project, that exposes tools, resources, or prompts to an AI agent like Claude or Cursor over a standard JSON-RPC interface. It runs as a local subprocess (stdio) or a remote HTTP service, and the agent calls into it only when a connected tool is actually relevant to the user's request.

Should you build an MCP server in Python or TypeScript?

Both languages get equal first-class support from the Model Context Protocol project, so the honest answer is: pick whichever one your integration target already speaks. If you're wrapping a Python-only library — a data science package, an internal ORM, a model you already serve with FastAPI — writing the server in Python avoids a cross-language bridge entirely. If you're wrapping a Node.js API or working in a frontend-heavy codebase, TypeScript is the better fit. Neither SDK is behind the other on features; the choice is almost entirely about what the rest of your stack looks like.

Does Python support Streamable HTTP, or only stdio?

Yes — the official Python SDK supports both transports. Stdio is the default for local servers a client spawns as a subprocess; Streamable HTTP is for a server that needs to run remotely and serve multiple client sessions at once. Start with stdio unless you specifically need remote access — see local vs. remote MCP servers for the full tradeoff breakdown, which applies the same way regardless of which SDK you're building with.

How do you build an MCP server in Python?

The official SDK ships a high-level API called FastMCP, which turns a Python function into a usable MCP tool with a single decorator. Install it with pip install mcp (or uv add "mcp[cli]" if you're using uv), then define a server like this:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather-server")

@mcp.tool()
def get_weather(city: str) -> str:
    """Get the current weather conditions for a given city."""
    import httpx
    response = httpx.get(f"https://wttr.in/{city}?format=3")
    return response.text

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

That's a complete, working MCP server. FastMCP reads the function's type hints to generate the tool's input schema automatically, and the docstring becomes the description the model uses to decide when the tool is relevant — so a vague docstring produces a tool the model under-uses or misuses, exactly as with the TypeScript SDK's description field.

What is FastMCP, and is it different from the official SDK?

FastMCP started as a separate open-source project before its decorator-based API was adopted into the official mcp Python SDK as its recommended high-level interface. You don't need to install anything beyond mcp itself to get it — from mcp.server.fastmcp import FastMCP is part of the standard package today, not a separate dependency.

Which Python MCP servers can you install today?

Seven Python-built servers are live and verified on DReview as of this writing, spanning four categories:

Redis MCP Server — the official Redis-maintained server for cache, streams, sessions, and vector search, listed under Database.

AWS MCP Servers — AWS Labs' official collection of modular servers, including AWS documentation search and infrastructure-as-code guidance, listed under Cloud & Infrastructure.

Google Workspace MCP — Gmail, Calendar, Drive, Docs, and Sheets access through OAuth, listed under Content/Writing.

Office Word MCP Server — create and edit .docx files programmatically, also under Content/Writing.

MCP Pandoc — wraps the Pandoc universal converter to move content between Markdown, Word, PDF, and a dozen other formats, under Content/Writing.

Discord MCP Server — read, send, and manage Discord messages and channels via a bot token, listed under Communication.

Telegram MCP Server — connects through Telegram's MTProto client API (not the Bot API) to read and send messages as a real user session, also under Communication.

Every one of these went through the same four-point review DReview runs on every submission — a real, maintained repo, an actual license, working install configs, and an accurate description — covered in more depth in how DReview verifies listings.

How do you test a Python MCP server before connecting it to Claude or Cursor?

Use the official MCP Inspector, the same tool recommended for TypeScript servers: run npx @modelcontextprotocol/inspector python server.py to open a browser UI that lists your server's tools and lets you invoke them with test inputs before wiring up a real client. Catching a malformed response here is far faster than debugging it inside an actual chat session.

Once it works in the Inspector, add an entry to your client's config. For Claude Desktop, that's claude_desktop_config.json:

{
  "mcpServers": {
    "weather-server": {
      "command": "python",
      "args": ["/absolute/path/to/server.py"]
    }
  }
}

What if you need a Python MCP client instead of a server?

The same mcp package includes client primitives for building an application that connects out to MCP servers, rather than exposing tools itself — useful if you're building your own agent runtime rather than relying on Claude Desktop or Cursor as the client. Search interest in a standalone Python MCP client is real but far smaller than server-building interest, which tracks with how MCP is actually used today: most developers are exposing their own tools to an existing client, not writing a new client from scratch.

Can a Python MCP server handle concurrent requests?

Yes, if you write your tools as async def instead of plain def. FastMCP supports both, but a synchronous tool blocks the server's event loop while it runs — fine for a quick local file read, costly for anything that waits on a network call. A tool hitting an external API, a database, or another MCP server should be async:

@mcp.tool()
async def get_weather(city: str) -> str:
    """Get the current weather conditions for a given city."""
    import httpx
    async with httpx.AsyncClient() as client:
        response = await client.get(f"https://wttr.in/{city}?format=3")
        return response.text

This matters most for a remote Streamable HTTP server handling several client sessions at once; a blocking synchronous tool in that setup stalls every other in-flight request, not just its own caller.

What mistakes should you avoid when building a Python MCP server?

Thin docstrings. FastMCP turns your docstring into the only context the model gets about when to use a tool. "Gets weather" tells the model almost nothing; describe inputs, outputs, and constraints the way you'd brief a new teammate.

Returning raw dicts for everything. The SDK will serialize a Python object for you, but a dense nested structure burns the model's context on parsing instead of reasoning. Flatten or summarize before returning when the raw shape isn't what the model actually needs.

Letting exceptions bubble up unhandled. An unhandled Python exception looks like a dead connection to the client. Catch it and return a clear text error instead, so the model can explain the failure and potentially retry with different arguments.

Skipping type hints. FastMCP's automatic schema generation depends entirely on type hints being present and accurate — an untyped parameter becomes a schema the model has to guess at.

Where can you list a Python MCP server once it's published?

Once your server works and is published with a working README and a Python install config, submitting it to the awesome MCP servers directory DReview maintains is a free way to get it in front of developers already searching for exactly what you built — submit it here.