Jeff Bruchado
Back to blog

MCP (Model Context Protocol): The Anthropic Standard Unifying AI Agents

Hello HaWkers, in 2026 we're witnessing something rare in the tech industry: competing companies adopting the same open standard. The Model Context Protocol (MCP), created by Anthropic, is being called the "USB-C of AI" and has already been adopted by OpenAI, Microsoft, and Google.

Why is this protocol so important? And how does it change the way we build applications with AI agents?

The Fragmentation Problem

Each company had its own solution.

Before MCP

How connecting AI to tools used to work:

OpenAI Function Calling:

// OpenAI-specific format
const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "Get weather for a location",
    parameters: {
      type: "object",
      properties: {
        location: { type: "string" }
      }
    }
  }
}];

Anthropic Tool Use:

// Anthropic-specific format
const tools = [{
  name: "get_weather",
  description: "Get weather for a location",
  input_schema: {
    type: "object",
    properties: {
      location: { type: "string" }
    }
  }
}];

Google Gemini Functions:

// Yet another different format
const tools = [{
  functionDeclarations: [{
    name: "get_weather",
    description: "Get weather for a location",
    parameters: {
      type: "OBJECT",
      properties: {
        location: { type: "STRING" }
      }
    }
  }]
}];

Three different formats to do the same thing. Developers needed to maintain separate code for each provider.

What is MCP

Open and universal protocol.

MCP Architecture

How it works:

┌─────────────────────────────────────────────────────────┐
│                    MCP Host (Client)                     │
│              (Claude, GPT, Gemini, etc.)                │
└────────────────────────┬────────────────────────────────┘
                         │
                    MCP Protocol
                    (JSON-RPC 2.0)
                         │
         ┌───────────────┼───────────────┐
         ▼               ▼               ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│  MCP Server  │ │  MCP Server  │ │  MCP Server  │
│   (GitHub)   │ │   (Slack)    │ │  (Database)  │
└──────────────┘ └──────────────┘ └──────────────┘

Fundamental Concepts

Three types of resources:

1. Tools:

// Actions the agent can execute
{
  "name": "create_issue",
  "description": "Create a GitHub issue",
  "inputSchema": {
    "type": "object",
    "properties": {
      "title": { "type": "string" },
      "body": { "type": "string" },
      "repo": { "type": "string" }
    },
    "required": ["title", "repo"]
  }
}

2. Resources:

// Data the agent can access
{
  "uri": "github://repos/user/project/issues",
  "name": "Project Issues",
  "mimeType": "application/json",
  "description": "List of open issues in the project"
}

3. Prompts (Templates):

// Pre-defined interaction templates
{
  "name": "code_review",
  "description": "Review code changes",
  "arguments": [
    {
      "name": "pr_url",
      "description": "Pull request URL",
      "required": true
    }
  ]
}

Implementing an MCP Server

Creating your own integration.

Basic Server

MCP Server structure:

// mcp-server.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

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

// Define available tools
server.setRequestHandler('tools/list', async () => {
  return {
    tools: [
      {
        name: 'search_database',
        description: 'Search records in the database',
        inputSchema: {
          type: 'object',
          properties: {
            query: {
              type: 'string',
              description: 'Search query'
            },
            limit: {
              type: 'number',
              description: 'Max results',
              default: 10
            }
          },
          required: ['query']
        }
      }
    ]
  };
});

// Implement tool execution
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'search_database') {
    const results = await searchDB(args.query, args.limit);
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(results, null, 2)
        }
      ]
    };
  }

  throw new Error(`Unknown tool: ${name}`);
});

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

Server with Resources

Exposing data to the agent:

// List available resources
server.setRequestHandler('resources/list', async () => {
  return {
    resources: [
      {
        uri: 'myapp://users/active',
        name: 'Active Users',
        description: 'List of currently active users',
        mimeType: 'application/json'
      },
      {
        uri: 'myapp://metrics/daily',
        name: 'Daily Metrics',
        description: 'Today\'s application metrics',
        mimeType: 'application/json'
      }
    ]
  };
});

// Read resource content
server.setRequestHandler('resources/read', async (request) => {
  const { uri } = request.params;

  if (uri === 'myapp://users/active') {
    const users = await getActiveUsers();
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(users)
        }
      ]
    };
  }

  if (uri === 'myapp://metrics/daily') {
    const metrics = await getDailyMetrics();
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(metrics)
        }
      ]
    };
  }

  throw new Error(`Resource not found: ${uri}`);
});

