Constructing a Easy MCP Server in Python

G7 Digital4 days ago

0 8 minutes read

Constructing a Easy MCP Server in Python

On this article, you’ll study what Mannequin Context Protocol (MCP) is and the best way to construct a easy, sensible task-tracker MCP server in Python utilizing FastMCP.

Matters we are going to cowl embody:

How MCP works, together with hosts, purchasers, servers, and the three core primitives.
Learn how to implement MCP instruments, assets, and prompts with FastMCP.
Learn how to 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 personal information or instruments? If that’s the case, you realize it usually means writing customized integrations, managing API schemas, and wrestling with authentication. And each new AI software can really feel like rebuilding the identical connection logic from scratch.

Mannequin Context Protocol (MCP) solves this by standardizing how giant 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 the best way 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.

You will get the code on GitHub.

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 truly work together with. The host might be Claude Desktop, an IDE with AI options, or a customized app you’ve constructed. The host incorporates (or interfaces with) the language mannequin and initiates connections to MCP servers.

Purchasers 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 linked 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 person 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 forms 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.

Assets present read-only entry to information. They permit viewing data with out altering it. Examples embody lists of duties, configuration recordsdata, and person 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 “Overview this code for safety points.”

In observe, 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 Surroundings

You’ll want Python 3.10 or later. Set up FastMCP utilizing pip (or uv if you happen to choose):

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

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

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.
duties is an inventory that shops all duties.
task_id_counter generates distinctive IDs for every job.

In an actual software, you’d use a database. For this tutorial, we’ll preserve it easy.

Creating Instruments

Instruments are features embellished with @mcp.software(). Let’s create three helpful instruments.

Software 1: Including a New Process

First, let’s create a software that provides duties to our record:

@mcp.software() 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

@mcp.software()

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 software 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 duties record.
Returns the created job.

The mannequin can now name add_task("Write documentation", "Replace API docs") and get a structured job object again.

Software 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”}

@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 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.

Software 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 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”}

@mcp.software()

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 software 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 Assets

Assets let the AI software view information with out modifying it. Let’s create two assets.

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

@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 operate codecs all duties into readable textual content with emojis for visible readability.
It returns a easy message if no duties exist.

The AI software can learn this useful resource to grasp 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

@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 right down to pending gadgets solely, codecs them for simple studying, and returns a message if there’s nothing left to do.

Assets work properly for information the mannequin must learn incessantly with out making adjustments.

Defining Prompts

Prompts information how the AI software 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 record and supply: 1. Whole variety of duties (accomplished vs pending) 2. Any overdue or high-priority gadgets 3. Advised subsequent actions 4. Total progress evaluation Use the duties://all useful resource to entry the whole job record.”””

@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. Advised 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()

if __name__ == “__main__”:

mcp.run()

Begin the server out of your terminal:

fastmcp run task_server.py

fastmcp run task_server.py

You’ll see output confirming the server is operating. Now the server is able to settle for connections from MCP purchasers.

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 referred to as test_client.py and run it:

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(“Accessible 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 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())

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(“Accessible 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

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 the whole lot works appropriately.

Subsequent Steps

You’ve constructed a whole 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. Completely satisfied studying and constructing!

Supply hyperlink