August 16, 2026

Build Your First MCP Server with Python: Step-by-Step Tutorial (2026)

Model Context Protocol (MCP) allows AI applications to interact with external tools and data through a standardized interface.

In earlier tutorials, we learned what MCP is and how Claude can use MCP-based connectors. Now we will move from theory to development and build our first MCP server using Python.

For this beginner project, we will create a simple Student Information MCP Server.

The server will expose tools that allow an MCP-compatible AI application to:

list students,
find a student by roll number,
calculate a student’s average marks, and
identify students who scored above a specified mark.

The project is intentionally simple so that we can concentrate on understanding the MCP server architecture rather than dealing with databases or external APIs.

By the end of this tutorial, you will understand how to:

create a Python MCP project,
install the MCP Python SDK,
create an MCP server,
define MCP tools,
use Python type hints and docstrings,
run the server using STDIO,
test the server,
connect it to Claude Desktop, and
extend the server with additional tools.

What Are We Going to Build?

Our MCP server will maintain a small collection of student records.

For example:

students = [
    {
        "roll_no": 101,
        "name": "Juhi",
        "marks": [85, 90, 88]
    }
]

The MCP server will expose tools such as:

list_students

get_student

calculate_average

students_above_marks

An MCP client could then ask the server to perform these operations.

The architecture will look like this:

User

↓

Claude / MCP Client

↓

Student MCP Server

↓

Python Functions

↓

Student Data

↓

Result

↓

Claude

↓

User

Understanding the MCP Server

An MCP server is a program that exposes capabilities to MCP-compatible clients.

MCP servers can provide three important types of capabilities:

Tools

Functions that an AI model can invoke.

Examples:

get_student
calculate_average

Resources

Data or information that an MCP client can read.

Prompts

Reusable prompt templates that can assist users with particular workflows.

For our first project, we will concentrate on tools.

Prerequisites

Before starting, make sure you have:

Python 3.10 or later
basic Python knowledge
a terminal or PowerShell
an internet connection for installing packages
Claude Desktop if you want to test the finished server with Claude

Check your Python installation:

python --version

On some systems you may need:

python3 --version

You should see a version such as:

Python 3.12.5

Any supported Python 3.10+ version is suitable.

Step 1: Install uv

The official MCP Python development workflow uses uv for creating and managing the Python project.

On Windows PowerShell, run:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

After installation, close the terminal and open it again.

Verify the installation:

uv --version

You should see the installed uv version.

Installing uv on macOS or Linux

Use:

curl -LsSf https://astral.sh/uv/install.sh | sh

Restart the terminal after installation.

Then check:

uv --version

Step 2: Create the MCP Project

We will call our project:

student-mcp

Create the project:

uv init student-mcp

Move inside the folder:

cd student-mcp

The project directory has now been created.

Step 3: Create a Virtual Environment

Create a Python virtual environment:

uv venv

On Windows, activate it with:

.venv\Scripts\activate

On macOS/Linux:

source .venv/bin/activate

After activation, the terminal may show something similar to:

(student-mcp)

This indicates that the virtual environment is active.

Step 4: Install the MCP Python SDK

Install the MCP package:

uv add "mcp[cli]"

On Windows PowerShell, this can also be entered as:

uv add mcp[cli]

The MCP SDK and its required dependencies will be added to the project.

Step 5: Create the Server File

Create a file called:

student_server.py

On Windows PowerShell:

new-item student_server.py

On macOS/Linux:

touch student_server.py

Your project should now look roughly like:

student-mcp/
│
├── .venv/
├── pyproject.toml
├── student_server.py
└── ...

Step 6: Import MCPServer

Open student_server.py.

Add:

from mcp.server import MCPServer

Now create the MCP server instance:

mcp = MCPServer("student-server")

The string:

student-server

is the name of our MCP server.

At this point, we have created the basic server object.

Step 7: Add Sample Student Data

Now add a small in-memory data set.

