Dev Note

Introduction
Every LLM integration used to be a snowflake. You’d write custom code to connect your AI assistant to your database, your APIs, your file system, your calendar. Each integration required a different approach, different auth patterns, different data formats.
Then Anthropic released the Model Context Protocol (MCP) in late 2024 — and by 2026, it has quietly become the standard that every major AI provider and developer tool has adopted.
MCP is to AI what USB-C is to devices: a universal connector that eliminates the combinatorial explosion of custom integrations. This post is a practical guide to understanding, building, and deploying MCP in production.
Photo by DeepMind on Unsplash
What is MCP?
MCP is an open protocol that standardizes how AI models communicate with external data sources and tools. Instead of each AI application needing to write custom integrations, MCP defines a common interface:
AI Model (Claude, GPT, Gemini...)
        ↓ MCP Protocol
MCP Host (Claude Desktop, IDE, custom app)
        ↓ 
MCP Servers (databases, APIs, files, services)
The key insight: MCP separates “how to connect” from “what to connect to.” An MCP server written for Claude Desktop works identically with VS Code’s AI, Cursor, Windsurf, or any other MCP-compatible host.
Core Primitives
MCP servers expose three types of capabilities:
1. Resources — Data the model can read
mcp://filesystem/home/user/documents/report.pdf
mcp://database/customers/id/12345
mcp://github/repo/issues/456
2. Tools — Actions the model can take
{
  "name": "query_database",
  "description": "Execute a SQL query against the production database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "database": { "type": "string", "enum": ["production", "analytics"] }
    },
    "required": ["query"]
  }
}
3. Prompts — Reusable templates
{
  "name": "analyze_performance",
  "description": "Analyze query performance with execution plan",
  "arguments": [
    { "name": "query", "description": "SQL query to analyze", "required": true }
  ]
}
The MCP Ecosystem in 2026
The ecosystem has exploded. As of early 2026:
Official servers: Anthropic maintains 20+ reference servers (filesystem, GitHub, Google Drive, Slack, PostgreSQL, etc.)
Community servers: 2,000+ servers on the MCP registry
Hosts: Claude Desktop, VS Code (via Cline/Continue), Cursor, Windsurf, JetBrains AI, Zed, custom apps
SDKs: Python, TypeScript, Rust, Java, Go, C#
Major companies with MCP servers: Stripe, Cloudflare, Brave, GitHub, Linear, Notion, Sentry, Datadog.
Building Your First MCP Server
Let’s build a practical MCP server — a tool that gives AI assistants access to your application’s internal metrics:
TypeScript Implementation
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
// Initialize MCP server
const server = new Server(
  { name: "metrics-server", version: "1.0.0" },
  { capabilities: { tools: {}, resources: {} } }
);
// Define available tools
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "get_error_rate",
      description: "Get the error rate for a service in the last N minutes",
      inputSchema: {
        type: "object",
        properties: {
          service: {
            type: "string",
            description: "Service name (e.g., api, worker, frontend)"
          },
          minutes: {
            type: "number",
            description: "Time window in minutes (default: 60)",
            default: 60
          }
        },
        required: ["service"]
      }
    },
    {
      name: "get_active_incidents",
      description: "List all currently active incidents",
      inputSchema: {
        type: "object",
        properties: {
          severity: {
            type: "string",
            enum: ["critical", "high", "medium", "low", "all"],
            default: "all"
          }
        }
      }
    },
    {
      name: "create_incident",
      description: "Create a new incident in PagerDuty",
      inputSchema: {
        type: "object",
        properties: {
          title: { type: "string" },
          service: { type: "string" },
          severity: {
            type: "string",
            enum: ["critical", "high", "medium", "low"]
          },
          description: { type: "string" }
        },
        required: ["title", "service", "severity"]
      }
    }
  ]
}));
// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  switch (name) {
    case "get_error_rate": {
      const errorRate = await fetchErrorRate(
        args.service as string,
        (args.minutes as number) ?? 60
      );
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({
              service: args.service,
              timeWindow: `${args.minutes ?? 60} minutes`,
              errorRate: `${errorRate.toFixed(2)}%`,
              threshold: "1.0%",
              status: errorRate > 1.0 ? "ALERT" : "OK"
            }, null, 2)
          }
        ]
      };
    }
    case "get_active_incidents": {
      const incidents = await fetchActiveIncidents(
        args.severity as string ?? "all"
      );
      return {
        content: [
          {
            type: "text",
            text: incidents.length === 0
              ? "No active incidents."
              : `Found ${incidents.length} active incidents:\n\n${
                  incidents.map(inc =>
                    `• [${inc.severity.toUpperCase()}] ${inc.title} (${inc.service})\n  Started: ${inc.createdAt}\n  ID: ${inc.id}`
                  ).join("\n\n")
                }`
          }
        ]
      };
    }
    case "create_incident": {
      const incident = await createPagerDutyIncident({
        title: args.title as string,
        service: args.service as string,
        severity: args.severity as string,
        description: args.description as string
      });
      return {
        content: [
          {
            type: "text",
            text: `✅ Incident created: ${incident.id}\nTitle: ${incident.title}\nURL: ${incident.url}`
          }
        ]
      };
    }
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});
// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);
Photo by Taylor Vick on Unsplash
Python Implementation
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types
import httpx
import asyncio
server = Server("metrics-server")
@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="query_logs",
            description="Search application logs with a query string",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Lucene query string"
                    },
                    "time_range": {
                        "type": "string",
                        "description": "Time range (e.g., '1h', '24h', '7d')",
                        "default": "1h"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Max results to return",
                        "default": 100
                    }
                },
                "required": ["query"]
            }
        )
    ]
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "query_logs":
        async with httpx.AsyncClient() as client:
            response = await client.post(
                "https://your-logging-api.internal/search",
                json={
                    "query": arguments["query"],
                    "timeRange": arguments.get("time_range", "1h"),
                    "limit": arguments.get("limit", 100)
                },
                headers={"Authorization": f"Bearer {os.environ['LOG_API_TOKEN']}"}
            )
            results = response.json()
            
        return [types.TextContent(
            type="text",
            text=f"Found {results['total']} log entries.\n\n" +
                 "\n".join(f"[{e['timestamp']}] {e['level']}: {e['message']}"
                          for e in results['entries'])
        )]
    
    raise ValueError(f"Unknown tool: {name}")
