Building Your Own MCP Server

Turn any Python application into an MCP server that Claude can use. This lesson covers the FastMCP SDK, implementing tools and resources, input validation, and local testing.

Learning Objectives

• Set up a project using the MCP Python SDK (FastMCP)
• Understand the server lifecycle: init, serve, shutdown
• Implement tools with typed parameters and JSON Schema
• Implement resources with URI schemes
• Test your server locally with the MCP Inspector

MCP Python SDK

The mcp Python package provides FastMCP, a high-level framework for building MCP servers with minimal boilerplate.

pip install "mcp[cli]"

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def hello(name: str) -> str:
    """Greet someone by name."""
    return f"Hello, {name}!"

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

Server Lifecycle

An MCP server goes through three phases:

1. Initialisation: Client connects, sends initialize request. Server responds with capabilities.
2. Operation: Client discovers tools/resources, then calls them as needed. The server processes requests and returns results.
3. Shutdown: Client disconnects or sends shutdown signal. Server cleans up resources.

With FastMCP, the lifecycle is handled automatically. You just define your tools and resources, and the framework manages the protocol.

Implementing Tools

Tools are functions the LLM can call. FastMCP uses decorators and type hints to generate schemas automatically.

@mcp.tool()
def add_note(title: str, content: str) -> str:
    """Add a new note to the collection.

    Args:
        title: Short title for the note
        content: Full text of the note
    """
    notes[title] = content
    return f"Note '{title}' saved ({len(content)} chars)"

@mcp.tool()
def list_notes() -> str:
    """List all saved notes with their titles."""
    if not notes:
        return "No notes yet."
    return "\n".join(f"- {title}" for title in notes)

The @mcp.tool() decorator registers the function as an MCP tool. The docstring becomes the tool description. Type hints become the JSON Schema input definition.

Implementing Resources

Resources provide data that the host can load into context. They use URI patterns for routing.

@mcp.resource("notes://all")
def get_all_notes() -> str:
    """Return all notes as formatted text."""
    if not notes:
        return "No notes saved."
    parts = [f"## {title}\n{content}" for title, content in notes.items()]
    return "\n\n".join(parts)

@mcp.resource("notes://{title}")
def get_note(title: str) -> str:
    """Return a specific note by title."""
    if title not in notes:
        return f"Note '{title}' not found."
    return notes[title]

Testing Locally

The MCP CLI includes an Inspector for testing servers without connecting to Claude.

# Run your server with the inspector
mcp dev notes_server.py

# Or test via the CLI
mcp run notes_server.py

The Inspector provides a web UI where you can:

• See all registered tools and resources
• Call tools with custom arguments and inspect results
• Browse resources by URI
• View the raw JSON-RPC messages

Demo

Live demonstration: building and testing a notes MCP server.

Lab & Homework