students = [
    {
        "roll_no": 101,
        "name": "Juhi",
        "marks": [85, 90, 88]
    },
    {
        "roll_no": 102,
        "name": "Cherry",
        "marks": [78, 82, 80]
    },
    {
        "roll_no": 103,
        "name": "Charlie",
        "marks": [92, 95, 90]
    },
    {
        "roll_no": 104,
        "name": "Kanchan",
        "marks": [68, 75, 72]
    },
    {
        "roll_no": 105,
        "name": "Nyra",
        "marks": [88, 84, 91]
    }
]

For now, the data is stored directly inside Python.

Later, the same MCP server could interact with:

MySQL,
PostgreSQL,
MongoDB,
REST APIs,
cloud services, or
other external systems.

Step 8: Create Our First MCP Tool

Let’s create a tool that returns all students.

Add:

@mcp.tool()
def list_students() -> list[dict]:
    """Return all student records."""
    return students

The decorator:

@mcp.tool()

tells the MCP SDK that this Python function should be exposed as an MCP tool.

The function name:

list_students

becomes the tool name.

The docstring:

"""Return all student records."""

describes what the tool does.

MCP clients can use this information when deciding whether the tool is appropriate for a task.

How the First Tool Works

The flow is:

Claude

↓

Needs student list

↓

Calls:

list_students

↓

MCP Server

↓

Executes Python function

↓

Returns student records

↓

Claude receives result

Step 9: Create a Tool to Find One Student

Now add:

@mcp.tool()
def get_student(roll_no: int) -> dict | str:
    """Find a student using the student's roll number."""

    for student in students:
        if student["roll_no"] == roll_no:
            return student

    return "Student not found."

This tool accepts one parameter:

roll_no

The type hint:

roll_no: int

indicates that the roll number should be an integer.

For example:

get_student(103)

would return:

Charlie
Marks: 92, 95, 90

in structured form.

Why Type Hints Matter

Notice this function definition:

def get_student(roll_no: int) -> dict | str:

The parameter type is:

int

The return value can be:

dict

or:

str

The MCP Python SDK uses Python type information when generating the schema describing a tool.

This helps MCP clients understand:

what arguments the tool requires,
what type of input should be supplied, and
what the function does.

Step 10: Create an Average-Marks Tool

Add another tool:

@mcp.tool()
def calculate_average(roll_no: int) -> str:
    """Calculate the average marks for a student."""

    for student in students:
        if student["roll_no"] == roll_no:
            marks = student["marks"]
            average = sum(marks) / len(marks)

            return (
                f"{student['name']} has an average score "
                f"of {average:.2f}"
            )

    return "Student not found."

Suppose the tool is called with:

calculate_average(101)

The marks are:

85, 90, 88

The result would be approximately:

Juhi has an average score of 87.67

Step 11: Create a Search Tool

Now let’s create a tool that finds students whose average is above a specified value.

Add:

@mcp.tool()
def students_above_marks(minimum_average: float) -> list[dict]:
    """Return students whose average marks exceed the specified value."""

    result = []

    for student in students:
        marks = student["marks"]
        average = sum(marks) / len(marks)

        if average >= minimum_average:
            result.append(
                {
                    "roll_no": student["roll_no"],
                    "name": student["name"],
                    "average": round(average, 2)
                }
            )

    return result

For example:

students_above_marks(85)

might return:

Juhi
Charlie
Nyra

depending on their calculated averages.

Step 12: Run the MCP Server

At the bottom of student_server.py, add:

if __name__ == "__main__":
    mcp.run(transport="stdio")

This tells the server to communicate using the STDIO transport.

STDIO means:

Standard Input / Standard Output

The MCP client communicates with the server through its input and output streams.

Complete MCP Server Code

Our complete beginner server now looks like this:

from mcp.server import MCPServer


mcp = MCPServer("student-server")


