What is MCP — the model context protocol
A Standardized Interface Between AI and Tools
MCP (Model Context Protocol) is an open protocol that provides a standardized way for AI models to discover and use tools. Instead of every AI integration being a custom one-off, MCP defines a universal interface: the model asks what tools are available, learns their schemas, and calls them with structured arguments.
Think of MCP as USB for AI — before USB, every peripheral needed its own connector. MCP does the same thing for AI tool integrations: one protocol, any tool, any model.
The problem — every integration was custom
Before MCP
Every tool integration required custom code on both sides. Claude needed a different plugin for Slack, GitHub, Jira, databases. ChatGPT had its own plugin system. Each vendor built and maintained N integrations for N models.
Integrations needed = M models x N tools = M*N
5 models x 50 tools = 250 custom integrations. Every new model or tool increases the cost multiplicatively.
With MCP
Each tool implements one MCP server. Each AI client implements one MCP client. Any client can connect to any server. The protocol handles discovery, schema negotiation, and invocation. Build once, connect everywhere.
Integrations needed = M clients + N servers = M+N
5 clients + 50 servers = 55 implementations. Linear scaling instead of quadratic.
Architecture — client, server, tools
Client
Claude / ChatGPT
Claude Desktop, Cursor, VS Code
JSON-RPC
↔
stdio / SSE
MCP Server
FTS MCP Server
HarperDB Resource
API calls
↔
HTTP / SDK
Tools / Data
Akamai APIs
Properties, DNS, Certs, WAF
The MCP server acts as a controlled gateway — the AI model never directly touches APIs or databases.
Core concepts — tools, resources, prompts
T
Tools
Actions the model can invoke. Each tool has a name, description, and JSON Schema for its parameters. The server validates arguments and returns results. Examples: list_properties, create_dns_record, activate_config.
R
Resources
Read-only data the model can access via URI. Resources provide context without side effects. Examples: akamai://properties, akamai://groups. The model reads resources to understand the current state before taking action.
P
Prompts
Pre-built prompt templates the server exposes. The client can list available prompts and fill in arguments. Prompts encode domain expertise: the right sequence of tools for common workflows like "migrate a property" or "debug a 503 error."
JSON-RPC protocol — the message flow
Connection Lifecycle
REQ
initialize — Client sends its capabilities and protocol version. {"method": "initialize", "params": {"capabilities": {...}}}
RES
Server responds with its capabilities, name, and version. Establishes what features both sides support.
REQ
tools/list — Client discovers all available tools. Server returns an array of tool definitions with names, descriptions, and JSON Schema input schemas.
RES
Tool catalog — [{"name": "list_properties", "description": "...", "inputSchema": {...}}, ...]
REQ
tools/call — Client invokes a tool with arguments. {"method": "tools/call", "params": {"name": "list_properties", "arguments": {"group": "12345"}}}
RES
Tool result — Server executes the tool, returns structured content. {"content": [{"type": "text", "text": "..."}]}
Transport can be stdio (local process, used by Claude Desktop) or SSE over HTTP (remote, used by this MCP server on HarperDB). The protocol is identical regardless of transport.
How this MCP demo works — FTS MCP Server on HarperDB
Architecture of This Project
This MCP server runs as a custom Resource on HarperDB. It implements the MCP protocol over SSE (Server-Sent Events), exposing 22 tools that orchestrate Akamai API operations. A Cloudflare-to-Akamai migration pipeline demonstrates multi-step AI-driven workflows.
22
Tools registered
Properties, DNS, Certs, WAF, CP Codes, EdgeHostnames, NetStorage
SSE
Transport protocol
HTTP streaming for remote access. No local process needed. Works from any MCP client.
135
Test assertions
Full test suite covering auth, tools, resources, migration pipeline, and error handling.
Why MCP matters — composability, security, discoverability
Composability
An AI agent can connect to multiple MCP servers simultaneously. One server for Akamai, one for GitHub, one for Slack. The model composes workflows across them: "Deploy this PR's changes to Akamai staging and notify the team in Slack." Each server is independent.
Security
The MCP server controls exactly what the AI can do. It validates every tool call, enforces permissions, and can reject dangerous operations. The model never has direct API keys — the server holds credentials and makes authenticated calls on behalf of the model.
Discoverability
Tools are self-describing. The model reads tool names, descriptions, and schemas to understand what's available. No training on specific APIs required — the model learns capabilities at connection time. Add a new tool and every connected client can use it immediately.
Interoperability
Build an MCP server once, and it works with Claude Desktop, Cursor, VS Code Copilot, ChatGPT, and any future client that implements the protocol. The ecosystem grows in both directions — more clients and more servers — without coordination.
