Python MCP Server with FastMCP 3.3.1: Real Install Guide

Here’s a detail almost nobody mentions: FastMCP isn’t just a Python MCP server framework. FastMCP 1.0 was incorporated into the official MCP Python SDK in 2024, and the standalone project is now downloaded a million times a day, with some version of FastMCP powering 70% of MCP servers across all languages. So when you install it, you’re installing the thing the official SDK was built from – plus four more years of features.

This is a deployment guide for the current release. No conceptual MCP tour, no calculator demo. Just what you need to get a Python MCP server running with the latest FastMCP, the install traps you’ll hit, and how to verify it actually works.

What you’re installing (and what changed recently)

As of late April 2026, the current stable release on PyPI is fastmcp 3.3.1, with a 3.4.0 beta in flight. Two things matter for anyone arriving from older tutorials:

• The repo moved.FastMCP moved from jlowin/fastmcp to PrefectHQ/fastmcp at v3.0. GitHub forwards old links, PyPI is the same, imports are the same. If a tutorial points you at the old org, the URL still works but bookmark the new one.
• 3.3 split the package.FastMCP 3.3 ships fastmcp-slim, a lightweight distribution that separates the client from the server stack. The full FastMCP package pulls in Starlette, Uvicorn, and the rest of the server machinery – necessary for running a server, but wasteful if you’re writing a client, a script, or an agent.

If you’re building a server, install the full package. If you’re writing an agent or test use that only calls MCP servers, install slim and save the dependency footprint.

System requirements for a Python MCP server

FastMCP requires Python 3.10 or higher. Anything below that and the install will refuse. Beyond that, there’s no published RAM or CPU minimum – a FastMCP server with a few tools will happily run inside a 256 MB container. The footprint comes from what your tools do, not from FastMCP itself.

The recommended column reflects an opinion based on the official docs and the issue tracker: uv sidesteps a known upgrade gotcha that pip users hit, and Python 3.12+ avoids a few asyncio deprecation warnings that surface on 3.14.

Install FastMCP 3.3.1

Three install paths, ranked by how much pain they save you.

Path 1 (recommended): uv

uv add fastmcp
# or, for a one-off project
uv pip install fastmcp==3.3.1

Why pin the exact version? FastMCP follows semantic versioning with pragmatic adaptations for the rapidly evolving MCP ecosystem, and breaking changes may occur in minor versions when necessary to stay current with the MCP Protocol. For production use, always pin to exact versions like fastmcp==3.0.0, not fastmcp>=3.0.0. That’s straight from the docs, and it’s good advice.

Path 2: pip (with one caveat)

pip install fastmcp==3.3.1

This works on a clean environment. On an upgrade, it sometimes doesn’t – see the troubleshooting section.

Path 3: client-only (slim)

uv add fastmcp-slim

Use this when you’re building something that consumes MCP servers but never runs one.

Pro tip: If you work in an enterprise where dependency licensing is reviewed, watch for docutils. FastMCP depends on Cyclopts for CLI functionality, and Cyclopts v4 includes docutils as a transitive dependency, which has complex licensing that may trigger compliance reviews. You can install Cyclopts v5 alpha which removes this dependency, or wait for the stable v5.

Your first server: minimum viable config

Skip the calculator. Here’s a server that exposes a single tool, runs over stdio (the default Claude Desktop transport), and shuts up cleanly when killed:

from fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool
def ping() -> str:
 """Health check. Returns 'pong'."""
 return "pong"

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

Save it as server.py. That’s the entire server. Declare a tool with a Python function, and the schema, validation, and documentation are generated automatically. No JSON Schema by hand, no JSON-RPC plumbing.

To run it over HTTP instead (useful for remote deployments), one line changes:

mcp.run(transport="streamable-http")

Verify the install works

Three checks, in order of how much they prove.

Check 1 – the version banner. Run:

fastmcp version

You should see something like: FastMCP version: 3.3.1, MCP version: 1.25.0, Python version: 3.12.2, Platform: macOS-… If this fails with “command not found”, your shell isn’t picking up the venv’s bin directory.

Check 2 – does the server start?

fastmcp dev server.py

