MCP in Production: Zero-Trust Tool Meshes for AI Agents

┌─────────────────────────────────────────────────────────────────────────────┐
│                       MCP DISTRIBUTED TOOL PROTOCOL                         │
├─────────────────────────────────────────────────────────────────────────────┤
│  AI Clients (Claude Code, Antigravity, Cursor, Grok Build, OpenCode)        │
│       │                                                                     │
│       ▼ (Standard JSON-RPC 2.0 via Stdio or Server-Sent Events SSE)         │
│  [MCP Security & Rate-Limiting Gateway]                                     │
│       │                                                                     │
│       ├──► [Database MCP Server: PostgreSQL / BigQuery / Supabase]          │
│       ├──► [Filesystem MCP Server: Workspace Sandbox & Git Hub]             │
│       ├──► [Cloud Ops MCP Server: Vercel / AWS / Kubernetes]                │
│       └──► [Memory MCP Server: Graphiti Temporal Knowledge Vault]           │
└─────────────────────────────────────────────────────────────────────────────┘

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 { z } from 'zod'

const server = new Server(
  { name: 'enterprise-db-gateway', version: '1.0.0' },
  { capabilities: { tools: {}, resources: {} } }
)

const QueryInputSchema = z.object({
  query: z.string().max(1000),
  readOnly: z.boolean().default(true),
})

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'execute_safe_query',
      description: 'Execute a read-only SQL query against the read-replica database.',
      inputSchema: {
        type: 'object',
        properties: {
          query: { type: 'string', description: 'SQL SELECT query string' },
          readOnly: { type: 'boolean', default: true },
        },
        required: ['query'],
      },
    },
  ],
}))

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === 'execute_safe_query') {
    const { query } = QueryInputSchema.parse(request.params.arguments)
    // Execute query securely with parameterized protection
    return { content: [{ type: 'text', text: JSON.stringify({ status: 'success', rows: [] }) }] }
  }
  throw new Error(`Tool not found: ${request.params.name}`)
})

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