MCP Servers: How to Build and Sell Model Context Protocol Tools in 2026

User: "What were our top 5 revenue-generating users last month?"
→ You open Postgres, run the query, copy results, paste into Claude

User: "What were our top 5 revenue-generating users last month?"
→ Claude calls your database MCP server's query_users tool directly
→ Answer appears in seconds

node -v  # 18+
npm install @modelcontextprotocol/sdk pg zod

postgres-mcp/
├── src/
│   ├── index.ts          # Entry point
│   ├── tools/
│   │   ├── query.ts      # Read queries
│   │   └── schema.ts     # Schema inspection
│   └── connection.ts     # DB connection pool
├── package.json
└── tsconfig.json

// src/connection.ts
import { Pool } from "pg";

let pool: Pool | null = null;

export function getPool(): Pool {
  if (!pool) {
    pool = new Pool({
      connectionString: process.env.DATABASE_URL,
      max: 10,
      idleTimeoutMillis: 30000,
      connectionTimeoutMillis: 2000,
    });
  }
  return pool;
}

export async function closePool(): Promise<void> {
  if (pool) {
    await pool.end();
    pool = null;
  }
}

// src/tools/query.ts
import { z } from "zod";
import { getPool } from "../connection";

export const QueryInput = z.object({
  sql: z.string().describe("SQL SELECT query to execute"),
  limit: z
    .number()
    .int()
    .min(1)
    .max(1000)
    .default(100)
    .describe("Max rows to return"),
});

export async function executeQuery(
  input: z.infer<typeof QueryInput>
): Promise<string> {
  // Security: only allow SELECT statements
  const normalized = input.sql.trim().toUpperCase();
  if (!normalized.startsWith("SELECT") && !normalized.startsWith("WITH")) {
    throw new Error("Only SELECT queries are allowed");
  }

  const pool = getPool();
  const limitedSql = `${input.sql.trim().replace(/;\s*$/, "")} LIMIT ${input.limit}`;

  const result = await pool.query(limitedSql);

  if (result.rows.length === 0) {
    return "Query returned no results.";
  }

  // Format as a readable table
  const headers = Object.keys(result.rows[0]);
  const rows = result.rows.map((row) =>
    headers.map((h) => String(row[h] ?? "NULL")).join(" | ")
  );

  return [
    `Rows: ${result.rows.length}`,
    headers.join(" | "),
    headers.map(() => "---").join(" | "),
    ...rows,
  ].join("\n");
}

// src/index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { executeQuery, QueryInput } from "./tools/query";
import { closePool } from "./connection";

const server = new Server(
  { name: "postgres-mcp", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "query_database",
      description:
        "Execute a read-only SQL SELECT query against the PostgreSQL database. " +
        "Returns results as a formatted table. Use this to look up user data, " +
        "analyze metrics, check order history, or explore any data in the database.",
      inputSchema: {
        type: "object",
        properties: {
          sql: {
            type: "string",
            description: "SQL SELECT query to execute",
          },
          limit: {
            type: "number",
            description: "Maximum rows to return (1–1000, default 100)",
          },
        },
        required: ["sql"],
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "query_database") {
    try {
      const input = QueryInput.parse(request.params.arguments);
      const result = await executeQuery(input);
      return { content: [{ type: "text", text: result }] };
    } catch (err) {
      const message = err instanceof Error ? err.message : "Unknown error";
      return {
        content: [{ type: "text", text: `Error: ${message}` }],
        isError: true,
      };
    }
  }

  return {
    content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
    isError: true,
  };
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Postgres MCP server running");
}

main().catch((err) => {
  console.error("Fatal error:", err);
  closePool();
  process.exit(1);
});

{
  "mcpServers": {
    "postgres": {
      "command": "node",
      "args": ["/path/to/postgres-mcp/dist/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@localhost:5432/mydb"
      }
    }
  }
}

// Bad
description: "Gets user data"

// Good
description:
  "Retrieve detailed information about a specific user including their " +
  "account status, subscription plan, payment history, and last login. " +
  "Use when you need to investigate a specific customer or verify their current state."

{
  "name": "postgres-mcp",
  "version": "1.0.0",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "ts-node src/index.ts"
  },
  "files": ["dist/", "README.md", "claude_desktop_config.example.json"]
}

# 1. Scaffold with Claude Code
mkdir stripe-mcp && cd stripe-mcp
claude

# Prompt:
# "Build a TypeScript MCP server for Stripe. Include tools for:
# - Querying recent charges and revenue
# - Looking up customer subscriptions
# - Creating payment links
# - Retrieving invoice history
# Use the @modelcontextprotocol/sdk and stripe npm packages.
# Add proper error handling and Zod validation."