MCP Developer Guide: Build Servers, Connect Tools, Ship Agents (2026)

pip install mcp
# or with uv (recommended)
uv add mcp

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Inventory", json_response=True)

@mcp.tool()
def check_stock(sku: str) -> dict:
    """Check current stock level for a product SKU.
    Returns quantity available and warehouse location."""
    # In production, this queries your inventory database
    return {"sku": sku, "quantity": 42, "warehouse": "US-EAST-1"}

@mcp.tool()
def reserve_stock(sku: str, quantity: int) -> dict:
    """Reserve stock for a pending order.
    Fails if requested quantity exceeds available stock."""
    return {"sku": sku, "reserved": quantity, "confirmation": "RSV-2026-0407"}

@mcp.resource("inventory://product/{sku}")
def get_product(sku: str) -> str:
    """Get full product details including pricing and category."""
    import json
    return json.dumps({
        "sku": sku,
        "name": "Widget Pro",
        "price": 29.99,
        "category": "components"
    })

@mcp.prompt()
def inventory_check(sku: str) -> str:
    """Guide the agent through a complete inventory check workflow."""
    return (
        f"Check the current stock level for SKU {sku}. "
        f"If stock is below 10 units, flag it as low-stock. "
        f"Include the warehouse location in your response."
    )

if __name__ == "__main__":
    mcp.run(transport="streamable-http", host="127.0.0.1", port=8000)

python inventory_server.py
# or for stdio transport (local development):
# uv run mcp run inventory_server.py

npm install @modelcontextprotocol/server zod

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
import { StdioServerTransport } from "@modelcontextprotocol/server";
import * as z from "zod/v4";
import type {
  CallToolResult,
  ReadResourceResult,
} from "@modelcontextprotocol/server";

const server = new McpServer({
  name: "inventory",
  version: "1.0.0",
});

// Register a tool with typed input/output schemas
server.registerTool(
  "check-stock",
  {
    title: "Check Stock",
    description:
      "Check current stock level for a product SKU. Returns quantity and warehouse.",
    inputSchema: z.object({
      sku: z.string().describe("Product SKU to check"),
    }),
    outputSchema: z.object({
      sku: z.string(),
      quantity: z.number(),
      warehouse: z.string(),
    }),
  },
  async ({ sku }): Promise<CallToolResult> => {
    const stock = { sku, quantity: 42, warehouse: "US-EAST-1" };
    return {
      content: [{ type: "text", text: JSON.stringify(stock) }],
      structuredContent: stock,
    };
  }
);

// Register a dynamic resource with URI template
server.registerResource(
  "product",
  new ResourceTemplate("inventory://product/{sku}", {
    list: async () => ({
      resources: [
        { uri: "inventory://product/WDG-001", name: "Widget Pro" },
        { uri: "inventory://product/WDG-002", name: "Widget Lite" },
      ],
    }),
  }),
  {
    title: "Product Details",
    description: "Full product details including pricing and category",
    mimeType: "application/json",
  },
  async (uri, { sku }): Promise<ReadResourceResult> => ({
    contents: [
      {
        uri: uri.href,
        text: JSON.stringify({
          sku,
          name: "Widget Pro",
          price: 29.99,
          category: "components",
        }),
      },
    ],
  })
);

// Connect via stdio transport
const transport = new StdioServerTransport();
await server.connect(transport);

# BAD: Agent doesn't know when to use this
@mcp.tool()
def process_data(input: str) -> str:
    """Process data and return results."""
    ...

# GOOD: Agent knows exactly when and how to use this
@mcp.tool()
def search_tickets(query: str, status: str = "open") -> list[dict]:
    """Search support tickets by keyword. Returns matching tickets
    with ID, subject, status, and assignee. Use 'status' to filter
    by open, closed, or pending. Returns max 25 results sorted
    by most recent."""
    ...

@mcp.tool()
def transfer_funds(from_account: str, to_account: str, amount: float) -> dict:
    """Transfer funds between accounts. Amount must be positive
    and not exceed the source account's available balance."""
    if amount <= 0:
        return {"error": "Amount must be positive", "code": "INVALID_AMOUNT"}
    if amount > get_balance(from_account):
        return {
            "error": f"Insufficient funds. Available: ${get_balance(from_account):.2f}",
            "code": "INSUFFICIENT_FUNDS",
            "available": get_balance(from_account)
        }
    # ... execute transfer

{
  "mcpServers": {
    "inventory": {
      "command": "python",
      "args": ["./inventory_server.py"]
    }
  }
}

if __name__ == "__main__":
    mcp.run(
        transport="streamable-http",
        host="0.0.0.0",
        port=8000
    )

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server_params = StdioServerParameters(
        command="python",
        args=["inventory_server.py"]
    )

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

            # Discover available tools
            tools = await session.list_tools()
            print(f"Available tools: {[t.name for t in tools.tools]}")

            # Call a tool
            result = await session.call_tool(
                "check-stock",
                arguments={"sku": "WDG-001"}
            )
            print(result)

import { Client } from "@modelcontextprotocol/client";
import { StdioClientTransport } from "@modelcontextprotocol/client";

const transport = new StdioClientTransport({
  command: "python",
  args: ["inventory_server.py"],
});

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(
  "Available tools:",
  tools.tools.map((t) => t.name)
);

const result = await client.callTool({
  name: "check-stock",
  arguments: { sku: "WDG-001" },
});

Agent Host
├── MCP Client → CRM Server (5 tools)
├── MCP Client → Billing Server (4 tools)
├── MCP Client → Inventory Server (6 tools)
└── MCP Client → Notifications Server (3 tools)