The Model Context Protocol (MCP) Production Handbook: Security, Transports & Sandboxing

[Agent Worker (Client)] ─── HTTP POST /messages ───► ┌─────────────────────────┐
                                                      │  Enterprise MCP Server  │
[Agent Worker (Client)] ◄─── HTTP GET /sse ────────── │  (SSE Stream Router)    │
                                                      └─────────────────────────┘
                                                                   │
                                                      ┌────────────┴────────────┐
                                                      ▼                         ▼
                                            ┌──────────────────┐      ┌──────────────────┐
                                            │ Postgres Gateway │      │ MicroVM Sandbox  │
                                            └──────────────────┘      └──────────────────┘

/**
 * enterprise-mcp-server.ts
 * Production-Ready Model Context Protocol Server with SSE Transport & Zod Guards
 */

import express from "express";
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ErrorCode,
  McpError,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

// ═══════════════════════════════════════════════════════════════
// 1. Tool Schemas & Security Contracts
// ═══════════════════════════════════════════════════════════════

const QueryLedgerInputSchema = z.object({
  accountId: z.string().min(5).max(32).regex(/^ACC-[A-Z0-9]+$/),
  lookbackDays: z.number().int().min(1).max(90).default(30),
  limit: z.number().int().min(1).max(100).default(25),
});

const ExecuteSandboxScriptSchema = z.object({
  language: z.enum(["python", "javascript"]),
  scriptContent: z.string().max(10000),
  timeoutMs: z.number().int().min(500).max(10000).default(3000),
});

// ═══════════════════════════════════════════════════════════════
// 2. Initialize MCP Server Instance
// ═══════════════════════════════════════════════════════════════

const server = new Server(
  {
    name: "enterprise-financial-mcp-gateway",
    version: "1.4.0",
  },
  {
    capabilities: {
      tools: {},
      resources: {},
    },
  }
);

// ═══════════════════════════════════════════════════════════════
// 3. Register Tool Discovery Handler
// ═══════════════════════════════════════════════════════════════

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "query_account_ledger",
        description: "Queries customer transaction ledgers with parameterized safety.",
        inputSchema: {
          type: "object",
          properties: {
            accountId: { type: "string", description: "Customer account identifier (e.g. ACC-4910)" },
            lookbackDays: { type: "number", description: "Number of historical days to query" },
            limit: { type: "number", description: "Maximum records to return" },
          },
          required: ["accountId"],
        },
      },
      {
        name: "execute_sandboxed_script",
        description: "Executes computational logic in an isolated microVM sandbox.",
        inputSchema: {
          type: "object",
          properties: {
            language: { type: "string", enum: ["python", "javascript"] },
            scriptContent: { type: "string", description: "Raw script string to execute" },
            timeoutMs: { type: "number", description: "Execution timeout in milliseconds" },
          },
          required: ["language", "scriptContent"],
        },
      },
    ],
  };
});

// ═══════════════════════════════════════════════════════════════
// 4. Register Tool Execution Router
// ═══════════════════════════════════════════════════════════════

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: rawArgs } = request.params;

  switch (name) {
    case "query_account_ledger": {
      const validation = QueryLedgerInputSchema.safeParse(rawArgs);
      if (!validation.success) {
        throw new McpError(ErrorCode.InvalidParams, `Schema validation failed: ${validation.error.message}`);
      }

      const { accountId, lookbackDays, limit } = validation.data;
      
      // Simulate parameterized SQL database query
      const ledgerResult = {
        accountId,
        queryLookbackDays: lookbackDays,
        recordCount: Math.min(18, limit),
        totalSettledUsd: 142050.00,
        riskAnomalyScore: 0.012,
        status: "HEALTHY",
        timestamp: new Date().toISOString(),
      };

      return {
        content: [{ type: "text", text: JSON.stringify(ledgerResult, null, 2) }],
      };
    }

    case "execute_sandboxed_script": {
      const validation = ExecuteSandboxScriptSchema.safeParse(rawArgs);
      if (!validation.success) {
        throw new McpError(ErrorCode.InvalidParams, `Sandbox parameter error: ${validation.error.message}`);
      }

      const { language, scriptContent, timeoutMs } = validation.data;

      // Sandboxed execution result simulation
      const executionResult = {
        language,
        exitCode: 0,
        stdout: "Calculation verified: Yield rate 4.82% APR confirmed across 10,000 simulations.",
        stderr: "",
        executionTimeMs: 142,
        sandboxMemoryMb: 24.5,
      };

      return {
        content: [{ type: "text", text: JSON.stringify(executionResult, null, 2) }],
      };
    }

    default:
      throw new McpError(ErrorCode.MethodNotFound, `Unregistered MCP Tool: '${name}'`);
  }
});

// ═══════════════════════════════════════════════════════════════
// 5. Express HTTP & SSE Server Transport
// ═══════════════════════════════════════════════════════════════

const app = express();
app.use(express.json());

let transport: SSEServerTransport | null = null;

// SSE Handshake endpoint
app.get("/sse", async (req, res) => {
  console.log("  📡 Inbound MCP Client connected to /sse stream");
  transport = new SSEServerTransport("/messages", res);
  await server.connect(transport);
});

// HTTP POST message endpoint
app.post("/messages", async (req, res) => {
  if (!transport) {
    res.status(400).send("No active SSE session found. Connect to /sse first.");
    return;
  }
  await transport.handlePostMessage(req, res);
});

const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`🚀 Enterprise MCP Server listening on port ${PORT}`);
});