Model Context Protocol (MCP): The Universal Standard for Connecting AI to Data & Tools

Overview #

Model Context Protocol (MCP) is an open, standardized protocol developed by Anthropic that establishes a universal client-server interface for LLMs to securely query databases, inspect local file trees, and execute tools without vendor lock-in.

The N x M Integration Problem in AI Development #

Previously, every AI tool or agent framework required bespoke integration code for every data source (Postgres, GitHub, Slack, Google Drive, Linear). Connecting 10 LLM tools to 20 databases required writing and maintaining 200 custom connectors. MCP standardizes this architecture into a clean client-server model: an MCP server exposes capabilities (resources, tools, prompts) over JSON-RPC 2.0 (via stdio or SSE), and any MCP-compliant client can instantly interact with it.

Core Primitives: Resources, Prompts, and Tools #

• Resources: File-like data streams that clients can read (e.g. database schemas, server log files, documentation pages).
• Prompts: Pre-defined prompt templates and workflows that servers expose for standardized execution.
• Tools: Functions with JSON schema parameters that the model can invoke to perform side-effects (e.g. running an SQL query, creating a Git commit, or triggering a CI pipeline).

Security Isolation and Principle of Least Privilege #

Because MCP servers run as isolated processes outside the model's core context, developers can enforce strict permission boundaries (read-only file access, scoped API tokens, human-in-the-loop approval dialogs before write operations) preventing unauthorized agentic actions.

Code Example: Building a Simple MCP Server in TypeScript #

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

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

// 1. Expose Available Tools
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "query_database",
      description: "Run a read-only SQL query against customer DB",
      inputSchema: {
        type: "object",
        properties: { sql: { type: "string" } },
        required: ["sql"],
      },
    },
  ],
}));

// 2. Handle Tool Execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "query_database") {
    const sql = String(request.params.arguments?.sql);
    // Execute safe query...
    return { content: [{ type: "text", text: JSON.stringify([{ id: 1, name: "Acme Corp" }]) }] };
  }
  throw new Error("Tool not found");
});

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

Frequently Asked Questions #

Q: Is MCP tied to Anthropic Claude or can other LLMs use it?

MCP is fully open-source and model-agnostic. Any model (including GPT-4o, DeepSeek-R1, and Llama 3) can connect to MCP servers via standard gateways or agent harnesses.

Q: What transports does MCP support?

MCP currently supports standard input/output (stdio) for local CLI processes and Server-Sent Events (SSE) over HTTP for remote network servers.

Q: How does MCP differ from standard function calling?

Function calling is an API parameter format for returning tool requests. MCP is a complete bidirectional protocol that handles tool discovery, capability negotiation, dynamic resource reading, and state management.