How to build MCP Servers and Clients from Scratch

What is MCP Think of MCP as a USB C port on a laptop. With it, you can charge your laptop, perform data transfer, connect to other displays, and charge other Type C-supported devices as well. Similarly, Model Context Protocol (MCP) provides a standard, secure, real time, and two-way communicating interface to AI systems for connecting with external tools, API Services and data sources. What it means is, unlike traditional APIs integration which requires separate code, documentation, authentication methods, and maintenance, MCP can provide a single, standardized way for AI models to interact with external systems, i.e. you write code once and all AI systems can use it. The key differences between MCP and traditional APIs include: Feature MCP Traditional API Integration Effort Single, standardized integration Separate integration per API Real-Time Communication ✅ Yes ❌ No Dynamic Discovery ✅ Yes ❌ No Scalability Easy (plug-and-play) Requires additional integrations Security & Control Consistent across tools Varies by API MCP enables two-way communication, allowing AI models to both retrieve information and trigger actions dynamically. This makes it perfect for creating more intelligent and context-aware applications. So how this all works? MCP Components The MCP architecture consists of several key components that work together to enable seamless integration: MCP Hosts: These are applications (like Claude Desktop or AI-driven IDEs) that need access to external data or tools MCP Clients: They maintain dedicated, one-to-one connections with MCP servers. MCP Servers: Lightweight servers that expose specific functionalities via MCP, connecting to local or remote data sources. Local Data Sources: Files, databases, or services securely accessed by MCP servers Remote Services: External internet-based APIs or services accessed by MCP servers This separation of concerns makes MCP servers highly modular and maintainable. So how this all connect? How The Components Work Together Let’s understand this with a practical example: Say you're using Cursor (an MCP host) to manage your project's budget. You want to update a budget report in Google Sheets and send a summary of the changes to your team via Slack. Cursor (MCP host) initiates a request to its MCP client to update the budget report in Google Sheets and send a Slack notification. The MCP client connects to two MCP servers: one for Google Sheets and one for Slack. The Google Sheets MCP server interacts with the Google Sheets API (remote service) to update the budget report. The Slack MCP server interacts with the Slack API (remote service) to send a notification. MCP servers send responses back to the MCP client. The MCP client forwards these responses to Cursor, which displays the result to the user. This process happens seamlessly, allowing Cursor to integrate with multiple services through a standardized interface. But understanding fundamental is no use if one can’t build, so let’s get building! How to Build a MCP Server There are 2 ways to build a MCP Server, using Python SDK or JavaScript SDK, for sake of simplicity, I will stick to Python SDK. So, like any other good dev, let’s create a separate work environment to keep things isolated. 1. Work Environment Setup We start by creating a project directory. Navigate to your working folder and create a folder named mcp or u can use the terminal command: mkdir mcp cd mcp Next create a virtual environment using: # windows python -m venv dotenv # linux/mac python -m venv --help sudo apt-get install python3-venv #install venv - optional python3 -m venv dev-env Now activate the environment with: # activates env dotenv\Scripts\activate # linux/mac dotenv\Scripts\activate Ensure you see (dotenv) Infront of the terminal cwd path. Finally install 2 libraries - MCP SDK, MCP CLI: # install libraries pip install mcp mcp[cli] It might ask you permission to install, press y and once installed, we are done with setting up the environment 2. Writing the Server Code Open the folder in any of your favourite editors of choice, create a new file called calculator.py, and write the following code: # basic import from mcp.server.fastmcp import FastMCP import math # instantiate an MCP server client mcp = FastMCP("Hello World") # DEFINE TOOLS #addition tool @mcp.tool() def add(a: int, b: int) -> int: """Add two numbers""" return int(a + b) # subtraction tool @mcp.tool() def subtract(a: int, b: int) -> int: """Subtract two numbers""" return int(a - b) # multiplication tool @mcp.tool() def multiply(a: int, b: int) -> int: """Multiply two numbers""" return int(a * b) # division tool @mcp.tool() def divide(a: int, b: int) -> float: """Divide two numbers""" return float(a / b) # power tool @mcp.tool() def power(a: int, b: int) -> int: """Power

Mar 16, 2025 - 07:22

How to build MCP Servers and Clients from Scratch

What is MCP

Think of MCP as a USB C port on a laptop. With it, you can charge your laptop, perform data transfer, connect to other displays, and charge other Type C-supported devices as well.

Similarly, Model Context Protocol (MCP) provides a standard, secure, real time, and two-way communicating interface to AI systems for connecting with external tools, API Services and data sources.

What it means is, unlike traditional APIs integration which requires separate code, documentation, authentication methods, and maintenance, MCP can provide a single, standardized way for AI models to interact with external systems, i.e. you write code once and all AI systems can use it.

The key differences between MCP and traditional APIs include:

Feature	MCP	Traditional API
Integration Effort	Single, standardized integration	Separate integration per API
Real-Time Communication	✅ Yes	❌ No
Dynamic Discovery	✅ Yes	❌ No
Scalability	Easy (plug-and-play)	Requires additional integrations
Security & Control	Consistent across tools	Varies by API

