The Model Context Protocol — a universal tool interface for LLMs
MCP (Model Context Protocol) is an open standard that lets LLMs connect to external tools and data sources through a uniform interface. Instead of each AI application building custom integrations, MCP provides a single protocol that any client (Claude, VS Code, custom apps) can use to discover and invoke tools on any MCP server.
The analogy: USB standardized how peripherals connect to computers. MCP standardizes how AI models connect to tools. One protocol, infinite capabilities.
Client
Claude Desktop, VS Code,
custom applications
Protocol
JSON-RPC 2.0 messages
over any transport
Server
Tools, resources, prompts
exposed to LLMs
Transport layers — how client and server communicate
stdio
Server runs as a subprocess. Messages pass through stdin/stdout. Simplest transport — no networking, no auth overhead. The client spawns the server process directly.
Client spawns: npx mcp-server
Messages: JSON-RPC via stdin/stdout
Used by Claude Desktop for local MCP servers. Zero latency, zero network config.
HTTP + SSE
Client sends requests via HTTP POST. Server streams responses via Server-Sent Events (SSE). Enables remote servers and network-based deployments. Requires an HTTP endpoint.
POST /mcp → JSON-RPC request
SSE stream ← JSON-RPC responses
The original remote transport. Being superseded by Streamable HTTP for new implementations.
Streamable HTTP
The newest transport. Single HTTP endpoint handles both requests and responses. Supports streaming via SSE when needed, falls back to simple request/response otherwise. Simpler than HTTP+SSE.
POST /mcp → request + response
Optional SSE for long-running tools
Recommended for new remote MCP servers. Our HarperDB server uses this transport.
Session lifecycle — from connection to close
1
Initialize
Client sends protocol version, capabilities
→
2
Capabilities
Server responds with supported features
→
3
Discovery
Client calls tools/list to get available tools
→
4
Execution
Client invokes tools/call with arguments
→
5
Close
Session terminates, resources released
The LLM sees the tool list at step 3 and decides which tools to invoke based on the user's request. The client mediates — the LLM never calls tools directly.
Tool definition schema — how tools describe themselves
Tool Definition Structure
Every MCP tool is defined by three fields: a unique name, a natural-language description (which the LLM reads to decide when to use it), and a JSON Schema describing its input parameters.
{
"name": "cf_export",
"description": "Export a Cloudflare
zone's DNS records, page rules,
and WAF configuration",
"inputSchema": {
"type": "object",
"properties": {
"zone_id": {
"type": "string",
"description": "CF zone ID"
}
},
"required": ["zone_id"]
}
}
Structured Content Responses
Tools return structured content — not just text. The MCP spec supports multiple content types in a single response, letting tools return rich data that the LLM can reason over effectively.
{
"content": [
{
"type": "text",
"text": "Exported 47 DNS
records, 12 page rules,
3 WAF rulesets"
},
{
"type": "text",
"text": "{...json data...}"
}
]
}
Security model — server controls, client mediates
Server-Side Control
The MCP server decides which tools to expose and what each tool can do. Tools can validate inputs, enforce rate limits, and restrict access to underlying APIs. The server is the security boundary — it never trusts the client blindly.
Client Mediation
The LLM proposes tool calls. The client (Claude Desktop, etc.) mediates — it can require user approval before executing sensitive tools. The LLM never directly invokes tools; there's always a human-in-the-loop or policy layer between the LLM and execution.
Token-Based Auth
Remote MCP servers authenticate via bearer tokens, API keys, or OAuth. Our server uses JWT tokens passed via query params (GET) or body fields (POST) — because HarperDB Resources cannot read HTTP request headers directly.
Capability Scoping
During initialization, server and client negotiate capabilities. A server can declare it supports tools but not resources or prompts. Clients can declare which notification types they handle. This prevents feature mismatches.
This MCP server's architecture — HarperDB + MCP SDK
The FTS MCP Server runs on HarperDB as a custom Resource. The McpServer.ts resource handles the MCP protocol layer, routing incoming JSON-RPC messages to the appropriate tool handlers registered in the tool registry.
Claude Desktop
MCP Client
→
Streamable HTTP
/McpServer endpoint
→
McpServer.ts
HarperDB Resource
→
Tool Registry
21 tools registered
Akamai Tools
configure_credentials
list_properties
get_property_rules
activate_property
list_dns_zones
manage_dns_records
Migration Tools
cf_export
cf_assess
cf_convert
cf_dns_export
cf_dns_convert
Utility Tools
create_change_request
list_change_requests
get_v3_comparison
get_v3_events
Documentation Tools
get_api_docs
get_cli_docs
search_docs
Multi-tool orchestration — how Claude chains tools for migration
The real power of MCP emerges when the LLM chains multiple tools together to accomplish complex workflows. In a Cloudflare-to-Akamai migration, Claude orchestrates a sequence of tool calls, using each tool's output as input for the next.
Claude analyzes the exported config, identifies features and complexity
Claude reviews compatibility, gaps, and migration strategy
Claude can now activate the property or create a change request for review
Key insight: the LLM decides the tool sequence at runtime
The orchestration is emergent, not hardcoded:
- Claude reads tool descriptions during discovery
- Based on the user's request, it plans which tools to call
- Each tool's output informs the next decision
- If cf_assess reveals issues, Claude may skip cf_convert and explain why
This is fundamentally different from traditional API orchestration. There's no predefined workflow — the LLM plans and adapts in real time.
Why MCP matters — from custom integrations to universal protocol
Before MCP
Every AI app built custom tool integrations. Each new tool required client-side code changes. N clients times M tools = N×M integrations. A new tool meant updating every client. A new client meant re-implementing every tool.
With MCP
Build a tool once as an MCP server. Any MCP client can use it immediately. N clients + M tools = N+M integrations. New tools are instantly available to all clients. New clients can use all existing tools.
For Akamai
Our MCP server exposes Akamai APIs as tools that any AI assistant can use. Property Manager, Edge DNS, WAF — all accessible through natural language. Customers can manage their Akamai configurations by describing what they want, not writing API calls.
For Migration
The Cloudflare migration tools demonstrate multi-step orchestration. Export, assess, convert, deploy — a workflow that would take days manually is completed in minutes. The LLM handles the translation logic; the tools handle the API calls.
