Creating a Custom MCP Server

While prebuilt servers (like GitHub or PostgreSQL) are highly useful, production systems often require exposing internal company databases or custom computation engines. In this page, we build a custom FastMCP Math Server in Python and consume its tools in a separate agentic client application.

1. Defining the Custom Server using FastMCP

To build MCP servers easily, the SDK provides a high-level framework called FastMCP. FastMCP handles the JSON-RPC message serialization and transport setup automatically under the hood.

Step 1: Install FastMCP Dependency

Run in your terminal:

uv add "mcp[cli]"

Step 2: Write the Server Script (`mcp_server.py`)

We initialize a FastMCP instance and register tools using the @mcp.tool() decorator:

# mcp_server.py
from mcp.server.fastmcp import FastMCP

# Initialize FastMCP Server
mcp = FastMCP("MathServer")

@mcp.tool()
def add_numbers(a: float, b: float) -> float:
    """Adds two numbers together and returns the floating-point result."""
    return a + b

@mcp.tool()
def multiply_numbers(a: float, b: float) -> float:
    """Multiplies two numbers together and returns the floating-point result."""
    return a * b

if __name__ == "__main__":
    # Start stdio server loop
    mcp.run()

2. Consuming Custom Server Tools in an Agentic Client

Now, we build a client application that:

Spawns our mcp_server.py script as a subprocess stdio transport connection.
Queries the server’s available tools.
Binds those tools to a Chat Model so the LLM can invoke them.

Step 1: Initialize the Stdio Subprocess Param

We configure parameters to launch our server script:

from mcp import StdioServerParameters

server_params = StdioServerParameters(
    command="python3",
    args=["mcp_server.py"]
)

Step 2: Bind MCP Tools to ChatModel

We fetch the tool definitions from the server, format them for LangChain, and bind them:

# Retrieve tools from the active MCP session
tools_response = await session.list_tools()

# Format MCP tools for the LangChain bind_tools schema
langchain_tools = []
for tool in tools_response.tools:
    # Convert tool schemas dynamically
    langchain_tools.append({
        "name": tool.name,
        "description": tool.description,
        "parameters": tool.inputSchema
    })

# Bind tools to the LLM
llm_with_tools = llm.bind_tools(langchain_tools)

3. Client Implementation Script (`mcp_client.py`)

Here is the complete, self-contained client script that connects to our server subprocess, binds the exposed math tools to Gemini, and executes a calculation query:

# mcp_client.py
import asyncio
import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Load API keys for LLM client
load_dotenv()

async def run_agentic_mcp():
    # Configure parameters to launch our local custom server file
    server_params = StdioServerParameters(
        command="python3",
        args=["mcp_server.py"]
    )

    print("Connecting to local custom Math MCP Server...")
    async with stdio_client(server_params) as (read_stream, write_stream):
        async with ClientSession(read_stream, write_stream) as session:
            # Step A: Handshake
            await session.initialize()
            print("Handshake Complete!\n")

            # Step B: List Tools from custom server
            response = await session.list_tools()
            print("--- Custom Server Tools Registered ---")
            for t in response.tools:
                print(f"Tool: {t.name} -> {t.description}")

            # Step C: Bind Server tools dynamically to LLM
            llm = init_chat_model("gemini-2.5-flash", model_provider="google_genai")
            
            # Format tool specifications
            tools_spec = []
            for t in response.tools:
                tools_spec.append({
                    "name": t.name,
                    "description": t.description,
                    "parameters": t.inputSchema
                })
            
            llm_with_tools = llm.bind_tools(tools_spec)

            # Step D: Invoke Agent with a math query
            query = "What is 453.25 + 98.75? Please use your calculator tools."
            print(f"\nUser Query: '{query}'")
            
            response_msg = llm_with_tools.invoke(query)
            
            # Step E: Handle Tool call
            if response_msg.tool_calls:
                call = response_msg.tool_calls[0]
                print(f"\nAgent requested tool execution: '{call['name']}' with arguments {call['args']}")
                
                # Execute tool execution request on custom MCP Server
                result = await session.call_tool(name=call['name'], arguments=call['args'])
                print(f"\nMCP Server Tool Return: {result.content[0].text}")
                
                # Feed back output to model to get final conversational response
                final_response = llm.invoke([
                    ("user", query),
                    response_msg,
                    ("user", f"Tool result was: {result.content[0].text}. Summarize the answer.")
                ])
                print(f"\nFinal Agent Response: {final_response.content}")
            else:
                print(f"\nFinal Agent Response: {response_msg.content}")

if __name__ == "__main__":
    asyncio.run(run_agentic_mcp())

4. Practice Exercises

Practice 1: Adding a Division Tool

Modify the custom server script mcp_server.py to add a new division tool called divide_numbers(a: float, b: float) -> float. Define its docstring indicating that it divides a by b, and returns the result.

Solution

Add the following decorator and function to the server script mcp_server.py:

@mcp.tool()
def divide_numbers(a: float, b: float) -> float:
    """Divides a by b and returns the floating-point result. Raises error if b is zero."""
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b

Foundations

Agentic Implementation

1. Defining the Custom Server using FastMCP

Step 1: Install FastMCP Dependency

Step 2: Write the Server Script (`mcp_server.py`)

2. Consuming Custom Server Tools in an Agentic Client

Step 1: Initialize the Stdio Subprocess Param

Step 2: Bind MCP Tools to ChatModel

3. Client Implementation Script (`mcp_client.py`)

4. Practice Exercises

Practice 1: Adding a Division Tool

​1. Defining the Custom Server using FastMCP

​Step 1: Install FastMCP Dependency

​Step 2: Write the Server Script (mcp_server.py)

​2. Consuming Custom Server Tools in an Agentic Client

​Step 1: Initialize the Stdio Subprocess Param

​Step 2: Bind MCP Tools to ChatModel

​3. Client Implementation Script (mcp_client.py)

​4. Practice Exercises

​Practice 1: Adding a Division Tool

1. Defining the Custom Server using FastMCP

Step 1: Install FastMCP Dependency

Step 2: Write the Server Script (`mcp_server.py`)

2. Consuming Custom Server Tools in an Agentic Client

Step 1: Initialize the Stdio Subprocess Param

Step 2: Bind MCP Tools to ChatModel

3. Client Implementation Script (`mcp_client.py`)

4. Practice Exercises

Practice 1: Adding a Division Tool