MakingMCP

MCP

Intent Surfaces™

A reference manual for people who design and build MCP (Model Context Protocol) ecosystems

MCP

Intent Surfaces™

A reference manual for people who design and build MCP (Model Context Protocol) ecosystems

MCP

Intent Surfaces™

A reference manual for people who design and build MCP (Model Context Protocol) ecosystems

Enter the Universal Translator

A protocol is born • What if AI connections worked like USB-C? • The moment Anthropic said "enough is enough"

The Napkin Sketch That Changed Everything

November 2024. A conference room at Anthropic. A team member draws a simple line on the whiteboard:

AI <---[MCP]---> Everything Else

"What if we just made one protocol for everything?"

It's the kind of simple idea that only seems obvious after someone says it out loud. Like USB-C—one port that handles charging, data, video, everything. Why couldn't AI connections work the same way?

"What if we just made one protocol for everything?"

The Rosetta Stone Moment

“The Model Context Protocol - or MCP - is like the Rosetta Stone of the AI world. Just as that ancient artifact unlocked communication between civilizations by providing a universal key to different languages, MCP creates a single, universal way for AI to understand and work with every tool in your organization. Think about it: Your finance team speaks in CAGR, earnings calls, and price-per-share. Your engineers talk about grep commands and git blame. Your sales team lives in CRM records and pipeline stages. These aren’t just different tools - they’re entirely different languages.”

The Rosetta Stone Moment

The Power of Universal Translation

MCP acts as a universal translator that gives AI three superpowers: First, it translates domain languages into prompts AI can understand. When your CFO asks about quarterly performance, MCP helps AI understand that ‘burn rate’ isn’t about fire.

Second, it provides resources - the right documents, databases, and context. Like giving AI a perfectly curated library card to your company’s knowledge.

Third, it enables actions. Not just understanding your tools, but actually using them. Imagine AI that doesn’t just read your CRM - it updates it. Doesn’t just analyze code - it commits fixes.

The Power of Universal Translation

Second, it provides resources - the right documents, databases, and context. Like giving AI a perfectly curated library card to your company’s knowledge.

Third, it enables actions. Not just understanding your tools, but actually using them. Imagine AI that doesn’t just read your CRM - it updates it. Doesn’t just analyze code - it commits fixes.

The Power of Universal Translation

Second, it provides resources - the right documents, databases, and context. Like giving AI a perfectly curated library card to your company’s knowledge.

Third, it enables actions. Not just understanding your tools, but actually using them. Imagine AI that doesn’t just read your CRM - it updates it. Doesn’t just analyze code - it commits fixes.

Three types of things flow through MCP:

Resources

Things you can read (files, database records, API responses)

Tools

Actions you can take (send email, update record, execute code)

Prompt

Templates for common workflows

How MCP Actually Works

MCP speaks JSON-RPC 2.0, a protocol that's been battle-tested for over a decade. Here's what an actual MCP conversation looks like:

Initialize Connection

1
2
3
4
5
6
7
8
9
10
11
12
13
//initialize connection
{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "1.0",
    "capabilities": {
      "tools": true,
      "resources": true
    }
  },
  "id": 1
}

capabilities

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Acknowledge and share capabilities
{
  "jsonrpc": "2.0",
  "result": {
    "protocolVersion": "1.0",
    "capabilities": {
      "tools": [{
        "name": "read_file",
        "description": "Read contents of a file"
      }],
      "resources": [{
        "uri": "file:///workspace",
        "mimeType": "text/directory"
      }]
    }
  },
  "id": 1
}

error

error

error

2.1 Message Flow Visualizer

The Architecture

MCP has three components that work together:

2.2 Architecture Explorer

Real Code Comparison

Connecting to Slack looked like before MCP:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Before: Custom Slack integration (~200 lines total)
import { WebClient } from '@slack/web-api';

const client = new WebClient(process.env.SLACK_TOKEN);

async function getMessages(channel) {
  try {
    const result = await client.conversations.history({
      channel: channel,
      limit: 100,
      include_all_metadata: true
    });
    if (!result.ok) {
      throw new Error(`Slack API error: ${result.error}`);
    }
    return result.messages.map(msg => ({
      text: msg.text,
      user: msg.user,
      timestamp: msg.ts,
      // ... more mapping logic
    }));
  } catch (error) {
    console.error('Failed to fetch messages:', error);
    // ... retry logic, error handling, rate limiting
  }
}

And here's the same thing with MCP:

1
2
3
4
5
//After: MCP connection (~10 lines total
const server = await client.connectToServer('slack');
const messages = await server.callTool('get_messages', {
  channel: 'general'
});

>_before mcp

import { WebClient } from '@slack/web-api';

const client = new WebClient(process.env.SLACK_TOKEN);

