Build an MCP Server: Tools, Resources, and Prompts

An MCP server is a small program that exposes capabilities to AI applications. The application, called the client, connects to the server, asks what it offers, and decides when to use it. The server does not need to know which model is on the other side.

Our server keeps tasks in a SQLite database. Setting it up takes two lines with the official Python SDK (version 2):

from mcp.server import MCPServer

mcp = MCPServer("taskboard-mcp")

Everything else is ordinary Python functions with a decorator on top.

MCP servers can expose three kinds of capability. The clearest way to tell them apart is to ask who decides when each one is used. Pick one to see it in this server.

@mcp.tool()
def add_task(title: str) -> dict[str, str]:
    """Create an open task and return it."""
    task_id = str(uuid4())
    task = {"id": task_id, "title": title, "status": "open"}
    with _database() as connection:
        connection.execute(
            "INSERT INTO tasks (id, title, status) VALUES (?, ?, ?)",
            (task_id, title, "open"),
        )
    return task

@mcp.resource("taskboard://tasks")
def tasks_resource() -> list[dict[str, str]]:
    """Show the current tasks on the taskboard."""
    return list_tasks()

@mcp.prompt()
def plan_open_tasks(goal: str) -> str:
    """Create a planning prompt using the current open tasks."""
    return (
        f"Help me make a practical plan for this goal: {goal}\n\n"
        'Use the taskboard-mcp `list_tasks` tool with status="open" to retrieve '
        "the current open tasks. Then order them into a practical plan and say "
        "what to do first. Do not change any task statuses."
    )

If it does something, such as changing data, it’s a tool. If it provides context to read, it’s a resource. If it’s a reusable way to ask for something, it’s a prompt.

Type hints do real work here. In list_tasks, the Literal type limits the status filter to two values, so the model cannot invent a third:

@mcp.tool()
def list_tasks(status: Literal["open", "completed"] | None = None) -> list[dict[str, str]]:
    """Return all tasks, or filter by open or completed status."""

When something goes wrong, raise ToolError. The client receives a clear error message instead of a crashed server:

@mcp.tool()
def complete_task(task_id: str) -> dict[str, str]:
    """Mark a task complete and return the updated task."""
    with _database() as connection:
        row = connection.execute(
            "SELECT title FROM tasks WHERE id = ?", (task_id,)
        ).fetchone()
        if row is None:
            raise ToolError(f"Task not found: {task_id}")
        connection.execute(
            "UPDATE tasks SET status = ? WHERE id = ?", ("complete", task_id)
        )
    return {"id": task_id, "title": row[0], "status": "complete"}

The same server can talk to clients in two ways, chosen when it starts:

if args.http:
    mcp.run(
        transport="streamable-http",
        host="127.0.0.1",
        port=8000,
        streamable_http_path="/mcp",
    )
else:
    mcp.run()

To try it, install the dependencies and start the server in either mode:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.txt

python server.py           # STDIO, for clients that launch the server
python server.py --http    # Streamable HTTP at http://127.0.0.1:8000/mcp

Any client that can launch a local process connects the same way over STDIO: point it at your virtual environment’s Python as the command, and at the absolute path to server.py as the argument.

Before connecting a real AI client, test every building block with MCP Inspector. It launches the server over STDIO and opens a browser interface:

npx @modelcontextprotocol/inspector@latest .venv/bin/python server.py

Use the Tools tab to call add_task or list_tasks, the Resources tab to read taskboard://tasks, and the Prompts tab to fill in plan_open_tasks with a goal such as “Prepare the demo by Friday”.

You can also use the server from your own code. The repository’s client.py launches the server and reads the resource:

server = StdioServerParameters(
    command=sys.executable,
    args=[str(SERVER_PATH)],
    cwd=str(SERVER_PATH.parent),
)

async with Client(server) as client:
    result = await client.read_resource("taskboard://tasks")

1. One server, many clients. MCP standardizes how AI applications connect to tools and data, so a server you build once works with any MCP client.
2. Ask who decides. Tools are actions the model chooses, resources are context the application reads, and prompts are templates the user picks.
3. Python makes it small. A decorator, type hints, and a clear docstring are enough to expose each building block.
4. Pick the transport for the client. STDIO suits local apps; Streamable HTTP suits networked clients and needs authentication before it is exposed.
5. Test first. MCP Inspector lets you exercise every tool, resource, and prompt before a real AI client uses them.