MCP enables two-way communication, allowing AI models to both retrieve information and trigger actions dynamically. This makes it perfect for creating more intelligent and context-aware applications.

So how this all works?

MCP Components

The MCP architecture consists of several key components that work together to enable seamless integration:

MCP Hosts: These are applications (like Claude Desktop or AI-driven IDEs) that need access to external data or tools
MCP Clients: They maintain dedicated, one-to-one connections with MCP servers.
MCP Servers: Lightweight servers that expose specific functionalities via MCP, connecting to local or remote data sources.
Local Data Sources: Files, databases, or services securely accessed by MCP servers
Remote Services: External internet-based APIs or services accessed by MCP servers

This separation of concerns makes MCP servers highly modular and maintainable.

So how this all connect?

How The Components Work Together

Let’s understand this with a practical example:

Say you're using Cursor (an MCP host) to manage your project's budget. You want to update a budget report in Google Sheets and send a summary of the changes to your team via Slack.

Cursor (MCP host) initiates a request to its MCP client to update the budget report in Google Sheets and send a Slack notification.
The MCP client connects to two MCP servers: one for Google Sheets and one for Slack.
The Google Sheets MCP server interacts with the Google Sheets API (remote service) to update the budget report.
The Slack MCP server interacts with the Slack API (remote service) to send a notification.
MCP servers send responses back to the MCP client.
The MCP client forwards these responses to Cursor, which displays the result to the user.

This process happens seamlessly, allowing Cursor to integrate with multiple services through a standardized interface.

But understanding fundamental is no use if one can’t build, so let’s get building!

How to Build a MCP Server

There are 2 ways to build a MCP Server, using Python SDK or JavaScript SDK, for sake of simplicity, I will stick to Python SDK.

So, like any other good dev, let’s create a separate work environment to keep things isolated.

1. Work Environment Setup

We start by creating a project directory.

Navigate to your working folder and create a folder named mcp or u can use the terminal command:

mkdir mcp
cd mcp

Next create a virtual environment using:

# windows 
python -m venv dotenv

# linux/mac
python -m venv --help
sudo apt-get install python3-venv #install venv - optional
python3 -m venv dev-env

Now activate the environment with:

# activates env
dotenv\Scripts\activate

# linux/mac
dotenv\Scripts\activate

Ensure you see (dotenv) Infront of the terminal cwd path.

Finally install 2 libraries - MCP SDK, MCP CLI:

# install libraries
pip install mcp mcp[cli]

It might ask you permission to install, press y and once installed, we are done with setting up the environment

2. Writing the Server Code

Open the folder in any of your favourite editors of choice, create a new file called calculator.py, and write the following code:

# basic import 
from mcp.server.fastmcp import FastMCP
import math

# instantiate an MCP server client
mcp = FastMCP("Hello World")

# DEFINE TOOLS

#addition tool
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return int(a + b)

# subtraction tool
@mcp.tool()
def subtract(a: int, b: int) -> int:
    """Subtract two numbers"""
    return int(a - b)

# multiplication tool
@mcp.tool()
def multiply(a: int, b: int) -> int:
    """Multiply two numbers"""
    return int(a * b)

#  division tool
@mcp.tool() 
def divide(a: int, b: int) -> float:
    """Divide two numbers"""
    return float(a / b)

# power tool
@mcp.tool()
def power(a: int, b: int) -> int:
    """Power of two numbers"""
    return int(a ** b)

# square root tool
@mcp.tool()
def sqrt(a: int) -> float:
    """Square root of a number"""
    return float(a ** 0.5)

# cube root tool
@mcp.tool()
def cbrt(a: int) -> float:
    """Cube root of a number"""
    return float(a ** (1/3))

# factorial tool
@mcp.tool()
def factorial(a: int) -> int:
    """factorial of a number"""
    return int(math.factorial(a))

# log tool
@mcp.tool()
def log(a: int) -> float:
    """log of a number"""
    return float(math.log(a))

# remainder tool
@mcp.tool()
def remainder(a: int, b: int) -> int:
    """remainder of two numbers divison"""
    return int(a % b)

# sin tool
@mcp.tool()
def sin(a: int) -> float:
    """sin of a number"""
    return float(math.sin(a))

# cos tool
@mcp.tool()
def cos(a: int) -> float:
    """cos of a number"""
    return float(math.cos(a))

# tan tool
@mcp.tool()
def tan(a: int) -> float:
    """tan of a number"""
    return float(math.tan(a))

# DEFINE RESOURCES

# Add a dynamic greeting resource
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"


 # execute and return the stdio output
 if __name__ == "__main__":
    mcp.run(transport="stdio")

Ok, so let’s take a moment to understand what's happening in the code.

First, we imported the FastMCP server from the MCP package and the math module. The FastMCP Server manages connections, follows the MCP protocol, and routes messages.
Next, we created an MCP server client and named it "Hello World"