async function getMessages(channel) {

try {

const result = await client.conversations.history({

channel: channel,

limit: 100,

include_all_metadata: true

});

before mcp

~200 Lines

2.3 Before MCP

The Open Source Decision

On December 4, 2024, Anthropic released MCP with this license:

MIT License

Permission is hereby granted, free of charge, to any person...

MIT License

Permission is hereby granted, free of charge, to any person...

MIT License

Permission is hereby granted, free of charge, to any person...

Not a "source available" license. Not a "free for non-commercial use" license. MIT—the same license that powers React, Node.js, and countless other foundational technologies.

Within 48 hours:

- 50+ GitHub stars

- First community PR merged

- Working Python SDK

- TypeScript implementation started

Within 48 hours:

- 50+ GitHub stars

- First community PR merged

- Working Python SDK

- TypeScript implementation started

Within 48 hours:

- 50+ GitHub stars

- First community PR merged

- Working Python SDK

- TypeScript implementation started

By week two:

- 1,000+ stars

- Slack server implemented

- GitHub server working

- First production deployments

By week two:

- 1,000+ stars

- Slack server implemented

- GitHub server working

- First production deployments

By week two:

- 1,000+ stars

- Slack server implemented

- GitHub server working

- First production deployments

Click to animate

Click to animate

Click to animate

Click to animate

Click to animate

Click to animate

Click to animate

Click to animate

Click to animate

2.4 Adoption Timeline

Security Model

MCP specification expects every connection to require explicit consent:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Server declares what it can do
{
  "tools": [{
    "name": "send_email",
    "description": "Send an email on your behalf",
    "inputSchema": {
      "type": "object",
      "properties": {
        "to": { "type": "string" },
        "subject": { "type": "string" },
        "body": { "type": "string" }
      }
    }
  }]
}

// Client must explicitly approve
{
  "method": "tools/approve",
  "params": {
    "tool": "send_email",
    "permissions": {
      "allowedDomains": ["@mycompany.com"],
      "requireConfirmation": true
    }
  }
}

No silent permissions. No invisible access. Every capability must be declared, approved, and auditable.

2.5 Security Flow Diagram

First Production Deployments

By January 2025, MCP wasn't just a neat idea—it was handling real traffic:

Block (Square/Cash App)

1
2
3
4
5
6
# Internal tool connecting to transaction data
mcp_server = TransactionServer(
    auth=BlockAuth(),
    allowed_operations=['read', 'aggregate']
)
# Result: 90% reduction in integration code

Replit

1
2
3
4
// AI can now understand your full project context
const context = await mcp.getResource('project://current');
const deps = await mcp.callTool('analyze_dependencies');
// Result: AI suggestions based on actual code structure

Individual Developers

1
2
3
4
5
6
7
// Personal productivity setup
const servers = [
  'obsidian://notes',
  'github://personal',
  'calendar://google'
];
// Result: AI assistant that actually knows your life

2.6 Production Traffic Visualizer

The JSON-RPC Transport

MCP uses JSON-RPC over two transport mechanisms:

Standard I/O (stdio)

1
2
3
4
5
# Server announces via stdout
{"jsonrpc":"2.0","method":"initialized","params":{}}

# Client sends via stdin
{"jsonrpc":"2.0","method":"tools/call","params":{...},"id":1}

HTTP + Server-Sent Events (SSE)

1
2
3
4
5
POST /mcp/v1/call HTTP/1.1
Content-Type: application/json

{"jsonrpc":"2.0","method":"resources/get","params":{...},"id":1}

This isn't new tech—it's proven tech. JSON-RPC has been moving data reliably since 2005. MCP just gives it a new purpose.

http

STDIO

>_Packet

{
“operation” : “return”
“params”: {
“value”: “example”   }
}

2.7 Transport Layer Debugger

Why This Changes Everything

Before MCP, every AI integration was a custom project. After MCP, it's a configuration line:

Standard I/O (stdio)

1
2
3
4
5
6
7
servers:
  - name: github
    command: npx @modelcontextprotocol/server-github
  - name: slack
    command: python -m mcp_server_slack
  - name: postgres
    uri: postgresql://localhost:5432/mydb

Your AI can now

- Read your GitHub issues

- Post to Slack

- Query your database

- All without writing integration code

Your AI can now

- Read your GitHub issues

- Post to Slack

- Query your database

- All without writing integration code

Your AI can now

- Read your GitHub issues

- Post to Slack

- Query your database

- All without writing integration code

The M×N problem from Chapter 1? Still there, but now it's the protocol's problem, not yours.

>github

connected

>Server 2

connected

Server_1

Server_2

Server_3

YAML CODE EDITOR

servers:

github

name: github

type: mcp

url: https://api.github.com

tools:

- list_repos

- get_issues

- create_pr

Add Others

>github

connected

>Server 2

connected

2.8 Changed Everything

The Future Arrives

As this chapter closes, it's March 2025. MCP isn't just surviving—it's thriving:

- 10,000+ GitHub stars

- 50+ production MCP servers

- Major IDEs integrated

- OpenAI and Google implementing

- 10,000+ GitHub stars

- 50+ production MCP servers

- Major IDEs integrated

- OpenAI and Google implementing

- 10,000+ GitHub stars

- 50+ production MCP servers

- Major IDEs integrated

- OpenAI and Google implementing

Sarah from Chapter 1? She's building MCP servers now instead of debugging integrations. That 3 AM debugging session? Ancient history. The universal translator isn't coming. It's here.

2.9 The Network Effect

PREV. CHAPTER

PREV.

NEXT CHAPTER

Who built this? Follow the signal