Model Context Protocol (MCP) in Production: Building Standardized Agentic Tooling for Enterprise LLMs

Until late 2024, connecting an AI agent to developer tooling, internal databases, and third-party SaaS required writing custom function-calling wrappers for every provider. If you switched your orchestrator or added a new vector database, you had to re-implement the schemas, authentication handshakes, and error handling from scratch.

The Model Context Protocol (MCP) has emerged as the universal standard for agentic tooling. By formalizing an open, bidirectional JSON-RPC 2.0 communication protocol between MCP Hosts (IDEs, desktop agents, backend orchestrators) and MCP Servers (filesystem handlers, git connectors, database drivers, cloud controllers), MCP eliminates the brittle N × M tooling complexity.

1. The Three Primitives of MCP: Tools, Resources, and Prompts

Unlike naive REST endpoints or generic webhook bridges, the MCP specification organizes capabilities into three strictly typed primitives:

• Tools: Model-executable functions that produce side effects (e.g., executing a SQL query, creating a branch in git, provisioning an AWS S3 bucket). Tools define JSON Schemas for input validation.
• Resources: Passive contextual data streams identified by URIs (e.g., postgres://prod-db/orders/schema or file:///logs/nginx/error.log). Resources can be observed via real-time update subscriptions.
• Prompts: Reusable parameterized interaction patterns exposed by the server to guide the host LLM through complex multi-step domain workflows.

2. Building a Production Enterprise MCP Server in TypeScript

Here is a production-grade MCP server implementation using the official @modelcontextprotocol/sdk that provides isolated read-only PostgreSQL query capabilities with query plan cost enforcement:

// src/mcp/postgresServer.ts - Enterprise MCP Database Server
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 { Pool } from "pg";

const pool = new Pool({ connectionString: process.env.DATABASE_READONLY_URL });

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

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "safe_readonly_query",
      description: "Executes a SELECT SQL query against production replica with max 1000ms timeout",
      inputSchema: {
        type: "object",
        properties: {
          sql: { type: "string", description: "The SELECT query to execute" },
        },
        required: ["sql"],
      },
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "safe_readonly_query") {
    const sql = String(request.params.arguments?.sql).trim();

    // Guardrail 1: Enforce SELECT-only statements
    if (!sql.toUpperCase().startsWith("SELECT") && !sql.toUpperCase().startsWith("WITH")) {
      throw new Error("Security Violation: Only SELECT/CTE queries are authorized.");
    }

    const client = await pool.connect();
    try {
      await client.query("SET statement_timeout = 1000;"); // 1s ceiling
      const res = await client.query(sql);
      return {
        content: [{ type: "text", text: JSON.stringify(res.rows, null, 2) }],
      };
    } finally {
      client.release();
    }
  }
  throw new Error(`Unknown tool: ${request.params.name}`);
});

const transport = new StdioServerTransport();
await server.connect(transport);

3. Scaling Over SSE and Distributed Transports

While local developer workflows execute MCP servers over stdio, enterprise deployments require multi-tenant, horizontal scale across Kubernetes clusters. In this topology, MCP operates over Server-Sent Events (SSE) with JWT authorization headers and rate-limiting sidecars.

Why MCP Is the Winning Standard

Adopting MCP prevents vendor lock-in. Whether your autonomous workflows run on Claude Code, OpenAI Swarms, Google Gemini, or local DeepSeek models, your underlying tools and integrations remain completely unchanged. At Binary Froster, all internal and client-facing agent systems are architected strictly against MCP interfaces.