async def main():
    async with stdio_server() as streams:
        await server.run(*streams, server.create_initialization_options())
asyncio.run(main())
Configuring MCP Clients
Claude Desktop
// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "metrics": {
      "command": "node",
      "args": ["/path/to/metrics-server/dist/index.js"],
      "env": {
        "METRICS_API_URL": "https://metrics.internal",
        "API_TOKEN": "your-token"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    }
  }
}
Programmatic MCP Client
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
// Connect to an MCP server
const transport = new StdioClientTransport({
  command: "node",
  args: ["./metrics-server/dist/index.js"]
});
const client = new Client(
  { name: "my-app", version: "1.0.0" },
  { capabilities: {} }
);
await client.connect(transport);
// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map(t => t.name));
// Call a tool
const result = await client.callTool({
  name: "get_error_rate",
  arguments: { service: "api", minutes: 30 }
});
console.log(result.content[0].text);
await client.close();
MCP Security Best Practices
MCP servers have real power — they can read files, query databases, make API calls. Security isn’t optional:
1. Principle of Least Privilege
// Bad: expose all database access
tools: [{ name: "execute_sql", description: "Run any SQL query..." }]
// Good: expose specific, scoped operations  
tools: [
  { name: "get_user", description: "Look up a user by ID (read-only)" },
  { name: "list_orders", description: "Get orders for a customer (last 90 days)" }
]
2. Input Validation
case "get_user": {
  const userId = args.user_id as string;
  
  // Validate input
  if (!/^\d+$/.test(userId)) {
    throw new Error("Invalid user_id: must be numeric");
  }
  
  // Use parameterized queries — never interpolate user input
  const user = await db.query(
    "SELECT id, name, email FROM users WHERE id = $1",
    [parseInt(userId)]
  );
  
  return { content: [{ type: "text", text: JSON.stringify(user) }] };
}
3. Audit Logging
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  
  // Log every tool call
  await auditLog.write({
    timestamp: new Date().toISOString(),
    tool: name,
    arguments: args,
    sessionId: request.params._meta?.sessionId
  });
  
  // ... handle tool
});
Production Deployment Patterns
Remote MCP Servers (HTTP Transport)
The stdio transport works for local servers. For shared team infrastructure, use HTTP:
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import express from "express";
const app = express();
app.use(express.json());
app.post('/mcp', async (req, res) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: () => crypto.randomUUID()
  });
  
  await server.connect(transport);
  await transport.handleRequest(req, res, req.body);
});
app.listen(3000);
Clients connect via:
{
  "mcpServers": {
    "company-tools": {
      "url": "https://mcp.internal.company.com/mcp",
      "headers": {
        "Authorization": "Bearer ${MCP_TOKEN}"
      }
    }
  }
}
Why MCP Matters for the Industry
Before MCP, every AI product had to build and maintain integrations with every service their users might want. The integration matrix (N AI tools × M data sources) was expensive and fragmented.
MCP collapses this to N + M: each AI tool implements MCP once, each data source implements MCP once, and everything works together.
This is why the adoption has been remarkable:
OpenAI adopted MCP in their API and desktop products
Microsoft integrated it into Copilot and VS Code
Google announced MCP support in Gemini
JetBrains, Zed, Replit, Sourcegraph all integrated it
The bet that an open protocol would create more value than proprietary lock-in appears to have been correct.
Conclusion
MCP has become the connective tissue of AI-augmented development in 2026. If you’re building tools that AI should be able to use, implementing an MCP server is now table stakes. If you’re building AI applications, consuming MCP servers gives you instant access to a growing ecosystem of integrations.
The protocol is simple, the SDKs are mature, and the ecosystem is rich. There’s no better time to start building.
Resources
MCP Official Documentation
MCP GitHub Repository
MCP Server Registry
Awesome MCP Servers
MCP TypeScript SDK

Model Context Protocol (MCP): The Standard That's Connecting AI to Everything

댓글