Introducing FastMCP 🚀

Last week, Anthropic introduced the Model Context Protocol (MCP), a new standard for connecting AI models to data and tools. Think of it as a universal remote for the internet - a way for AI to safely interact with databases, files, APIs, and internal tools through a common interface.

The protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. You might spend more time writing infrastructure code than building things the AI can actually use.

That’s why I built FastMCP. I wanted building an MCP server to feel as natural as writing a Python function. Here’s how it works:

from fastmcp import FastMCP

mcp = FastMCP("File Server")

@mcp.resource("file://{path}")
def read_file(path: str) -> str:
    """Read a file from disk"""
    with open(path) as f:
        return f.read()

@mcp.tool()
def append_to_file(path: str, content: str) -> None:
    """Append content to a file"""
    with open(path, 'a') as f:
        f.write(content)

That’s it. No protocol details, no server lifecycle, no content types - just Python functions that define what your AI can do.

Pure Logic, No Boilerplate

Since FastMCP is built around standard Python functions, you can integrate any kind of functionality. Need database access? File operations? API calls? Just write the function that does it:

@mcp.tool()
def search_docs(query: str) -> list[str]:
    """Search documentation"""
    results = elastic.search(index="docs", q=query)
    return [hit["_source"]["content"] for hit in results["hits"]["hits"]]

@mcp.resource("profile://{user_id}")
def get_profile(user_id: str) -> str:
    """Get user profile"""
    return get_user_profile(user_id)

Each decorator tells FastMCP how to integrate your function:

• Resources provide data (like schemas or file contents). Think of these like GET endpoints for populating context.
• Tools perform actions (like searches or updates). Think of these like POST endpoints for performing actions.
• Prompts define templates for common interactions.

Everything is just Python - FastMCP handles the protocol machinery.

Why This Matters

Right now, everyone building AI applications has to write their own integrations from scratch. It’s like if every website had to implement its own version of HTTP. MCP provides a standard way for AI models to interact with data and tools, and FastMCP makes it dead simple to implement that standard.

Instead of building custom agents or copying data into prompts, you can publish a clean interface that any AI model can use. Want to make your company’s data searchable? Create an MCP server. Want to let AI models use your internal tools? MCP server. Want to permit AI’s to safely access your product? You get the idea.

Think of FastMCP as FastAPI for AI-native APIs - a microframework for building functionality over a standard protocol. I built the initial version in about 24 hours of excited hacking after MCP was announced, but it’s quickly grown beyond that. The community has already contributed excellent examples, bug fixes, and feature ideas. If you’re interested in making AI integration simpler and more standardized, we’d love to have you join us!

Come check out the examples, open an issue, or submit a PR - let’s make AI integration feel natural for everyone.

Give FastMCP a star on GitHub, and happy engineering!