students = [
    {
        "roll_no": 101,
        "name": "Juhi",
        "marks": [85, 90, 88]
    },
    {
        "roll_no": 102,
        "name": "Cherry",
        "marks": [78, 82, 80]
    },
    {
        "roll_no": 103,
        "name": "Charlie",
        "marks": [92, 95, 90]
    },
    {
        "roll_no": 104,
        "name": "Kanchan",
        "marks": [68, 75, 72]
    },
    {
        "roll_no": 105,
        "name": "Nyra",
        "marks": [88, 84, 91]
    }
]


@mcp.tool()
def list_students() -> list[dict]:
    """Return all student records."""
    return students


@mcp.tool()
def get_student(roll_no: int) -> dict | str:
    """Find a student using the student's roll number."""

    for student in students:
        if student["roll_no"] == roll_no:
            return student

    return "Student not found."


@mcp.tool()
def calculate_average(roll_no: int) -> str:
    """Calculate the average marks for a student."""

    for student in students:
        if student["roll_no"] == roll_no:
            marks = student["marks"]
            average = sum(marks) / len(marks)

            return (
                f"{student['name']} has an average score "
                f"of {average:.2f}"
            )

    return "Student not found."


@mcp.tool()
def students_above_marks(minimum_average: float) -> list[dict]:
    """Return students whose average marks exceed the specified value."""

    result = []

    for student in students:
        marks = student["marks"]
        average = sum(marks) / len(marks)

        if average >= minimum_average:
            result.append(
                {
                    "roll_no": student["roll_no"],
                    "name": student["name"],
                    "average": round(average, 2)
                }
            )

    return result


if __name__ == "__main__":
    mcp.run(transport="stdio")

We now have a complete MCP server.

Step 13: Run the Server

From the project directory, run:

uv run student_server.py

The server now waits for communication from an MCP client.

You may not see an ordinary application interface.

That is expected.

An STDIO MCP server communicates with an MCP client through the protocol rather than displaying a normal menu.

Important: Do Not Use print() Carelessly

This is particularly important for an STDIO MCP server.

Avoid writing ordinary messages to standard output using:

print("Server started")

Why?

Because STDIO is being used for MCP protocol communication.

Writing unrelated text to stdout can corrupt the protocol messages exchanged between the client and server.

If you need logging, use Python’s logging facilities configured to write to stderr.

For example:

import logging

logger = logging.getLogger(__name__)

logger.info("Processing request")

This is safer for an STDIO-based MCP server.

Step 14: Test with MCP Inspector

Before connecting our server to Claude Desktop, it is useful to test it independently.

The MCP Inspector is the official developer tool for testing and debugging MCP servers.

It can help you:

view server capabilities,
inspect available tools,
call tools,
examine arguments,
inspect responses, and
debug MCP problems.

The Inspector currently provides browser, CLI, and terminal interfaces.

Launch MCP Inspector

MCP Inspector is distributed through npm.

Current Inspector versions require a supported recent Node.js installation.

From a terminal, you can launch the Inspector and point it to your MCP server.

For example, the general pattern is:

npx @modelcontextprotocol/inspector <server command>

For our Python server, the server command is:

uv run student_server.py

Therefore, from the project directory you can use:

npx @modelcontextprotocol/inspector uv run student_server.py

The Inspector starts and provides a browser interface.

Inspect the Available Tools

After connecting, look at the server’s available tools.

You should see tools such as:

list_students

get_student

calculate_average

students_above_marks

Select a tool and provide its arguments.

For example, choose:

get_student

and enter:

roll_no = 103

Run the tool.

The returned record should correspond to Charlie.

Test calculate_average

Select:

calculate_average

Enter:

The expected response should indicate Juhi’s average.

Try another roll number:

Then try an invalid value:

The server should return:

Student not found.

This demonstrates why testing both valid and invalid input is important.

Test students_above_marks

Select:

students_above_marks

Use:

The server should return only students whose calculated average is at least 85.

Try different threshold values:

Observe how the results change.

Step 15: Connect the Server to Claude Desktop