Popular MCP Servers

Ready-to-use integrations.

Official Servers

Available from Anthropic:

GitHub:

npx @anthropic/mcp-server-github
  • Create/edit issues and PRs
  • Search code in repository
  • Access commit history

Slack:

npx @anthropic/mcp-server-slack
  • Send messages
  • List channels
  • Search history

PostgreSQL:

npx @anthropic/mcp-server-postgres
  • Execute queries
  • List tables
  • Access schema

Filesystem:

npx @anthropic/mcp-server-filesystem
  • Read/write files
  • List directories
  • Search content

Configuration in Claude Desktop

How to connect servers:

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost/db"
      }
    },
    "custom": {
      "command": "node",
      "args": ["/path/to/my-mcp-server.js"]
    }
  }
}

Industry Adoption

Who is using MCP.

OpenAI and Microsoft

Official announcement in January 2026:

  • OpenAI adopted MCP for GPT-4 and GPT-5
  • Microsoft integrated into Copilot
  • Azure AI Services supports MCP natively

Immediate benefits:

  • Developers write one integration, works on all models
  • Shared ecosystem of MCP servers
  • 70% reduction in integration code

Google

Gradual implementation:

  • Gemini Pro supports MCP since December 2025
  • Google Cloud offers managed MCP servers
  • Vertex AI has native support

Open Source Community

Explosive growth:

GitHub Statistics (January 2026):

  • 500+ public MCP servers
  • 12k+ stars on main repository
  • 200+ active contributors

Popular community servers:

  • Notion MCP Server
  • Jira MCP Server
  • AWS MCP Server
  • Linear MCP Server
  • Figma MCP Server

Advanced Use Cases

Practical MCP applications.

DevOps Agent

Automated workflow:

// The agent can use multiple MCP servers
// to create a complete workflow

// 1. Receives alert from PagerDuty (MCP Server)
// 2. Searches logs in DataDog (MCP Server)
// 3. Identifies the problem
// 4. Creates issue on GitHub (MCP Server)
// 5. Notifies on Slack (MCP Server)
// 6. Suggests fix and opens PR (MCP Server)

// User prompt:
// "Investigate the high latency alert and create
// an issue with your analysis"

// The agent automatically:
// - Queries metrics
// - Analyzes logs
// - Correlates events
// - Documents findings
// - Notifies team

Data Analysis Agent

Access to multiple sources:

// Connected MCP servers:
// - PostgreSQL (transactional data)
// - BigQuery (analytical data)
// - Notion (documentation)
// - Slack (business context)

// Prompt: "Analyze last quarter sales
// and compare with goals defined in Notion"

// The agent:
// 1. Fetches goals from Notion
// 2. Queries sales from PostgreSQL
// 3. Aggregations in BigQuery
// 4. Generates report
// 5. Posts summary on Slack

Security and Best Practices

How to implement securely.

Access Control

Limiting permissions:

// Define permission scope
const server = new Server({
  name: 'secure-mcp-server',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {
      // Read-only tools
      allowedOperations: ['read', 'search']
    },
    resources: {
      // Specific resources
      allowedPatterns: ['myapp://public/*']
    },
  },
});

// Validate inputs
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  // Sanitize inputs
  const sanitizedArgs = sanitize(args);

  // Check rate limits
  await checkRateLimit(request.context.clientId);

  // Audit log
  await logAccess({
    tool: name,
    args: sanitizedArgs,
    client: request.context.clientId,
    timestamp: new Date()
  });

  return executeTool(name, sanitizedArgs);
});

The Model Context Protocol represents a fundamental shift in how we build AI applications. For the first time, we have an open standard adopted by all major players. This reduces fragmentation, accelerates development, and creates a robust ecosystem of integrations.

If you want to learn more about AI agents in practice, I recommend checking out another article: n8n and AI Agent Workflows where you'll discover how to create intelligent automations without code.

Let's go! 🦅

🎯 Join Developers Who Are Evolving

Thousands of developers already use our material to accelerate their studies and achieve better positions in the market.

Why invest in structured knowledge?

Learning in an organized way with practical examples makes all the difference in your journey as a developer.

Start now:

  • 1x of $4.90 on card
  • or $4.90 at sight

🚀 Access Complete Guide

"Excellent material for those who want to go deeper!" - John, Developer

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments