🚀 Able to supercharge your AI workflow? Strive ElevenLabs for AI voice and speech technology!
On this article, you’ll be taught what Mannequin Context Protocol (MCP) is and the right way to construct a easy, sensible task-tracker MCP server in Python utilizing FastMCP.
Subjects we are going to cowl embody:
- How MCP works, together with hosts, purchasers, servers, and the three core primitives.
- implement MCP instruments, sources, and prompts with FastMCP.
- 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? In that case, 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 methods. FastMCP is a framework that makes constructing MCP servers easy.
On this article, you’ll be taught what MCP is, the way it works, and the right way to construct a sensible job tracker server utilizing FastMCP. You’ll create instruments to handle duties, sources 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 functions talk with exterior methods.
How MCP Works
MCP has three elements:
Hosts are the AI-powered functions customers truly work together with. The host might be Claude Desktop, an IDE with AI options, or a customized app you’ve constructed. The host comprises (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 purchasers concurrently, every related to a unique 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, sources, 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 be taught extra about MCP, learn The Full Information to Mannequin Context Protocol.
The Three Core Primitives
MCP servers expose three varieties of performance:
Instruments are features 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.
Sources present read-only entry to information. They permit viewing data with out altering it. Examples embody lists of duties, configuration recordsdata, and consumer profiles.
Prompts are templates that information AI interactions. They construction how the mannequin approaches particular duties. Examples embody “Analyze these duties and counsel priorities” and “Assessment this code for safety points.”
In observe, you’ll mix these primitives. An AI mannequin may use a useful resource to view duties, then a device to replace one, guided by a immediate that defines the workflow.
Setting Up Your Atmosphere
You’ll want Python 3.10 or later. Set up FastMCP utilizing pip (or uv should you favor):
Let’s get began!
Constructing a Process Tracker Server
We’ll construct a server that manages a easy job record. Create a file referred to 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 had 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 identify.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 features embellished with @mcp.device(). Let’s create three helpful instruments.
Device 1: Including a New Process
First, let’s create a device that provides duties to our record:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
@mcp.device() def add_task(title: str, description: str = “”) -> dict:     “”“Add a brand new job to the duty record.”“”     international 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 device does the next:
- Takes a job title (required) and an elective description.
- Creates a job dictionary with a singular ID, standing, and timestamp.
- Provides it to our
dutiesrecord. - Returns the created job.
The mannequin can now name add_task("Write documentation", "Replace API docs") and get a structured job object again.
Device 2: Finishing a Process
Subsequent, let’s add a device to mark duties as full:
|
@mcp.device() 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 device searches the duty record 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.
Device 3: Deleting a Process
Lastly, add a device to take away duties:
|
@mcp.device() def delete_task(task_id: int) -> dict: Â Â Â Â “”“Delete a job from the record.”“” Â Â Â Â 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 device searches for a job, removes it from the record, 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 Sources
Sources let the AI utility view information with out modifying it. Let’s create two sources.
Useful resource 1: Viewing All Duties
This useful resource returns the whole job record:
|
@mcp.useful resource(“duties://all”) def get_all_tasks() -> str:     “”“Get all duties as formatted textual content.”“”     if not duties:         return “No duties discovered”         consequence = “Present Duties:nn”     for job in duties:         status_emoji = “âś…” if job[“status”] == “accomplished” else “⏳”         consequence += f“{status_emoji} [{task[‘id’]}] {job[‘title’]}n”         if job[“description”]:             consequence += f”  Description: {job[‘description’]}n”         consequence += f”  Standing: {job[‘status’]}n”         consequence += f”  Created: {job[‘created_at’]}nn”         return consequence |
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!”         consequence = “Pending Duties:nn”     for job in pending:         consequence += f“⏳ [{task[‘id’]}] {job[‘title’]}n”         if job[“description”]:             consequence += f”  {job[‘description’]}n”         consequence += “n”         return consequence |
The useful resource filters the duty record all the way down to pending gadgets solely, codecs them for simple studying, and returns a message if there’s nothing left to do.
Sources work nicely for information the mannequin must learn continuously with out making adjustments.
Defining Prompts
Prompts information how the AI utility interacts along 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 record and supply:  1. Whole variety of duties (accomplished vs pending) 2. Any overdue or high-priority gadgets 3. Urged subsequent actions 4. Total progress evaluation  Use the duties://all useful resource to entry the whole job record.”“” |
This immediate defines a structured template for job evaluation, tells the AI what data 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 purchasers.
Testing with the FastMCP Consumer
You possibly can take a look at your server utilizing FastMCP’s built-in consumer. Create a take a look at file referred to 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:         # Checklist accessible instruments         instruments = await consumer.list_tools()         print(“Out there instruments:”, [t.name for t in tools.tools])                 # Add a job         consequence = await consumer.call_tool(“add_task”, {             “title”: “Be taught MCP”,             “description”: “Construct a job tracker with FastMCP”         })         print(“nAdded job:”, consequence.content material[0].textual content)                 # View all duties         sources = await consumer.list_resources()         print(“nAvailable sources:”, [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 sources return information. This confirms every part works appropriately.
Subsequent Steps
You’ve constructed a whole MCP server with instruments, sources, 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. Pleased studying and constructing!
🔥 Need one of the best instruments for AI advertising? Take a look at GetResponse AI-powered automation to spice up your online business!
