MCP Explained
Posted by rwilinski 1 day ago
Comments
Comment by nater5000 1 day ago
MCPs don't really need this level of technical explanations (it's basically just a REST API with standardized endpoints for discovery aimed at agents), and AI agents really do lack in the taste dimension when it comes to these things.
Comment by jrmg 1 day ago
Comment by bityard 1 day ago
Comment by dspillett 5 hours ago
Most documentation is reference documentation, which as you find it not very useful for just starting out (it assumes at least a small base of knowledge about what it is documenting).
> _Good_ documentation should also teach the user how to use the thing
Good documentation usually comes in at least two parts: guide/introduction and reference. This is how some of the better ORA books were written, back when dead trees on shelves were a key source of learning for programmers - three sections: a small one for absolute basics (what you need to know before starting, many could skip this), the second an introduction to the concepts of the new thing (language, library, server, etc.) and what differentiates it from similar/related things, typically with worked examples, and at least the last half of the pages being reference material (split into meaningful subdivisions where that is useful). Sometimes they would split this in two and there would be explicit introduction and reference works (under the banner “complete reference”, though these would have a little introductory text in them too) for the same subject, but not always.
When you try to merge the two (guide and reference) too closely it all too often ends up either too basic or irritatingly long-winded for the experienced readers, while still being too opaque for those who are starting from scratch.
Sometimes a single good README is all that is needed for the guide part these days, sometimes you need that with branches (links) off to longer introductions to specific parts, it depends on the size of the project.
Comment by Geezus_42 1 day ago
Comment by SOLAR_FIELDS 10 hours ago
Comment by palata 3 hours ago
For an article explaining a concept, it's a balance to find, and it depends on the target public. If every physics publication started by teaching physics to the reader, it just wouldn't work, would it?
Regarding documentation: we probably all agree that a code repository should NOT explain how programming works: if you don't understand C++, then a C++ codebase is not for you.
But should the README explain how to, e.g. run CMake? I would agree it shouldn't. Just like it shouldn't explain how to clone the git repository, or start the computer.
This said, I find this particular explainer about MCP... convoluted.
Comment by ep103 20 hours ago
Engineers rarely consider either, and doing both requires significant work
Comment by dawnerd 8 hours ago
Comment by dspillett 5 hours ago
No MS, I don't want to ask co-pilot. Why don't you get co-pilot to draft some good documentation, that you then review and edit to make sure it is accurate, instead of expecting every individual to ask an AI for every question they have? That would be a lot more efficient in terms of energy use, I expect.
Comment by adolph 19 hours ago
Comment by 4L3XV33 11 hours ago
Comment by ex-aws-dude 18 hours ago
Comment by ozim 8 hours ago
I don’t like people pointing out AI slop but one looks like something that should be called out. Maybe it helps the author for self learning that’s cool, but it doesn’t look like something for sharing with people as it really only wastes time.
Comment by dingaling911 1 day ago
Comment by WhitneyLand 1 day ago
They both provide stateless RPC methods and human readable metadata that makes them easy to route.
You could ask why json-rpc was even necessary for 2.0. I think mostly just for stdio and backwards compatibility.
Comment by dingaling911 1 day ago
Comment by rootusrootus 16 hours ago
Comment by privacyishuman 14 hours ago
Comment by LoganDark 13 hours ago
Comment by gnabgib 13 hours ago
Comment by slowpacket 15 hours ago
Comment by Aurornis 1 day ago
The opening has 1 paragraph and 5 table entries. One of them is “Not REST”
It’s a little scary that this was considered too dense or complex because the basics were explained in something that could be read in 1 minute. That still wasn’t enough to stop the top HN comment (as I write this) from calling it too dense and giving incorrect information that is immediately refuted by skimming the top part of the article.
Comment by sharifhsn 1 day ago
Comment by jazzypants 23 hours ago
https://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypert...
Comment by krackers 11 hours ago
Particularly this subthread which was my moment of enlightenment https://news.ycombinator.com/item?id=44507991. A truly restful API isn't for a program to consume, it's for _you_, the user to consume through your user agent. Clicking on links is a hypermedia driven, restful api.
I think I saw a comment somewhere by the htmx dev, that Fielding was just giving a name to how the web already was at the time, hyperlinks rendered by a browser that you can navigate in a stateless way to get things done without the user agent being coupled to the sites themselves. It makes sense when you view it as backward-looking academic analysis rather than practical prescriptive advice.
But once you have that defined you can talk about whether things are more or less restful. That's separate from whether something being "more restful" is even good or desired though.
Comment by jazzypants 3 hours ago
Comment by tasuki 22 hours ago
What does that even mean?
> the same request/response format as REST
What request/response format does REST have?
Do you even know what HATEOAS means?
Comment by parineum 1 day ago
If the article said, "It's basically just REST". There'd be no need to comment as such.
Comment by wongarsu 23 hours ago
Yeah, I can click around and follow what's going on. But I'm with GP: this is not making it easier to understand. It's great at being Hollywood UX: looks pretty, stuff moving everywhere. One click on "step" makes the image animate, and change the text in the left sidebar, top middle, and right sidebar, in addition to stepping the table in the bottom middle. But it's almost the opposite of distilling information
Comment by steve_adams_86 21 hours ago
Agreed, and it probably doesn't need to be overwhelming but the design choices leave the intent and purpose of the UI fairly unclear. It requires a bit of clicking around to understand what it's all for, and it's quite flat and unappealing, leaving little drive to do that work.
Comment by iugtmkbdfil834 1 day ago
Comment by taneq 1 day ago
Comment by sleepybrett 22 hours ago
Comment by flanz_10 23 hours ago
and yet...
Comment by amelius 1 day ago
Maybe it was written for an AI? :)
Or by an AI? Or both?
Comment by WhitneyLand 1 day ago
From your comment, I expected to be annoyed by a bunch of slop or obscurities.
My guess is the writing did not come straight out of an LLM and was carefully curated.
If I’m wrong I’d love to have the style prompt.
Comment by rwilinski 1 day ago
Comment by Zaheer 22 hours ago
Comment by pllbnk 21 hours ago
Comment by truetraveller 21 hours ago
Comment by bluegatty 20 hours ago
Anything fleeting -> just use a skill.
The advantage of MCP is thin, and it only starts to show when it's really well integrated, and your company platform provider does the integration.
Otherwise it's a huge pain in the rear to keep your cli integrated with all the MCPs.
MCP is good for things you use literally 'all of the time' - or - it's seamlessly integrated into your system and you don't have to think about it.
Otherwise, just give your AI some instructions on the CLI.
I think that MCP may have been a mistake, and the local service aspect a distraction.
The 'enterprise integration' part may have best been articulated as a form of API standard and not associated with how it's integrated into 'tools' or anything else.
It was introduced too early.
Comment by ndriscoll 1 day ago
Comment by zzbzq 1 day ago
In theory the agents could just natively know how to do this better, to get exactly the composability you want. In fact, you could probably just write a CLI mcp-caller and tell the agent to only call MCPs via that, and boom you're done.
Where MCP does come back into the picture even for coders is a more controlled way to break a sandbox.
What I will also say is it matters less and less. It's the usual bitter lesson. The models are just getting so much better all attempts to optimize everything are a drop in the bucket.
Comment by jameshart 23 hours ago
Consider an agent which doesn’t have those tools though. MCPs are a great way to give them constrained access to remote resources.
Comment by ndriscoll 23 hours ago
Comment by cefboud 1 day ago
Comment by kbdiaz 1 day ago
Internally at my startup, I built an interpreter for a subset of Javascript where the agent can compose its tools and MCPs. The cool thing about it is that it can create durable workflows and automations from these same scripts.
Comment by nickstinemates 20 hours ago
Comment by dingaling911 1 day ago
"Find the latest prod JIRAs and analyze the related logs"
Comment by anthony_aisyste 35 minutes ago
Comment by rwilinski 1 day ago
Comment by zaelar 5 hours ago
Comment by strideashort 3 hours ago
Comment by dirteater_ 20 hours ago
Sure now there are apps and tasks in the spec to handle specific usecases, but those can also be DIY'ed without the protocol and agents can still use them.
Comment by sputknick 1 day ago
Comment by Gshaheen 1 day ago
Comment by nater5000 1 day ago
Comment by sputknick 1 day ago
Comment by jrm4 20 hours ago
Daniel Miessler's fabric comes to mind. It's great, does a lot of great stuff, but requires literally nothing new, "code-wise"
Comment by slashtom 22 hours ago
Watched a few youtube apps about a 'harness' and I still haven't dived too deep into it but using openchamber to work with the code is awesome. Next step is MCP to various apps and seeing what it can do.
Comment by ricardobeat 18 hours ago
What do you mean? DeepSeek Flash 1017 is well over 200GB even at 1 bit quantization, how are you running it locally?
Comment by selcuka 16 hours ago
> Unsloth Desktop + llama.cpp enables ~3x faster DeepSeek-V4.1 inference than other CPU/VRAM/ngram repos. DeepSeek and runs locally on 128GB+ RAM setups or 64GB RAM (slower).
Comment by shaolinspirit 1 day ago
Comment by tedivm 1 day ago
MCP has its place. It should not be the default for many use cases, but if you need to expose specific tools in a secure way to agents that are not trusted to run shell commands then MCP is great. Developers need to think beyond their own use cases and consider architecture patterns if they're going to build, not just consume, AI systems.
Comment by mattw2121 1 day ago
Comment by navhc 23 hours ago
Comment by v7n 7 hours ago
Comment by z3t4 6 hours ago
Comment by mattw2121 22 hours ago
Comment by navhc 22 hours ago
Can only hope google relaxes their limitations on choice of ai assistant. In the meantime I'm setting up a raspi with openwakeword to just act as an interface for voice to voice interactions for while I'm home.
Comment by orthogonal_cube 1 day ago
Comment by nicholassmith 1 day ago
Comment by insin 1 day ago
Comment by toddmorey 1 day ago
This was just to avoid MCP infra, but the newer stateless protocol makes that much more trivial.
Comment by shaolinspirit 1 day ago
Comment by ByteOfWood 1 day ago
People make the argument that it doesn't matter for non-programmers. I use Bluebeam (a pdf editor which is standard in the construction industry) daily, and it has an MCP, but a big problem is that if the agent wants to import or export a large amount of data from a document, then it has to regurgitate a bunch of tokens into or out of the MCP. If it were a CLI, then it would just pipe things in and out as it needs.
I ended up just having the agent make a script that wraps the MCP so it can use it as a CLI instead.
Comment by insin 1 day ago
Tool calls being composable or not are a property of the harness being used, not of MCP servers
Comment by pama 23 hours ago
There are usecases of MCPs (e.g. serving outside customers via proprietary tools), but composability has not been in the minds of the early users of MCP and it is one of the hundreds of little practical drawbacks they have when used in house.
Comment by Atiscant 23 hours ago
Comment by littlecranky67 1 day ago
It is the same with a wepapp: You could argue you don't neex browser apps if the user just install a software on their computer, but we feel better using the sandboxing environment of your browser.
Comment by toddmorey 1 day ago
Be surprised how far apps can get with just solid & well documented APIs. Modern agents are smart!
Comment by imtringued 1 day ago
Then you don't need an MCP server per service anymore, you just need one and a whitelist of authorized services.
Comment by mmnfrdmcx 1 day ago
Comment by sick_of_slop 1 day ago
Comment by dominotw 1 day ago
Comment by hammadtariq 22 hours ago
Comment by okeuro49 21 hours ago
Comment by cityofdelusion 1 day ago
Comment by flyingsky 1 day ago
Comment by Felar 6 hours ago
Comment by BSPtree 9 hours ago
Comment by LoganDark 13 hours ago
Here's a more concise explainer that doesn't take a whole page.
Most language models can only generate content, like text or images, by default. For a model to perform actions, you need to give it tools. These tools are like functions: the model emits special markers signaling a tool call, which includes the name of the tool as well as parameters for the tool. Models can be instructed to do this, but many models are already trained to emit tool calls when tool definitions are provided.
These special markers around the tool call signal to a surrounding system, called a harness, that the model intends to call a tool. The harness, or the provider, will typically stop generation after collecting a tool call or multiple, execute the tool(s) with the specified parameters, and then restart generation with the results of the tool calls.
(The harness could be a desktop app, or a CLI like Claude Code. Sometimes even websites can offer to connect to hosted or even local MCP servers. Some providers like Anthropic also have a server-side harness, which performs server-side tool calls transparently, sending only the client-side tool calls down to be performed by the client-side harness.)
However, some users want models to be able to call tools that aren't built-in to the harness. This includes tools from third-party developers, as well as custom tools; anything the user wants the model to be able to do. MCP allows a harness to achieve this capability by connecting to an MCP server and exchanging messages to communicate tool calls and receive their results.
The harness can connect to the MCP server in one of two ways: using HTTP Server-Sent Events (legacy) or the newer "Streamable HTTP" to connect to an already-running server, or executing a command as a new subprocess and communicating by writing messages (JSON-RPC) to its stdin and reading responses from its stdout.
Once a connection is successful, the harness asks the server for tool definitions. These are JSON schemas, defining the shape and documentation of expected and allowed parameters for each tool the server offers. The harness can include these tool definitions when calling the model. The server can also provide documentation that applies to all tools, and which can also be included to the model.
When the model tries to call one of the server's tools by emitting a tool call, the harness sends the tool call and its parameters as a message to the server, which may perform the desired action before returning a response back to the harness. The harness then communicates this response to the model to continue the model's turn.
This omits some implementation details of precisely how protocols are implemented, because that knowledge is relevant only to the protocols themselves and not to MCP servers in specific. That is one distinction LLMs struggle to make in explainers. It assumes some basic familiarity with certain computing concepts like processes or stdio. In all cases, a search engine should help you study up on anything you might not understand yet.
Comment by curtismager20 22 hours ago
Comment by wolvesechoes 9 hours ago
Comment by BatchJob 13 hours ago
Comment by bibelo 1 day ago
Comment by vatsachak 1 day ago
Comment by 1ba9115454 1 day ago
Don't believe me? Try connecting Blender to Codex.
Comment by Aurornis 1 day ago
Their secret, which is not very secret, is to ask the AI to help them set it up.
I think this might follow that bell curve meme where people on the unsophisticated and highly sophisticated ends of the curve are leveraging the LLM for MCP setup (and other routine tasks) while some in the middle are making it more complicated than it needs to be because they still think of it as outside the domain of AI-assisted work.
The biggest problem I see isn’t getting MCP set up, it’s people getting stuck using the wrong tools for the job. I’ve improved a lot of workflows by observing what someone is doing and suggesting a better tool for the job.
Comment by spike021 1 day ago
Also, Apple just announced their preview for new Siri AI capabilities and part of that is they seemingly are going to add MCP to apps (if developers of the apps want to) as tools, which would enable Siri to use functions of apps, similarly to Claude Desktop using functions of services through MCP tool calls.
Comment by skipants 23 hours ago
At my job we maintain an MCP for our admin portal/prod data and it's seen a lot of use. Our admin side was a mess to use so allowing admins to ask questions about prod data has been a huge help for everyone.
And for myself personally, connecting MCPs to Claude has also been an insanely huge productivity boost. It's really nice to just ask for a link to Datadog when I want to monitor some change I made, instead of trying to craft a query myself.
Comment by francisofascii 23 hours ago
Comment by jonathanlydall 23 hours ago
Now a Claude/Codex/etc user installs a few MCP servers and before they know it their context is already largely used up with tool schemas and guidance before they’ve sent their first prompt.
In response to this harnesses aggressively “hide” most of this to agents, so the agents land up doing best guesses on how to use tools, doing things like sending wrong argument names, etc.
Turns out that a really effective strategy to deal with this is to make two tools only, one to execute a script (eg in JS) and another on how to get guidance on how to craft a script.
When an agent needs to use the tool, they look at the “help” and then craft JavaScript (something they’re already very good at). If the execute endpoint returns adequately descriptive errors with stack traces then the agent can pretty much always self fix their mistake.
We worked this out for ourselves in our own product and we found out after that Cloudflare wrote a blog post on how they use the same strategy.
Comment by michaelscott 22 hours ago
Comment by camcil 1 day ago
Just like us to take something and limit it back to being useless until we implement the feature (tools).
The real "race to market" winners will just throw the credentials into the SQL connector and let 'er rip like a real man.
Comment by huntertwo 1 day ago
Comment by otabdeveloper4 1 day ago
No it doesn't. It adds yet another Nth "API standardization" spec.
Comment by Culonavirus 1 day ago
That's what we started doing... and never looked back. Now we're thinking of exposing parts of the database in readonly mode to in-house staff (non-developers) so they can vibe code whatever the hell kind of tools they want...
Comment by camcil 19 hours ago
Comment by JimmyBiscuit 23 hours ago
Is it that bad? I have Blender connected to Claude (and my mind is quite blown by how great it is to use) and it was quite easy if you could follow the tutorial (the hardest part was reading that you have to click on something twice)
Comment by mmnfrdmcx 1 day ago
Comment by mattlondon 22 hours ago
It's not like it really brings anything to the table that was missing or even needed.
I mentally group it with XML at this stage. Useless bloat peddled by people trying to sell something to people who don't really understand it much. Sort of thing I expect IBM to turn up and sell some Websphere Enterprise MCP Router Platform or something.
Comment by steve_adams_86 21 hours ago
It was possible without MCP, but arguably this convention made the whole thing a bit more reliable and consistent. It also provides some safe guards against how people might get this data alternatively. People can now ask "What was the ocean acidity like for January 2016 to March 2017 in the Salish Sea? And Claude will reliably draw up a graph for all stations in the Salish Sea monitoring this parameter, report which values have or have not been QC'd, show a map of the stations' locations, etc.
It works better than a skill. It allows me to integrate a protected endpoint more easily for the end users. It only knows about read-only endpoints. No risk of people handing credentials to Claude to make it easier. Overall it makes it pretty seamless to bundle a bunch of domain knowledge into the server, providing access and empowerment to a team of scientists who can but would really prefer not to write API queries when they have one-off questions about our data.
It could also be done with a CLI or something, but, the goal is to provide a powerful interface using simpler tools. An API or CLI would defeat the purpose.
Comment by mattlondon 21 hours ago
I ask Claude these sort of things all the time and it writes its own SQL queries or writes its own API client to query multiple sources. Is that not a better approach to remove the MCP middleman?
Comment by steve_adams_86 20 hours ago
That aside, the MCP middleman in this case provides a few things:
1. Most importantly, it models and enforces the complex domains of the API and underlying data in a way that most people can't easily, so it maps English requests to sensible queries effortlessly. Claude uses discovery endpoints and constructs queries in seconds, is instructed to check parameters about each endpoint, and generally handles a lot of domain-specific concerns that users typically won't have a full grasp of.
Imagine a sensor network with dozens of stations and thousands of sensors. Which one should you query, for which type of data? What parameters does it take? How granular is the data? These are easy to keep track of if you're familiar with the station and have some API requests on hand that you lean on frequently. It's much harder when you want to know things about an area or type of sensor data you're less familiar with. The MCP server solves for this quite well. You can write things like "How much chlorophyll was in the ocean in the summer months of 2025 near Victoria, BC?" and it can map that to stations, then to sensors (some named chlorophyll, some named fluorometers, some named after the manufacturer's model name, etc). And yes, this can be done with a skill, but my experimentation with this was disappointing. The MCP server provides far more consistent results.
2. Less important, but the API doesn't presently differentiate between users. They have access or they don't. The writable endpoints should not be accessible to Claude, so handing it a token is not acceptable. The MCP server ensures Claude's use of the token is limited. This takes less work than rebuilding auth for the API. We could use a read-only proxy instead, but on its own, this wouldn't help my team much.
3. The API already does return consistent results. The problem lies more in the direction of knowing how to query it.
I suppose a followup point is that the code driving the MCP server is testable and provides some guarantees about the system's behaviour, which allowed me to progressively improve its end results and determinism. I don't know how to do that with skills. I'm also solving a problem for less technical users, so I can't set them loose with a skill and a terminal to begin with.
Comment by pyrale 21 hours ago
I just don't understand how the whole concept doesn't run afoul of the bitter lesson: agents will figure our tools eventually, they don't need their own.
Comment by hnlmorg 21 hours ago
XML has features that other documents don’t support and thus can be useful in some domains.
Likewise, I find MCP extremely useful for accessing enterprise systems using OAuth. It’s secure, easy to define access controls, and easy to audit.
Comment by mattlondon 21 hours ago
Comment by hnlmorg 20 hours ago
Comment by grey-area 19 hours ago
It will go the way of Openclaw, Personal Agents, Scaffolding, Skills and all these other things people prematurely tried to build around LLM models.
Comment by padolsey 1 day ago
Comment by recursive 1 day ago
Comment by HoldOnAMinute 22 hours ago
Comment by flr03 1 day ago
Comment by dingaling911 22 hours ago
The same reasons those were needed is why this is needed.
Comment by ddellacosta 1 day ago
I swear when I see stuff like this is makes me depressed about the future of our industry. Pick up an Edward Tufte book or something and use your brain
Comment by brazukadev 1 day ago
Comment by drop_star 1 day ago
Comment by rwilinski 1 day ago
Comment by jimbokun 1 day ago
Comment by rwilinski 1 day ago
Comment by dools 19 hours ago
Comment by enjoyyourlife 1 day ago
from mcp.server.fastmcp import FastMCP
Comment by huntertwo 1 day ago
“Claude add an mcp for this”
Comment by spacecadet404 17 hours ago
Comment by not-tarnished 1 day ago
Comment by coindefdev 3 hours ago
Comment by urios 10 hours ago
Comment by manu69x 23 hours ago
Comment by farnulfo 18 hours ago
Comment by Mantis99 1 day ago
Comment by pnb1 22 hours ago
Comment by BurakSakmak 1 day ago
Comment by f34rffm 21 hours ago
Comment by amelius 1 day ago