Once the MCP server works in Inspector, we can connect it to Claude Desktop.

Claude Desktop needs to know:

what the server is called,
which command launches it, and
where the project is located.

The configuration is stored in:

claude_desktop_config.json

Find the Claude Desktop Configuration File

On Windows, the configuration file is normally located at:

%APPDATA%\Claude\claude_desktop_config.json

A convenient way to open it from PowerShell, if VS Code is installed, is:

code $env:AppData\Claude\claude_desktop_config.json

On macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

On Linux, current Claude configurations may use:

~/.config/Claude/claude_desktop_config.json

Step 16: Add the MCP Server Configuration

Suppose your Windows project is stored at:

C:\Users\YourName\Documents\student-mcp

Add:

{
  "mcpServers": {
    "student-server": {
      "command": "uv",
      "args": [
        "--directory",
        "C:\\Users\\YourName\\Documents\\student-mcp",
        "run",
        "student_server.py"
      ]
    }
  }
}

Replace:

YourName

with your actual Windows username.

Use an absolute path.

macOS/Linux Configuration

For macOS or Linux, the configuration might look like:

{
  "mcpServers": {
    "student-server": {
      "command": "uv",
      "args": [
        "--directory",
        "/home/username/student-mcp",
        "run",
        "student_server.py"
      ]
    }
  }
}

Change the path according to your actual project location.

Why Is –directory Used?

Consider:

uv --directory PATH run student_server.py

The option:

--directory

tells uv which project directory it should use.

Claude Desktop can therefore launch the MCP server even when Claude itself was started from a different directory.

Step 17: Find the Full uv Path if Necessary

Sometimes Claude Desktop may not find the uv command.

On Windows, run:

where uv

You may receive something similar to:

C:\Users\YourName\.local\bin\uv.exe

You can then replace:

"command": "uv"

with the complete path:

"command": "C:\\Users\\YourName\\.local\\bin\\uv.exe"

On macOS/Linux, use:

which uv

Step 18: Restart Claude Desktop

After saving the configuration:

Completely quit Claude Desktop.
Start Claude Desktop again.
Open a new conversation.
Check the available connectors/tools.

If the configuration is correct, the new MCP server should be available.

Step 19: Ask Claude to Use the MCP Server

Try:

List all students available in the student server.

Claude can determine that the:

list_students

tool is relevant.

It may request permission to use the tool.

Approve the request after reviewing it.

Claude should then display the student information.

Try More Natural-Language Questions

You do not have to use the exact Python function names.

For example:

What are Charlie’s marks?

Claude can determine that it needs:

get_student

with:

roll_no = 103

You could also ask:

What is Juhi’s average score?

Claude can use:

calculate_average

Or:

Which students have an average above 85?

Claude can use:

students_above_marks

This is one of the important ideas behind MCP.

The user communicates using natural language, while the AI determines which structured MCP tool can help complete the request.

What Is Actually Happening?

Suppose the user asks:

Which students have an average above 85?

The workflow may be:

User

↓

Claude understands request

↓

Claude sees available MCP tools

↓

Selects:

students_above_marks

↓

Provides argument:

↓

MCP Server executes Python

↓

Returns student records

↓

Claude interprets result

↓

User receives natural-language answer

The MCP server is not an AI model.

It is a software service that exposes structured capabilities to the AI application.

Adding Another Tool

Let’s extend the project.

Suppose we want to know the highest-performing student.

Add:

@mcp.tool()
def highest_scoring_student() -> dict:
    """Return the student with the highest average marks."""

    best_student = None
    best_average = -1

    for student in students:
        average = sum(student["marks"]) / len(student["marks"])

        if average > best_average:
            best_average = average
            best_student = {
                "roll_no": student["roll_no"],
                "name": student["name"],
                "average": round(average, 2)
            }

    return best_student

Restart the MCP server or Claude Desktop as required.

The tool:

highest_scoring_student

