Building Production Model Context Protocol (MCP) Gateways for AI Agents

Until recently, connecting autonomous AI agents to internal company databases, file trees, and APIs meant writing brittle custom function-calling wrappers for every model provider. Each integration had its own error format, schema structure, and authorization model.

Anthropic's Model Context Protocol (MCP) has unified this landscape. MCP establishes an open, standard protocol enabling AI applications to discover capabilities, inspect context resources, and invoke tools across isolated processes. However, exposing enterprise infrastructure directly to an LLM via MCP requires an architectural gateway to enforce strict role-based access control, schema validation, and rate limiting.

The MCP Gateway Architecture

An enterprise-ready MCP architecture introduces an intermediary Security Gateway between the LLM client and internal services:

1. Agent Host Client: Runs the model interface (e.g., Claude, local Llama 3.3, or Qwen 2.5) speaking standard JSON-RPC 2.0.
2. Gateway Multiplexer: Intercepts all MCP protocol frames over Unix domain sockets or Server-Sent Events (SSE). It injects audit metadata, validates parameters against JSON Schemas, and checks tool allowlists.
3. Domain Tool Servers: Isolated backend daemons exposing strictly bounded capabilities: PostgreSQL Reader, Kubernetes Inspector, or GitHub PR Reviewer.

Building an MCP Server in TypeScript

The official @modelcontextprotocol/sdk makes implementing tools intuitive. Below is a production server exposing a safe, read-only system telemetry tool:

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 os from 'os';

const server = new Server(
  { name: 'netbay-telemetry-mcp', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

// Register available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'get_host_telemetry',
        description: 'Returns real-time CPU, memory, and load averages for the node',
        inputSchema: {
          type: 'object',
          properties: {
            detailed: { type: 'boolean', description: 'Include per-core stats' }
          }
        }
      }
    ]
  };
});

// Handle tool execution with strict validation
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name !== 'get_host_telemetry') {
    throw new Error('Unknown tool name: ' + request.params.name);
  }

  const telemetry = {
    uptime_sec: os.uptime(),
    load_avg: os.loadavg(),
    total_mem_mb: Math.round(os.totalmem() / 1024 / 1024),
    free_mem_mb: Math.round(os.freemem() / 1024 / 1024),
    hostname: os.hostname()
  };

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

async function run() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('Netbay Telemetry MCP server initialized on stdio');
}

run().catch((err) => {
  console.error('Fatal error starting MCP:', err);
  process.exit(1);
});

Expand

Video Reference on LLM Tool Calling Protocols

Explore the mechanics of language model tool calling and JSON-RPC protocol design:

Implementing an MCP gateway gives engineering teams full control over agent access privileges, protecting sensitive data while unlocking autonomous tool workflows.

Deploy your AI agent microservices on high-performance Netbay Linux VPS instances with dedicated RAM and zero throttled CPU at netbayhosts.in.