Model Context Protocol, explained
A plain-English tour of Model Context Protocol — the standard that gives AI models arms and legs to act on your WordPress, Laravel and home systems.
(*Update: Microsoft is now integrating MCP directly into Windows, so chances are it's here to stay!)
(*Update 2: As of 22nd May, OpenAI has also updated its Responses API with MCP support - so assume you're good to go with this!)
Heads up This was written as a mid-2025 snapshot, and the "bleeding-edge / still evolving"
framing has aged fastest — MCP won. It is now a mainstream, cross-vendor standard: OpenAI, Google and
Microsoft have all officially adopted it, and it ships in the major IDEs and agent tools (Claude Code, Cursor,
VS Code, Windsurf, the OpenAI Agents SDK, Google's Gemini/ADK). There's an official
MCP registry for discovering servers, and the spec has been through several dated revisions
(2025-03-26, then 2025-06-18) under a proper working group.
Read every "it's early days" caveat below through that lens. And where the piece names models — Claude, ChatGPT —
the current frontier line-up is roughly Claude Sonnet 4.5, GPT-5.x and
Gemini 3; Claude Desktop is now joined by Claude Code and dozens of other first-class MCP clients.
Okay, so let's discuss LLMs and MCP integration! – that's Model Context Protocol – and how it links in with web development, specifically with platforms like WordPress, Laravel, Craft CMS, and even your home server or desktop.
If you're even slightly interested in AI like I am, you'll likely have heard this term - "Model Context Protocol" on socials and in the tech news. Perhaps in the context of big companies automating systems, or tech enthusiasts upgrading their home network.
The idea of AIs getting even more agency and power to do stuff outside the confines of their context windows though is, well, a tiny bit scary to put it mildly
And if you're firmly in the "AI sucks" camp then this likely just sounds like even more bad news heaped on top of an insurmountable heap. But it's here, it's happening, all we can do is hope it turns out well for us.
Many people don't even know Model Context Protocol exists yet (I barely knew anything about it before researching this post). But in a few years, it could be quietly running under the hood of everything, much like how HTTP shaped the web or how SFTP still exists as a way of getting files to and from web servers. MCP is a brand new kid on the block which lets AIs like ChatGPT or Claude do more than just chat and gives them arms and legs to reach out into the world with. A little creepy!
What does this mean for developers, customers, business owners? Here I'll go through what MCP actually is, why it matters, how it works across different platforms, and where this could all be heading next. What the heck indeed.
One of the first things to clarify is what Model Context Protocol is and what it isn't. It's easy to get lost in the jargon. So, what exactly is MCP? Is it just a protocol, or is it something else?
When you talk about MCP, you're basically just talking about a set of rules.
Think of it like this: MCP is a guide for how to define tools, a guide for how clients should expose those tools, and a guide for how LLMs can call them. It tells developers how to describe tools (name, inputs, outputs, etc.) using a schema, primarily JSON Schema (other specs like OpenAPI or GraphQL SDL are typically wrapped by helper servers). It lays out how the LLM should send requests and expect responses, and it allows many different types of tools – local scripts, HTTP APIs, etc. – to be treated the same way.
This abstraction is what makes MCP so elegant. It's AI-talk for not reinventing the wheel.
One language that AIs can use to communicate with the world.
Understanding these roles helps clarify how the different pieces of the MCP puzzle fit together.
{
"tool_name": "getSalesForMonth",
"arguments": {
"month": "May",
"year": 2025
}
}
// LLM sends something like the above to a Model Context Protocol Server...
// ...and might get back:
{
"total_sales": 12345.67,
"currency": "USD",
"top_product": "Widget Deluxe"
}A simplified conceptual example of an LLM requesting to use a tool and the kind of response it might receive.
One way to think about it is that instead of a 1-to-1 relationship between AIs and services (so you've have countless LLMs, each with n connections to services, leading to an n*n scenario, you have AIs connecting to the Model Context Protocol Client which connects in turn to the services. So an n+n situation. Far more manageable!
It's important to note that while the concepts are similar, different players have their own implementations. MCP was coined and formalized by Anthropic. Claude Desktop is currently a prominent client implementation of Model Context Protocol.
OpenAI's tool-calling capabilities (the part of the Chat Completions / Assistants API that returns tool_calls) play a similar role to an MCP Host's function but it isn't MCP-compatible at the wire level—think of it as a parallel dialect. It makes GPT behave like it can use tools. Think: "I typed a message into ChatGPT, and instead of just words back, it knows it needs to call a tool — and here's what it sent." So, if MCP becomes a widely adopted standard, then anyone can write a backend that various LLMs (those supporting MCP) can call tools from—including your own Laravel app, WordPress admin, or even your Minecraft server. However, OpenAI doesn't strictly use MCP; it uses its own schema, which is very similar but not identical or directly interoperable.
Heads up This section is now the most out-of-date part of the article. In March 2025 OpenAI officially adopted MCP — it's supported in the Agents SDK, the Responses API and ChatGPT desktop. So "it isn't MCP-compatible at the wire level" and "OpenAI doesn't strictly use MCP" are no longer true: you can point an MCP-speaking client at OpenAI's stack, and OpenAI can consume remote MCP servers directly. The "parallel dialect" framing described the world of early 2025, not today's.
"Think of MCP like a USB-C port for AI applications, just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools."
Anthropic, creators of MCP
The real "aha!" moment with MCP often comes when you realize you can wire LLMs into everyday platforms. Let's focus on one "hero" scenario: a WordPress site for "Widget Co." to see how Model Context Protocol can empower a business.
Widget Co. uses a WordPress site to manage information about their widgets, business locations, staff updates, and production documents. They love widgets there. It's all they think about. The CEO wants to query this information naturally, because of course he does. Bosses don't have time for code and suchlike.
"I would love to be able to talk to my website; that sounds brilliant! I want to query who's been updating widgets recently, who's been the most productive, what's the latest widget that we've produced, and so on. Make it happen."
- Boss Man
(Note: The data could be in an internal system, but for our example, WordPress is the source of truth. We're web developers, after all!)
"I sit down at my computer, I open up ChatGPT (or Claude Desktop), and I start typing, 'How many widgets have we updated this month?' How does the AI know what I mean? How does it know to call something on my website?"
The Workflow Unpacked:
mcp-wp/mcp-server). This plugin wraps WordPress's REST API. They then define "tools" – mini JSON APIs described by a schema – like list_widget_updates or get_productivity_stats.
list_widget_updates as relevant. It constructs a structured request:
{
"method": "tools/call", // Or similar based on specific MCP implementation
"params": {
"name": "list_widget_updates",
"arguments": { "date_range": "2025-05-01 to 2025-05-22" }
}
}This request is routed to the MCP server on the WordPress site. The server runs the query and returns the data.
The "tool" is defined on the AI side (e.g., in a Custom GPT or understood by Claude via MCP discovery). You specify the endpoint (your MCP server on WordPress), method, and schema. The AI learns to associate user intent with these tools. Your WordPress REST API endpoints are the actual executors.
All tools must be sandboxed. No raw database access or arbitrary file system operations unless explicitly and carefully coded. You might expose read_widget_status but not delete_all_users. Businesses need assurance: the AI isn't roaming free. Every action should be permissioned, scoped, and logged. The developer defines the API, limiting what the AI can do.
You could allow staff to use AI to update widget statuses, but this requires robust role-based access control (RBAC) and potentially OAuth integration within your MCP server plugin.
The Human-in-the-Loop: Essential for Trust
We're likely years away from fully trusting AIs with significant, unreviewed decisions on live business data. For actions like updating records or emailing customers, a human approval step is vital. You could implement a queue in the WordPress admin dashboard showing AI-initiated changes, awaiting acceptance or rejection. Keep the AI on a leash, especially for write operations!
While WordPress offers a great entry point, the principles of MCP extend to more powerful and flexible platforms.
Let's see how Laravel can take MCP integration to the next level.
For more complex needs, Laravel provides a robust foundation. It offers greater flexibility, testability, and control over your MCP server implementation. Think Sanctum/Passport for authentication (treating the LLM like a scoped API user), sophisticated gates and policies for authorization, job queues for asynchronous tasks, and powerful Eloquent ORM for data interactions.
You could define dedicated MCP routes (e.g., in routes/mcp.php), use resource controllers for tools, and implement rate limiting and detailed logging for AI interactions.
A key advantage in Laravel is the ability to use design patterns like the Repository Pattern. You can wrap your MCP tool logic in an interface (e.g., ToolExecutorInterface). Your current implementation might use an MCP-specific schema, but you could later swap this out for OpenAI's tool-calling format or a future protocol without rewriting your core business logic.
Key Takeaway for Laravel: "Using the repository pattern, you can safely bet on MCP today—while leaving the back door open to swap in whatever protocol wins tomorrow."
Back on our WordPress site, similar approval queues and security considerations would apply if we were allowing write access.
2026 update Laravel now has first-party MCP support — the official laravel/mcp package
(Laravel MCP) gives you server scaffolding, tool/resource classes and auth via Sanctum out of the box, so you no longer
have to hand-roll routes/mcp.php. The repository-pattern advice still holds, but the "back door" is less
of a concern now that OpenAI, Google and Anthropic all speak the same protocol.
The conversation doesn't have to be one-way. What about the website sending updates to the LLM? This is where things get really interesting, especially when you bring in automation tools like Zapier.
For example, a new order on your WordPress site could trigger a webhook. This webhook could send data to an LLM (perhaps via a custom tool or an intermediary service). The LLM processes this, and then, using a Zapier connection (if the LLM platform supports it as a tool), updates a Google Sheet or sends a Slack notification.
In Laravel, queued jobs could monitor for new products and then use a tool to inform an LLM, which in turn might use its own tools (like a Zapier integration) to update external spreadsheets or dashboards. This creates a more dynamic, event-driven interaction.
Websites are just one part of the equation. MCP's potential truly shines when we consider local applications.
Let's explore how MCP can transform your desktop and home automation experience.
The line between AIs and the clients we use to access them is blurring. From desktop agents to IDE integrations, the ways we interact are multiplying, which can be overwhelming.
Traditionally, a client (like a browser) had to be programmed to talk to a specific server API. With MCP, the LLM acts as an intelligent intermediary. You provide a natural language query to a client (like Claude Desktop); the LLM (as part of the Host) interprets this and figures out which MCP tool on which MCP Server to call. A text prompt can, in many cases, replace a complex front-end application.
Imagine querying files on your system ("Find PDF invoices from April"), summarizing spreadsheets, or running local scripts ("Run disk_cleanup.py every Friday")—all by talking to an AI.
With Claude Desktop, you can run an MCP client that talks to local tools. It starts and introspects an MCP server running on your machine (e.g., mcp-desktop-automation or custom scripts). You define tools locally, and Claude (the LLM in the cloud, via the Host in Claude Desktop) uses them. No public IPs or complex port forwarding needed for these local interactions.
This contrasts with using, say, ChatGPT's web interface with Custom GPTs for local tools. That typically requires your local tools to be exposed publicly via a server or a tunneling service like ngrok, and you manually define the tool schemas in the GPT builder. For true local-first power, a dedicated MCP client like Claude Desktop is currently more streamlined.
"With Claude Desktop, your local tools are easily accessible. For web-based AIs to use local tools, those tools often need a bridge to the internet."
The LLM can become your butler, DJ, and lighting designer. "Turn the kitchen lights red," "Play some uplifting music," or "What's the temperature in the fridge?"
You've got your Nest, Ring, smart lights, Spotify... how do you connect them?
mcp-desktop-automation or custom script) defining tools like get_fridge_temp(). Each tool runs a script or hits a local device API.Security: Runs locally. For remote access, consider VPNs and token auth per tool. Every server should explicitly request user approval for tool invocations (Claude Desktop can show a grant dialog).
"We used to script smart homes with logic blocks—now we just talk to them, and the LLM figures out the rest."
Enough home maintenance and business logic! If you run a Minecraft server (perhaps on a home Linux box, like I do with my son), you can expose MCP tools to manage it: start/stop server, whitelist players, change world settings ("Claude, new creative world, no rain!").
Your Minecraft server becomes a Model Context Protocol Server, with tools running RCON commands or server scripts. Claude Desktop acts as your admin console. It's a fantastic way to teach how computers talk to each other.
You could even imagine tools to get in-game information or trigger events. The possibilities are playful and educational.
MCP is exciting, but it's early days. Let's address the current landscape and potential pitfalls.
Heads up Two of these four limitations are simply gone now:
2025-03-26 spec introduced
Streamable HTTP as the standard remote transport, with OAuth 2.1 for auth — so a WordPress or Laravel MCP
server on another machine connects natively over HTTPS. No SSH/ngrok bridge, no custom Host/Client pair.Spec churn and ecosystem maturity have also settled: there's a governed spec with dated releases, an official registry, and production-grade WordPress (e.g. the Automattic/WordPress MCP work) and Laravel MCP support.
Will MCP be the standard, or one of many? We risk the "JavaScript framework problem": 14 competing standards, then someone creates a 15th to unify them... (Cue the classic XKCD comic on standards).
"If MCP is HTTP, let's hope we don't end up with 14 slightly different versions of it, each needing its own plugin to make 'turn on my lights' work."
If you build an MCP tool for WordPress, will it be obsolete in six months? Short answer: Yes, to a point—but build with adaptability in mind.
How to Build Safely:
"MCP is stable enough to explore—but young enough that you should build like you might have to migrate."
This is where the imagination can, well, run a little wild. We've all seen the movies. An AI, given the keys to the kingdom, decides to lock us all out (or worse!). When we talk about Actionable AI and MCP allowing LLMs to do things, it's natural to wonder if we're inching closer to that kind of scenario. Could MCP be the conduit for an AI to gain too much power?
Let's ground this a bit. MCP itself doesn't grant the AI sentience or independent ambition. The LLM isn't waking up and deciding to cause chaos via your WordPress MCP server. It's responding to prompts and using the specific tools you, the developer, have exposed. If there's no "delete_database" tool available through MCP, the LLM can't just conjure one up.
The more pertinent concerns, when we strip away the sci-fi gloss, are a bit more down-to-earth but still incredibly important:
So, while the narrative of a spontaneously rebellious AI is compelling, the immediate challenge with MCP is more about robust engineering, meticulous security, the principle of least privilege for exposed tools, and ensuring human oversight where actions have significant consequences. It's less about the AI wanting to "go rogue" and more about humans ensuring they haven't inadvertently left the entire system vulnerable or designed tools that are too much of a "free rein" for any single point of failure or instruction.
Ultimately, the AI is working within the "fences" you build. The critical task is to design those fences well.
2026 update Everything in this section has aged well — if anything it reads as prescient. Prompt injection against tool-using agents is now the headline MCP security concern in the wild, and the ecosystem has responded with exactly the "fences" described here: OAuth-scoped tokens, per-tool human-in-the-loop approval, and the June 2025 spec's tightened auth and consent requirements. "Design those fences well" is now received wisdom rather than a warning.
As MCP and similar protocols mature, we'll see new patterns emerge.
The AI models are black boxes, but the MCP Servers and Clients are human-designed. This means huge scope for modular, reusable toolkits (e.g., for WordPress content, file operations, team chat integration). Imagine an npm for MCP tools!
2026 update "Imagine an npm for MCP tools" arrived: the
official MCP registry launched in 2025, and package managers,
IDEs and desktop apps now install servers from it directly. The reusable-toolkit future Robin pictured here is the
present.
When teams use a shared LLM interface, the MCP server can become a team historian. "What did the UK team update yesterday?" The LLM, via MCP tools, could provide summaries of collaborative work.
With interconnected systems, clear logging is vital. An MCP server could expose tools to query its own status or explain failures. "Why didn't that email send?" This enables self-diagnosing systems.
"You're not just building tools—you're building interfaces for questions you haven't thought to ask yet."
Model Context Protocol won't simplify tech. If anything, it adds layers and complexity by encouraging more connectivity. It's not making things simpler; it's giving us more options. And options sound good, but not always when they come from a thousand different sources.
"MCP and LLMs offer new doors—but also a hallway full of them. And you still need to decide which ones to open."
But these are layers that can speak our language. You might start wanting to talk to your WordPress site, then wonder if your fridge, lights, and Minecraft server can join the conversation. With MCP, they can.
The LLM isn't just a data processor; it's a tool for understanding how we interact with data and what that means in our daily lives, even when we step away from the computer.
(This part is more speculative, but exciting!) Imagine wearing earbuds, chatting to your home AI. Or a VR headset where you virtually explore and interact with your connected world – seeing lights respond, orders filter through your website, all visualized in real-time. This isn't just interface design; it's experience architecture.
AI doesn't simplify the world; it multiplies possibilities. But with tools like MCP, we can shape those possibilities into something human, meaningful, and perhaps even fun, giving us tools to visualize our increasingly complex world.
The journey into MCP and LLM integration is just beginning. It's a landscape ripe with potential for innovation, for creating more intuitive and powerful ways to interact with the technology that surrounds us.
What are your thoughts? How do you see MCP shaping the future of web development and system interaction?
All articlesI help content-rich organisations understand their data and pull it back into one place. Tell me what specific problems you're having and I'll be happy to talk solutions with you.
Tell me what specific problems you’re having and I’ll be happy to talk solutions with you.