# Using stdio transport (default)
python server.py

Using SSE transport
mcp run server.py --transport sse

Using streamable HTTP transport
mcp run server.py --transport streamable-http

from mcp.server.fastmcp import FastMCP
from typing import Optional
import json

mcp = FastMCP("Advanced Tools Server")

@mcp.tool()
def searchproducts(
    query: str,
    category: Optional[str] = None,
    minprice: Optional[float] = None,

    maxprice: Optional[float] = None,
    limit: int = 10
) -> str:
    """Search products by query and filters.

    Args:
        query: Search keywords
        category: Product category (optional)
        minprice: Minimum price (optional)

        maxprice: Maximum price (optional)
        limit: Maximum number of results (default: 10)
    """
    results = {
        "query": query,
        "filters": {
            "category": category,
            "minprice": minprice,
            "maxprice": maxprice
        },
        "limit": limit,
        "results": [
            {"name": "Product A", "price": 29.99, "category": "electronics"},
            {"name": "Product B", "price": 49.99, "category": "fashion"}
        ]
    }
    return json.dumps(results, indent=2)

@mcp.tool()
def createinvoice(

    customername: str,
    items: list[dict],
    taxrate: float = 0.10

) -> str:
    """Create a new invoice.

    Args:
        customername: Customer name
        items: List of items [{name, quantity, price}]
        taxrate: Tax rate (default 10%)

    """
    subtotal = sum(item["price"]  item["quantity"] for item in items)
    tax = subtotal  taxrate
    total = subtotal + tax

    invoice = {
        "customer": customername,

        "items": items,
        "subtotal": subtotal,
        "tax": tax,
        "total": total
    }
    return json.dumps(invoice, indent=2)

# client.py
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdioclient

async def main():
    # Configure connection to server
    serverparams = StdioServerParameters(

        command="python",
        args=["server.py"],
        env=None
    )

    async with stdioclient(serverparams) as (read, write):

        async with ClientSession(read, write) as session:
            # Initialize connection
            await session.initialize()

            # List all available tools
            tools = await session.listtools()
            print("Available tools:")
            for tool in tools.tools:
                print(f"  - {tool.name}: {tool.description}")

            # List all resources
            resources = await session.listresources()

            print("\nAvailable resources:")
            for resource in resources.resources:
                print(f"  - {resource.uri}: {resource.name}")

            # Call a tool
            result = await session.calltool(
                "calculatebmi",

                arguments={"weightkg": 70, "heightm": 1.75}

            )
            print(f"\nBMI Result: {result.content[0].text}")

            # Read a resource
            resourcecontent = await session.readresource("config://app")

            print(f"\nConfig: {resourcecontent.contents[0].text}")

if name == "main":
    asyncio.run(main())

Transport Types

MCP supports several transport types for communication between client and server:

1. Stdio (Standard Input/Output)

The simplest default transport. The client runs the server as a subprocess and communicates through stdin/stdout.

# Client using stdio
serverparams = StdioServerParameters(

    command="python",
    args=["server.py"]
)

# Server with SSE transport
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("SSE Server")

Run with SSE
mcp run server.py --transport sse --port 8080

# Client using SSE
from mcp.client.sse import sseclient

async with sseclient("http://localhost:8080/sse") as (read, write):

    async with ClientSession(read, write) as session:
        await session.initialize()

# Server with streamable HTTP
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("HTTP Server", statelesshttp=True)

Run with streamable HTTP
mcp run server.py --transport streamable-http --port 8080

Integration with Claude Desktop

To use an MCP server with Claude Desktop, edit the configuration file:

{
  "mcpServers": {
    "demo-server": {
      "command": "python",
      "args": ["/path/to/server.py"],
      "env": {
        "DATABASEURL": "postgresql://user:pass@localhost/mydb"

      }
    },
    "another-server": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/documents"]
    }
  }
}

# Add MCP server to project scope
claude mcp add db-server -s project -- python /path/to/dbserver.py

Add with environment variables
claude mcp add db-server -s project \
  -e DATABASEURL=postgresql://user:pass@localhost/mydb \

  -- python /path/to/dbserver.py

Add remote SSE/HTTP server
claude mcp add remote-server -s user --transport http \
  http://api.example.com/mcp

List all MCP servers
claude mcp list

Remove an MCP server
claude mcp remove db-server

Configuration is stored in the .mcp.json file at the project root:

{
  "mcpServers": {
    "db-server": {
      "command": "python",
      "args": ["/path/to/dbserver.py"],

      "env": {
        "DATABASEURL": "postgresql://user:pass@localhost/mydb"
      }
    }
  }
}

Testing with MCP Inspector

MCP Inspector is a visual tool for testing and debugging MCP servers:

# Run Inspector
npx @modelcontextprotocol/inspector

Inspector will open browser at http://localhost:6274

With Inspector, you can:

• View all resources, tools, and prompts exposed by the server
• Call tools with custom parameters
• Read resources
• Inspect server responses in real-time
• Debug connection issues

You can also run Inspector directly with a server:

# Directly test a specific server
npx @modelcontextprotocol/inspector python server.py

Test server with environment variables
DATABASEURL=postgresql://localhost/mydb \

  npx @modelcontextprotocol/inspector python server.py

import re

@mcp.tool()
def querydata(tablename: str, limit: int = 10) -> str:

    """Query data from a specific table."""
    # Validate table name - only alphanumeric and underscores
    if not re.match(r'^[a-zA-Z][a-zA-Z0-9]