should now become available.

Ask:

Who is the highest-performing student?

Claude can invoke the new tool.

Add a Subject-Specific Tool

Suppose the three marks correspond to:

Python
Java
Cloud Computing

We could represent each student’s marks more clearly:

"marks": {
    "Python": 85,
    "Java": 90,
    "Cloud Computing": 88
}

Then we could create:

get_subject_topper

For example:

Who scored highest in Python?

This shows how a simple MCP server can gradually become a more realistic application.

Tools Should Do One Clear Job

Avoid designing one enormous tool such as:

manage_everything

Instead, prefer small, understandable capabilities:

list_students

get_student

calculate_average

highest_scoring_student

Clear tools are easier to:

understand,
secure,
test,
document,
debug, and
authorize.

Use Clear Docstrings

Compare:

@mcp.tool()
def get_student(roll_no: int):
    """Get data."""

with:

@mcp.tool()
def get_student(roll_no: int):
    """Return the student record matching the supplied roll number."""

The second description provides much more useful information.

Remember that an AI client may use tool descriptions when determining which tool to invoke.

Good descriptions therefore improve tool discoverability and reduce ambiguity.

Input Validation

Our first server is deliberately simple.

In a real application, you should validate tool input.

For example:

@mcp.tool()
def get_student(roll_no: int) -> dict | str:
    """Find a student using a positive integer roll number."""

    if roll_no <= 0:
        return "Roll number must be positive."

    for student in students:
        if student["roll_no"] == roll_no:
            return student

    return "Student not found."

Input validation becomes increasingly important when a tool performs:

database operations,
file changes,
API calls,
cloud actions, or
other real-world side effects.

Read Tools vs Write Tools

Our current tools are all read-oriented.

They return information but do not modify data.

Examples:

get_student

list_students

These are relatively low risk.

Suppose we add:

delete_student

That becomes a write/destructive tool.

For example:

@mcp.tool()
def delete_student(roll_no: int) -> str:
    """Delete a student record."""

A tool like this can change real data.

Production MCP servers therefore require much more careful:

authorization,
validation,
logging,
confirmation,
auditability, and
permission design.

For your first MCP server, start with read-only tools.

Security Principles for MCP Servers

Building an MCP server means giving an AI application access to capabilities.

Always think about what those capabilities can do.

Follow these principles.

Least privilege

Expose only the tools the AI genuinely needs.

Validate input

Never assume tool parameters are automatically safe.

Protect credentials

Do not hard-code secrets.

Restrict external access

A database user used by an MCP server should have only the permissions required.

Review destructive actions

Delete, update, deployment, payment, messaging, and infrastructure operations deserve additional controls.

Log important actions

Production systems should maintain appropriate audit information.

Treat external content cautiously

Data returned by external systems may contain malicious or misleading instructions.

STDIO vs HTTP MCP Servers

Our first MCP server uses:

mcp.run(transport="stdio")

STDIO is convenient for local integrations because the client launches the server process and communicates directly with it.

Architecture:

Claude Desktop

↓

STDIO

↓

Local Python MCP Server

For hosted integrations, MCP can also operate over network transports.

A remote architecture might look like:

Claude

↓

Network

↓

Remote MCP Server

↓

Database/API

Remote servers introduce additional concerns such as:

authentication,
HTTPS,
authorization,
network security,
deployment, and
availability.

STDIO is therefore a good place to begin.

Common Error: Claude Cannot Find the MCP Server

Check the following:

Is the project path correct?
Is it an absolute path?
Is uv installed?
Can Claude Desktop find the uv executable?
Is student_server.py spelled correctly?
Did you completely restart Claude Desktop?

On Windows, remember that JSON paths commonly use double backslashes:

C:\\Users\\YourName\\student-mcp

Common Error: Server Immediately Stops

Try running the server manually:

uv run student_server.py

If Python displays an error, correct that error first.

Common causes include:

missing MCP package,
syntax error,
incorrect Python version,
invalid imports,
broken virtual environment.

