Model Context Protocol (MCP) Explained: How One Standard Connected Claude, OpenAI, and Google Agents

1. The Fragmentation Crisis: Why We Needed the USB-C of Artificial Intelligence

Think back to the consumer electronics landscape of 2008. If you carried a digital camera, an external hard drive, a BlackBerry, and a portable GPS unit, you needed four proprietary charging cables, three bespoke transfer dongles, and an ungodly collection of driver disks. That is precisely where the agentic software landscape stood until early 2025. Every frontier AI vendor invented their own proprietary tool-calling schema. OpenAI had function calling schemas formatted one way; Anthropic had another; Google Vertex enforced custom OpenAPI specs; and LangChain wrapped everything in three layers of brittle Python abstractions.

If an engineering team wanted an LLM to query internal PostgreSQL schemas, read Jira issues, and push git commits, they had to write custom glue code for every IDE and CLI tool they tested. When you ask what is Model Context Protocol MCP, the simplest mental model is hardware standardization: MCP is the universal USB-C port for agentic intelligence. By decoupling the model from the execution environment, MCP creates an open ecosystem where any AI client can query any data provider over a shared, bidirectional wire format.

2. Architectural Blueprint: JSON-RPC, Resources, Tools, and Prompts

Under the hood, MCP does not rely on complex gRPC stubs or proprietary binary transports. It uses battle-tested JSON-RPC 2.0 over two transport channels: local standard input/output (stdio) for desktop and CLI workflows, and HTTP streaming with Server-Sent Events (SSE) for remote services.

The MCP specification categorizes capabilities into three distinct protocol primitives:

• Resources: Passive, read-only data streams. Think file contents, application logs, database schema definitions, or live API metrics. The agent can inspect resources without triggering mutating side effects.
• Tools: Executable functions that mutate external state. Examples include running database migrations, submitting pull requests, executing bash test suites, or sending Slack alerts. Every tool must expose a strict JSON Schema definition for input validation.
• Prompts: Reusable, parameterized context templates supplied by the server. An MCP server for Git might provide a predefined git-review-diff prompt that automatically gathers staged changes and structures the critique prompt.

// Sample MCP Server Configuration in claude_desktop_config.json or Claude Code
{
  "mcpServers": {
    "local-mysql-analyst": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "--network", "host",
        "-e", "DB_HOST=127.0.0.1",
        "-e", "DB_PORT=3306",
        "-e", "DB_USER=readonly_agent",
        "-e", "DB_PASS=vault_secret_token",
        "-e", "DB_NAME=filxtech_prod",
        "mcp/mysql-server:latest"
      ]
    },
    "github-automation": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_secure_pat_stream"
      }
    }
  }
}

3. Step-by-Step Guide: How to Build an MCP Server in TypeScript / Node.js

Building an MCP server is straightforward. Using the official @modelcontextprotocol/sdk, you can build a secure, typed server in fewer than 60 lines of code. Here is a production-ready example demonstrating how to expose database query analysis safely to an AI coding assistant:

// src/index.ts - Production MCP Server Exposing SQL Optimization Insights
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 mysql from "mysql2/promise";

const pool = mysql.createPool({
  host: process.env.DB_HOST || "127.0.0.1",
  user: process.env.DB_USER || "readonly_agent",
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME,
  connectionLimit: 5,
});

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

// Register Available Tools
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "explain_query",
      description: "Runs EXPLAIN ANALYZE on a read-only SQL query to inspect query execution plan and missing indexes.",
      inputSchema: {
        type: "object",
        properties: {
          query: { type: "string", description: "The SELECT query to analyze" },
        },
        required: ["query"],
      },
    },
  ],
}));

// Handle Tool Execution with Strict Read-Only Guardrails
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "explain_query") {
    const rawSql = String(request.params.arguments?.query).trim();
    if (!rawSql.toUpperCase().startsWith("SELECT")) {
      throw new Error("Security Violation: Only SELECT queries are permitted.");
    }

    const [rows] = await pool.query(`EXPLAIN ANALYZE ${rawSql}`);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(rows, null, 2),
        },
      ],
    };
  }
  throw new Error(`Unknown tool: ${request.params.name}`);
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}
main().catch(console.error);

Notice the safety guardrails: the server strictly enforces read-only operations before executing raw queries. The LLM never receives administrative credentials; it only receives execution plan telemetry to recommend composite index additions.

4. The Multi-Model Future: Connecting Claude Code, OpenAI Operator, and Gemini Agents

What makes MCP revolutionary is vendor interoperability. Anthropic open-sourced the protocol without proprietary licensing traps, and within months, OpenAI, Google DeepMind, and Microsoft GitHub incorporated MCP compatibility into their agent orchestration engines.

In modern engineering organizations, developers no longer switch between separate isolated chatbots. An agent operating inside Claude Code or a terminal CLI environment uses MCP to simultaneously read error traces from Sentry, cross-reference tickets in Jira, pull git history, and run test suites in a local container. By turning messy enterprise software stacks into structured JSON-RPC endpoints, MCP has established the architectural foundation for autonomous software development.