This launches the server in development mode and opens the MCP Inspector in your browser. Click around the Tools tab and invoke ping. If you see pong, the protocol layer is healthy.

Check 3 – wire it to a real host.FastMCP 3.0 added a `fastmcp install` command that registers your server with Claude Desktop, Cursor, or Goose in one command:

fastmcp install server.py --client claude

Restart the host. If your tool shows up in its tool list, you’re done.

Common install errors (the ones that actually happen)

I’ll skip generic “check your venv” advice. These are the failures with real fixes.

ModuleNotFoundError: No module named ‘mcp.types’; ‘mcp’ is not a package

You have a local file or folder named mcp in your project. A real reported case: FastMCP 2.12.5 on Python 3.10, the import chain reaches `import mcp.types` and Python finds your local mcp first. Rename your file. Don’t call anything in your project mcp.py.

TypeError: FastMCP.__init__() got an unexpected keyword argument ‘dependencies’

You upgraded from FastMCP 2.x (or installed a package that did). In 3.0, the `ui=` parameter became `app=`, and 16 FastMCP() constructor kwargs were removed. If you’ve been ignoring months of deprecation warnings, you’ll get a TypeError with specific migration instructions. The dependencies= kwarg is one of them. Remove it from the FastMCP() call and declare dependencies in your pyproject.toml instead. This was reported against the awslabs core-mcp-server on macOS 26.1 with Python 3.11 and 3.14.2 in December 2025.

import fastmcp fails right after a pip upgrade

Classic pip behavior: it leaves the old install half-overwritten. If import fastmcp fails right after a pip upgrade from FastMCP 3.2 or earlier, run `pip install –force-reinstall fastmcp`. uv is unaffected. This is the single best argument for using uv on a project that crosses major-version boundaries.

fastmcp[tasks] fails at startup with ImportError

An upstream library broke. fakeredis 2.35.0 shipped an undocumented rename (FakeConnection → FakeAsyncRedisConnection) that broke pydocket’s memory:// backend, causing fastmcp[tasks] installs to fail at startup with an ImportError. The fix pins fakeredis<2.35.0 in the tasks extra. If you hit it before pulling the patched FastMCP, pin fakeredis yourself.

Upgrade and uninstall

Coming from FastMCP 2.x? The surface API is mostly unchanged – @mcp.tool() still works – but the constructor lost a pile of kwargs and a few module paths shifted. The upgrade guides at gofastmcp.com cover what broke. Pin the new version, run your tests, fix any TypeError from removed kwargs, and you’re usually done in an hour.

One more thing about upgrades: 3.x moved faster than the docs in early 2026. One reported example – `get_tools()` shows up in older content but the actual method is `list_tools()`. If a method name from an old tutorial doesn’t exist, search the changelog before assuming you’ve broken something.

Uninstall is boring, which is good:

uv pip uninstall fastmcp
# clean up the CLI dependency too if you want
uv pip uninstall cyclopts mcp

If you used fastmcp install to register with Claude Desktop, also remove the entry from ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or the equivalent on Windows. fastmcp install --help shows the exact path it writes to.

FAQ

Should I use FastMCP or the official MCP Python SDK directly?

Use FastMCP. The standalone project gets new features first, and the official SDK still ships FastMCP 1.0 inside it anyway.

What’s the difference between fastmcp-slim and fastmcp?

fastmcp-slim is the client-only distribution introduced in 3.3. It strips Starlette, Uvicorn, and the rest of the server stack. Concrete scenario: you’re building a CLI agent that talks to three remote MCP servers but never hosts one – install slim and your Docker image drops by tens of megabytes. If you call mcp.run() anywhere in your code, you need the full package instead.

Does FastMCP work on Python 3.14?

Yes, with one caveat. The 3.10 floor still holds, and recent FastMCP releases have already cleaned up the asyncio.iscoroutinefunction deprecation warnings that 3.14 emits. But some downstream MCP servers built against FastMCP 2.x (the AWS labs server is a documented example) still pass the removed dependencies kwarg – those will fail on any Python version until their authors update, not because of the interpreter.

Next: open the official installation page, copy the uv add fastmcp line, and get the version banner showing on your own machine before you write a single tool.