Common Error: Tools Do Not Appear

Check that every tool has:

@mcp.tool()

For example:

@mcp.tool()
def list_students():

Without the decorator, it is an ordinary Python function rather than an exposed MCP tool.

Common Error: Using print() with STDIO

Avoid:

print("MCP server running")

STDIO MCP servers use standard output for protocol communication.

Extra stdout text can interfere with the MCP protocol.

Use proper logging to stderr instead.

Common Error: Invalid JSON Configuration

This is valid JSON:

{
  "mcpServers": {
    "student-server": {
      "command": "uv",
      "args": [
        "--directory",
        "C:\\Users\\YourName\\student-mcp",
        "run",
        "student_server.py"
      ]
    }
  }
}

Be careful about:

missing commas,
unmatched brackets,
incorrect quotation marks,
Windows backslashes, and
invalid paths.

Project Structure

At the end of this tutorial, your project may look like:

student-mcp/
│
├── .venv/
├── pyproject.toml
├── uv.lock
└── student_server.py

The important application file is:

student_server.py

Complete Development Workflow

The complete workflow is:

Install Python

↓

Install uv

↓

Create Project

↓

Create Virtual Environment

↓

Install MCP SDK

↓

Create MCPServer

↓

Define Tools

↓

Run with STDIO

↓

Test with MCP Inspector

↓

Configure Claude Desktop

↓

Restart Claude Desktop

↓

Ask Claude Natural-Language Questions

↓

Claude Calls MCP Tools

Practice Exercise 1

Create a tool:

get_student_count

It should return the total number of students.

Expected result:

Practice Exercise 2

Create:

get_lowest_scoring_student

It should calculate each student’s average and return the lowest-performing student.

Practice Exercise 3

Create:

students_below_marks

The user should provide a threshold such as:

and the tool should return students whose average is below 75.

Practice Exercise 4

Change the student data structure so that marks are stored by subject:

"marks": {
    "Python": 85,
    "Java": 90,
    "Cloud": 88
}

Then create:

get_subject_marks

Practice Exercise 5

Create:

get_subject_topper

The user supplies:

Python

and the server returns the student with the highest Python mark.

Practice Exercise 6

Replace the in-memory list with data loaded from:

students.json

This is a useful next step toward learning MCP resources and file-based integrations.

Practice Exercise 7

After working with JSON, connect the MCP server to a database such as MySQL.

The architecture can then become:

Claude

↓

MCP Client

↓

Python MCP Server

↓

MySQL Database

This is a much more realistic application.

Frequently Asked Questions

What is an MCP server?

An MCP server is software that exposes tools, resources, prompts, or other capabilities to MCP-compatible AI applications.

Can I create an MCP server using Python?

Yes. MCP provides an official Python SDK for building MCP clients and servers.

Which Python version do I need?

Current MCP documentation requires Python 3.10 or later for its Python server quickstart.

What Python MCP SDK version should I use?

Current MCP documentation specifies the Python MCP SDK 2.0.0 or newer for its current quickstart.

What does `@mcp.tool()` do?

It exposes a Python function as an MCP tool that compatible clients can discover and invoke.

What does `MCPServer` do?

MCPServer creates and manages an MCP server instance.

Why are type hints useful?

Type hints help describe the inputs and outputs expected by tools and allow the SDK to generate structured tool definitions.

Why are docstrings important?

Tool descriptions help AI clients understand what each tool is intended to do.

What is STDIO?

STDIO means standard input and standard output. It is commonly used for local MCP servers where a client launches the server process and communicates directly with it.

Can I use print() in an STDIO MCP server?

Avoid ordinary print() calls to stdout because they can interfere with MCP’s protocol communication. Use logging to stderr instead.

What is MCP Inspector?

MCP Inspector is the official developer tool for inspecting, testing, and debugging MCP servers.

Can Claude Desktop use my Python MCP server?

