On this article, you’ll study what Mannequin Context Protocol (MCP) is and methods to construct a easy, sensible task-tracker MCP server in Python utilizing FastMCP.
Matters we are going to cowl embrace:
- How MCP works, together with hosts, shoppers, servers, and the three core primitives.
- How one can implement MCP instruments, assets, and prompts with FastMCP.
- How one can run and take a look at your MCP server utilizing the FastMCP consumer.
Let’s not waste any extra time.
Constructing a Easy MCP Server in Python
Picture by Editor
Introduction
Have you ever ever tried connecting a language mannequin to your individual information or instruments? If that’s the case, you recognize it usually means writing customized integrations, managing API schemas, and wrestling with authentication. And each new AI utility can really feel like rebuilding the identical connection logic from scratch.
Mannequin Context Protocol (MCP) solves this by standardizing how massive language fashions (LLMs) and different AI fashions work together with exterior programs. FastMCP is a framework that makes constructing MCP servers easy.
On this article, you’ll study what MCP is, the way it works, and methods to construct a sensible job tracker server utilizing FastMCP. You’ll create instruments to handle duties, assets to view job lists, and prompts to information AI interactions.
Understanding the Mannequin Context Protocol
As talked about, Mannequin Context Protocol (MCP) is an open protocol that defines how AI purposes talk with exterior programs.
How MCP Works
MCP has three parts:
Hosts are the AI-powered purposes customers really work together with. The host could be Claude Desktop, an IDE with AI options, or a customized app you’ve constructed. The host accommodates (or interfaces with) the language mannequin and initiates connections to MCP servers.
Shoppers connect with servers. When a number wants to speak to an MCP server, it creates a consumer occasion to handle that particular connection. One host can run a number of shoppers concurrently, every related to a special server. The consumer handles all protocol-level communication.
Servers are what you construct. They expose particular capabilities — database entry, file operations, API integrations — and reply to consumer requests by offering instruments, assets, and prompts.
So the consumer interacts with the host, the host makes use of a consumer to speak to your server, and the server returns structured outcomes again up the chain.
To study extra about MCP, learn The Full Information to Mannequin Context Protocol.
The Three Core Primitives
MCP servers expose three kinds of performance:
Instruments are capabilities that carry out actions. They’re like executable instructions the LLM can invoke. add_task, send_an_email, and query_a_database are some examples of instruments.
Assets present read-only entry to information. They permit viewing info with out altering it. Examples embrace lists of duties, configuration recordsdata, and consumer profiles.
Prompts are templates that information AI interactions. They construction how the mannequin approaches particular duties. Examples embrace “Analyze these duties and counsel priorities” and “Overview this code for safety points.”
In apply, you’ll mix these primitives. An AI mannequin would possibly use a useful resource to view duties, then a software to replace one, guided by a immediate that defines the workflow.
Setting Up Your Setting
You’ll want Python 3.10 or later. Set up FastMCP utilizing pip (or uv for those who want):
Let’s get began!
Constructing a Process Tracker Server
We’ll construct a server that manages a easy job listing. Create a file known as task_server.py and add the imports:
|
from fastmcp import FastMCP from datetime import datetime |
These give us the FastMCP framework and datetime dealing with for monitoring when duties have been created.
Initializing the Server
Now arrange the server and a easy in-memory storage:
|
mcp = FastMCP(“TaskTracker”)
# Easy in-memory job storage duties = [] task_id_counter = 1 |
Right here’s what this does:
FastMCP("TaskTracker")creates your MCP server with a descriptive title.dutiesis an inventory that shops all duties.task_id_countergenerates distinctive IDs for every job.
In an actual utility, you’d use a database. For this tutorial, we’ll preserve it easy.
Creating Instruments
Instruments are capabilities adorned with @mcp.software(). Let’s create three helpful instruments.
Instrument 1: Including a New Process
First, let’s create a software that provides duties to our listing:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
@mcp.software() def add_task(title: str, description: str = “”) -> dict: “”“Add a brand new job to the duty listing.”“” world task_id_counter
job = { “id”: task_id_counter, “title”: title, “description”: description, “standing”: “pending”, “created_at”: datetime.now().isoformat() }
duties.append(job) task_id_counter += 1
return job |
This software does the next:
- Takes a job title (required) and an non-obligatory description.
- Creates a job dictionary with a novel ID, standing, and timestamp.
- Provides it to our
dutieslisting. - Returns the created job.
The mannequin can now name add_task("Write documentation", "Replace API docs") and get a structured job object again.
Instrument 2: Finishing a Process
Subsequent, let’s add a software to mark duties as full:
|
@mcp.software() def complete_task(task_id: int) -> dict: “”“Mark a job as accomplished.”“” for job in duties: if job[“id”] == task_id: job[“status”] = “accomplished” job[“completed_at”] = datetime.now().isoformat() return job
return {“error”: f“Process {task_id} not discovered”} |
The software searches the duty listing for an identical ID, updates its standing to “accomplished”, and stamps it with a completion timestamp. It then returns the up to date job or an error message if no match is discovered.
Instrument 3: Deleting a Process
Lastly, add a software to take away duties:
|
@mcp.software() def delete_task(task_id: int) -> dict: “”“Delete a job from the listing.”“” for i, job in enumerate(duties): if job[“id”] == task_id: deleted_task = duties.pop(i) return {“success”: True, “deleted”: deleted_task}
return {“success”: False, “error”: f“Process {task_id} not discovered”} |
This software searches for a job, removes it from the listing, and returns affirmation with the deleted job information.
These three instruments give the mannequin create, learn, replace, and delete (CRUD) operations for job administration.
Including Assets
Assets let the AI utility view information with out modifying it. Let’s create two assets.
Useful resource 1: Viewing All Duties
This useful resource returns the entire job listing:
|
@mcp.useful resource(“duties://all”) def get_all_tasks() -> str: “”“Get all duties as formatted textual content.”“” if not duties: return “No duties discovered”
outcome = “Present Duties:nn” for job in duties: status_emoji = “✅” if job[“status”] == “accomplished” else “⏳” outcome += f“{status_emoji} [{task[‘id’]}] {job[‘title’]}n” if job[“description”]: outcome += f” Description: {job[‘description’]}n” outcome += f” Standing: {job[‘status’]}n” outcome += f” Created: {job[‘created_at’]}nn”
return outcome |
Right here’s how this works:
- The decorator
@mcp.useful resource("duties://all")creates a useful resource with a URI-like identifier. - The perform codecs all duties into readable textual content with emojis for visible readability.
- It returns a easy message if no duties exist.
The AI utility can learn this useful resource to know the present state of all duties.
Useful resource 2: Viewing Pending Duties Solely
This useful resource filters for incomplete duties:
|
@mcp.useful resource(“duties://pending”) def get_pending_tasks() -> str: “”“Get solely pending duties.”“” pending = [t for t in tasks if t[“status”] == “pending”]
if not pending: return “No pending duties!”
outcome = “Pending Duties:nn” for job in pending: outcome += f“⏳ [{task[‘id’]}] {job[‘title’]}n” if job[“description”]: outcome += f” {job[‘description’]}n” outcome += “n”
return outcome |
The useful resource filters the duty listing right down to pending gadgets solely, codecs them for straightforward studying, and returns a message if there’s nothing left to do.
Assets work properly for information the mannequin must learn regularly with out making modifications.
Defining Prompts
Prompts information how the AI utility interacts together with your server. Let’s create a useful immediate:
|
@mcp.immediate() def task_summary_prompt() -> str: “”“Generate a immediate for summarizing duties.”“” return “”“Please analyze the present job listing and supply:
1. Complete variety of duties (accomplished vs pending) 2. Any overdue or high-priority gadgets 3. Steered subsequent actions 4. Total progress evaluation
Use the duties://all useful resource to entry the entire job listing.”“” |
This immediate defines a structured template for job evaluation, tells the AI what info to incorporate, and references the useful resource to make use of for information.
Prompts make AI interactions extra constant and helpful. When the AI mannequin makes use of this immediate, it is aware of to fetch job information and analyze it on this particular format.
Working and Testing the Server
Add this code to run your server:
|
if __name__ == “__main__”: mcp.run() |
Begin the server out of your terminal:
|
fastmcp run task_server.py |
You’ll see output confirming the server is working. Now the server is able to settle for connections from MCP shoppers.
Testing with the FastMCP Consumer
You’ll be able to take a look at your server utilizing FastMCP’s built-in consumer. Create a take a look at file known as test_client.py and run it:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
from fastmcp import Consumer import asyncio
async def test_server(): async with Consumer(“task_server.py”) as consumer: # Listing accessible instruments instruments = await consumer.list_tools() print(“Out there instruments:”, [t.name for t in tools.tools])
# Add a job outcome = await consumer.call_tool(“add_task”, { “title”: “Be taught MCP”, “description”: “Construct a job tracker with FastMCP” }) print(“nAdded job:”, outcome.content material[0].textual content)
# View all duties assets = await consumer.list_resources() print(“nAvailable assets:”, [r.uri for r in resources.resources])
task_list = await consumer.read_resource(“duties://all”) print(“nAll duties:n”, task_list.contents[0].textual content)
asyncio.run(test_server()) |
You’ll see your instruments execute and assets return information. This confirms every little thing works accurately.
Subsequent Steps
You’ve constructed an entire MCP server with instruments, assets, and prompts. Right here’s what you are able to do to enhance it:
- Add persistence by changing in-memory storage with SQLite or PostgreSQL.
- Add instruments to filter duties by standing, date, or key phrases.
- Construct prompts for precedence evaluation or job scheduling.
- Use FastMCP’s built-in auth suppliers for safe entry.
Begin with easy servers like this one. As you develop extra comfy, you’ll end up constructing helpful MCP servers to simplify extra of your work. Glad studying and constructing!
