Model Context Protocol (MCP) went from "thing Anthropic published" to standard infrastructure fast — by mid-2026 there were roughly 9,400 published servers across the major registries, and nearly every serious agent tool speaks it. If you've been heads-down shipping and only half-absorbed what it actually is, here's the version that skips the hype and gets to the mechanics.
The problem it's solving#
Before MCP, every time you wanted an AI agent to use a tool — query a database, call an API, read a file, search the web — someone wrote a custom integration for that specific agent and that specific tool. A Claude integration for Notion looked nothing like a ChatGPT plugin for Notion, which looked nothing like a LangChain tool for Notion. N tools times M agents, all bespoke.
MCP is the fix: a standard protocol so a tool provider builds one server, and any MCP-compatible agent can use it. Same idea as how a USB-C port doesn't care what brand of cable is plugged into it.
The actual pieces#
MCP defines a client-server relationship with three primitives:
- Tools — functions the agent can call, with a defined input schema. This is the closest analog to what you'd already recognize as "function calling."
- Resources — data the agent can read: a file, a database row, a URL. Read-only, addressable by URI.
- Prompts — reusable prompt templates the server exposes, parameterized by the client.
A server declares what it offers. A client (the agent host — Claude Code, Cursor, an IDE, a custom app) connects, discovers the server's tools/resources/prompts, and the model decides at runtime which ones it needs for the task in front of it.
// Rough shape of a tool the server exposes
{
"name": "search_orders",
"description": "Search customer orders by email or order ID",
"inputSchema": {
"type": "object",
"properties": {
"query": { "type": "string" }
},
"required": ["query"]
}
}The server owns the implementation — how search_orders actually queries your database is entirely your business logic. The protocol only standardizes the shape of the conversation between agent and tool.
Where this differs from what you're probably already doing#
If you're running n8n-style automation — webhook triggers, chained HTTP nodes, an LLM node in the middle — you're already doing agent-to-tool orchestration, just wired by hand per workflow. The difference with MCP is who decides which tool gets called and when.
An n8n chain has a fixed shape: node A always feeds node B. An MCP-connected agent is handed a menu of tools and decides at inference time which ones the task actually needs, in what order, possibly none of them. That's a real tradeoff, not a strict upgrade — a fixed n8n chain is predictable and cheap to debug; an agent choosing its own tool sequence is more flexible but needs more guardrails (scoped permissions, tool allowlists, sane defaults on failure).
They're not mutually exclusive either. A perfectly reasonable architecture is an n8n workflow where one node is an MCP client, giving that step access to a whole toolbox instead of one hardcoded API call.
Designing tools an agent can actually use#
The protocol is the easy part. The part that decides whether your server is useful is tool design, and the instinct most of us bring from REST APIs is subtly wrong here.
A REST endpoint is consumed by a developer who reads your docs once and writes integration code deliberately. An MCP tool is consumed by a model that picks from a menu at inference time, based almost entirely on the tool's name and description. That changes what "good" looks like:
Descriptions are the interface, not documentation. search_orders with the description "Search customer orders by email or order ID" gets chosen correctly. The same function described as "Order query endpoint (v2)" gets skipped or misused. Write the description for someone deciding whether this is the right tool, not for someone who already decided.
Narrow beats general. One database_query tool that accepts arbitrary SQL is maximally flexible and nearly unusable — the model has to construct correct SQL against a schema it can't see, and every mistake is a silent wrong answer. Three specific tools (get_customer, list_recent_orders, search_products) constrain the space enough that being right is the default.
Return errors the model can act on. "Error 400" tells a model nothing. "No customer found with that email — try search_customers with a partial name" tells it exactly what to do next, and it usually will.
Assume every tool will be called wrong at some point. Validate inputs at the server, and make destructive operations require explicit confirmation rather than trusting the model to be careful. The model is not an authenticated user with intent — it's a component that occasionally guesses.
The security question you should ask first#
Because an MCP server exposes real capability to something that decides at runtime what to call, "what could this do if it chose badly?" is a design question, not a paranoid one.
Two things worth settling before you ship one: scope credentials to the minimum the tools actually need — a server exposing read-only reporting should hold read-only database access, not an admin connection string — and treat data returned from a tool as untrusted content, not instructions. If your server returns user-generated text (support tickets, comments, scraped pages) and that text contains something shaped like a directive, a naive agent may act on it. That's prompt injection with a real blast radius, and the mitigation lives in how the host handles tool output, not in the protocol.
What this means practically#
If you're building anything that exposes internal tools to an AI assistant — a CLI, an internal dashboard's data, a set of scripts your team runs by hand — an MCP server is now the default way to make that agent-usable, rather than a bespoke plugin per assistant. The upfront cost is defining clean, narrow tool schemas (the same discipline as designing a good REST endpoint); the payoff is that it works with whatever agent your team standardizes on next, without rewriting the integration.
We haven't wired an MCP server into DevStash's own pipeline yet — the current AI automation here (the /lab/ai-content-pipeline demo, and the n8n + Groq workflows behind the scenes) predates that being the obvious choice. If we revisit it, the natural first candidate is exposing the blog's own content layer — getAllPosts(), getProjectBySlug() — as MCP resources, so an agent could query real site content directly instead of a workflow re-implementing that lookup by hand. That's a "would," not a "did" — worth being precise about the difference.
Quick answers
What problem does MCP solve?
Before MCP every agent and every tool needed its own custom integration. MCP is a standard protocol, so a provider builds one server and any MCP-compatible agent can use it.
What are the three MCP primitives?
Tools, which are functions the agent can call with a defined input schema; resources, which are read-only data addressable by URI; and prompts, which are reusable parameterised prompt templates the server exposes.
How is an MCP agent different from an n8n workflow?
An n8n chain has a fixed shape where node A always feeds node B. An MCP-connected agent is given a menu of tools and decides at inference time which to call. The post calls that a tradeoff, not a strict upgrade, and says the two can be combined.
What makes a good MCP tool?
A description written for deciding whether this is the right tool, narrow tools over one general one, error messages the model can act on, input validation at the server, and credentials scoped to the minimum the tools need.
Need something like this built or fixed?
Custom websites, landing pages and speed fixes. I reply within 24 hours.
Adesh Shukla
Front-end developer who came to the web from accounts, by way of an interest in UX. Building DevStash — a developer ecosystem covering automation, AI workflows, and modern frontend systems.