Yes. Claude Desktop can launch a local MCP server through its MCP configuration.

Does an MCP server need Claude?

No. MCP is an open standard. A server can work with compatible MCP clients other than Claude.

Can an MCP server connect to MySQL?

Yes. The Python MCP server can contain ordinary database code and expose carefully controlled database functionality as MCP tools.

Is an MCP server automatically secure?

No. Developers remain responsible for authentication, authorization, validation, permissions, secrets, logging, and safe tool design.

Conclusion

Building an MCP server becomes much easier once the architecture is understood.

The essential pattern is:

Create MCPServer

↓

Write Python Function

↓

Decorate with @mcp.tool()

↓

Run MCP Server

↓

Connect MCP Client

↓

AI Discovers and Uses Tool

Our Student Information Server used only a small in-memory Python list, but the same architecture can be applied to much more powerful systems.

Instead of:

Python List

the MCP server could connect to:

MySQL
PostgreSQL
REST API
AWS
GitHub
File System
Internal Business Application

The key idea remains the same:

The MCP server exposes controlled capabilities; the AI client decides when those capabilities are useful.

Once you can build a simple server like this, you have moved from being merely an MCP user to becoming an MCP developer.

Next Post:

20 Python MCP Server MCQs with Answers (2026)

References and Further Reading

Because MCP continues to evolve, check the official Model Context Protocol documentation before building production integrations.

Recommended official resources:

Build Your First MCP Server with Python: Step-by-Step Tutorial (2026)

What Are We Going to Build?

Understanding the MCP Server

Tools

Resources

Prompts

Prerequisites

Step 1: Install uv

Installing uv on macOS or Linux

Step 2: Create the MCP Project

Step 3: Create a Virtual Environment

Step 4: Install the MCP Python SDK

Step 5: Create the Server File

Step 6: Import MCPServer

Step 7: Add Sample Student Data

Step 8: Create Our First MCP Tool

How the First Tool Works

Step 9: Create a Tool to Find One Student

Why Type Hints Matter

Step 10: Create an Average-Marks Tool

Step 11: Create a Search Tool

Step 12: Run the MCP Server

Complete MCP Server Code

Step 13: Run the Server

Important: Do Not Use print() Carelessly

Step 14: Test with MCP Inspector

Launch MCP Inspector

Inspect the Available Tools

Test calculate_average

Test students_above_marks

Step 15: Connect the Server to Claude Desktop

Find the Claude Desktop Configuration File

Step 16: Add the MCP Server Configuration

macOS/Linux Configuration

Why Is –directory Used?

Step 17: Find the Full uv Path if Necessary

Step 18: Restart Claude Desktop

Step 19: Ask Claude to Use the MCP Server

Try More Natural-Language Questions

What Is Actually Happening?

Adding Another Tool

Add a Subject-Specific Tool

Tools Should Do One Clear Job

Use Clear Docstrings

Input Validation

Read Tools vs Write Tools

Security Principles for MCP Servers

Least privilege

Validate input

Protect credentials

Restrict external access

Review destructive actions

Log important actions

Treat external content cautiously

STDIO vs HTTP MCP Servers

Common Error: Claude Cannot Find the MCP Server

Common Error: Server Immediately Stops

Common Error: Tools Do Not Appear

Common Error: Using print() with STDIO

Common Error: Invalid JSON Configuration

Project Structure

Complete Development Workflow

Practice Exercise 1

Practice Exercise 2

Practice Exercise 3

Practice Exercise 4

Practice Exercise 5

Practice Exercise 6

Practice Exercise 7

Frequently Asked Questions

What is an MCP server?

Can I create an MCP server using Python?

Which Python version do I need?

What Python MCP SDK version should I use?

What does @mcp.tool() do?

What does MCPServer do?

Why are type hints useful?

Why are docstrings important?

What is STDIO?

Can I use print() in an STDIO MCP server?

What does `@mcp.tool()` do?

What does `MCPServer` do?