> MCP is now the industry standard for connecting LLMs to external tools.

No it isn't. We're still five or ten years away from real standards.

(Anyways it's clear that the future is smaller self-hosted LLMs, so whatever standard eventually emerges will be based on that paradigm.)

Sure, like how we all self-host our own email servers and photo albums? Honestly, I think you’re about as wrong as you could possibly be, both on timelines, and in that I’d argue the arc of consumer tech adoption bends towards centralisation most often.

Standards are already emerging, including MCP, and to say that simply because they’ll evolve and be replaced over time means they’re not ‘real’ now is ridiculous. Look at the early internet and web as examples.

Local models, even accounting for reasonable progress and device performance improvements, will always, inherently, be behind the eight ball compared to SOTA models. While they may be sufficient for the low hanging fruit, I’d not bet against the frontier models being every bit as compelling relatively speaking.

Using weasel words like ‘real’ and ‘x is the future’ is astoundingly arrogant, and anyone claiming with confidence that they’ve got any idea where we’re heading is almost assuredly wrong.

1) It isn't a standard yet, but what else apart from filesystem-mcp can be used for prompts like "write me README.md for this repo" (like really produce the file)

2) For me it is not clear the future is smaller self-hosted LLMs. As of today, most useful for me is to use best models, and those are not self-hosted.

Once we get used to the fact that LLMs exist they won't be sold on the gee-whiz "wow, a talking assistant just like in my sci-fi movies!" factor.

They'll be used for particular language classification and search tasks, and for that you'd want several lighter, faster, cheaper and more specialized models. Not one with an arbitrary "best" score that's based on tricking the Turing test.

so we no longer need langchain and stuff like that, that's a win. But MCP also feels a bit overrated:https://www.lycee.ai/blog/why-mcp-is-mostly-bullshit

I feel like that article doesn't really live up to its title. At the end, its basic point is that MCP isn't a magic bullet (I don't think anyone claimed it was?) and that it has a lot of hype. It also makes it clear why MCP is good (ie don't need to rely on LangChain). Feels like its title should be "Why MCP is a Good Step but Doesn't Solve Agents" or something. But then, it wouldn't enable the millenial urge to use "shit".

I could not find the actual criticism in that article. What's the problem with MCP again? It's the first standard for agents.

http endpoint + function calling can do what MCP do, this extra bad named layer is just jargon festish

Okay, but we should have a standard around that, right? Something like... a protocol?

Standards might not have been _the_ problem, but they were _a_ problem. Before MCP I couldn't distribute a tool call that could be configured by end-users to be used with multiple mainstream clients.

That is not mentioned in the article. I am just becoming familiar with MCP myself so I suggest raising the issue: https://github.com/orgs/modelcontextprotocol/discussions

This is just moving the goalposts, MCP is not supposed to solve every problem with agents. It's meant to make it easier to provide easier, standardised ways for LLMs to interact with external tools, which it has done. Reliability is a completely different problem.

That article seems to miss the point by being incurious about _why_ there is hype around MCP instead of LangChain, LangGrah, SmolAgents, LlamaIndex, etc.

We've had tool call frameworks before, but we haven't had a way of making tools that our clients actually talked to. There was no way to build tools that other people could download and run locally without getting them to switch to a client that baked those tools in. It's like the difference between static linking and dynamic linking, but for tool calls.

Tool calls in any of the agent frameworks are just wrappers around native functions.

MCP let's you handle the processing outside of the agent context, redistribute tools independently, and provide them as either private or public hosted services.

Basically, add an HTTP layer on the existing concept of tools. It is not a replacement for a framework, it is an enhancement of a well established pattern.

> That article seems to miss the point by being incurious about _why_ there is hype around MCP instead of LangChain, LangGrah, SmolAgents, LlamaIndex, etc.

The VCs that were invested in AI companies (like Cursor) would of course need to hype something up like MCPs to get us to build them as little of those tools did not exist.

Cursor already makes $100M+. So why not get behind and integrate this chosen standard to make even more money with more MCP servers.

The last ingredient is to hype it all up on the internet to get everyone building.

A win for the VCs regardless even though it was suspiciously orchestrated as soon as Cursor integrated it.

MCPs aren't specific to Cursor. Rather, they enable any IDE to become a Cursor competitor.

Example: JetBrains released an MCP server plugin for their IDEs recently and it enables Claude Desktop to seamlessly use the IDE for reading and writing files and even compiling or running tests against it.

And that's just one example; there are MCP servers for anything from VSCode to Emacs already. That means almost anyone can now use LLMs to generate code in their IDE of choice, just as they would do with Cursor.

In fact, MCPs are posing a threat to many startups, especially the "wrapper" ones.

I too feel it's bad that companies take VC money and build open standards which let me build faster and target more providers. Seriously, what? I struggle to understand the mindset of someone frequenting HN who can say unironically that "getting everyone building" is a bad outcome.

I'd like some more of that getting everyone building please.

> But MCP also feels a bit overrated:

VCs invested in AI and agentic companies needed a way to get you guys to accelerate agents this year.

So why not "create" artificial hype for MCPs on the internet, since there were little to no MCP servers for LLMs to use despite it being several months old (November 2024) until Cursor integrated it.

This is the true reason why you see them screaming about MCPs everywhere.

So the main criticism is a borderline conspiracy theory about VC's creating artificial hype for it?

Hype isn’t free. Maybe the benefit is mutual, but I can’t tell how Anthropic gets paid.

Anthropic subsidizes an open standard, but proprietary extensions later emerge that lock you into servers from their marketplace or something? I need a sociopath to help me understand this.

The Anthropic models are running underneath everything (Claude Code, Windsurf, Cursor, etc). Whenever someone is using MCP they (in the generalized case, until now) ultimately end up using Anthropic as their LLM and Anthropic gets paid whenever someone does that.

This is literally not true. You can leverage MCP using any model. Even some of the IDEs you mention let you leverage MCP using many model providers.

There's already like a half dozen such "marketplaces" and they all ultimately point to open source repos. If the goal was to lock people in, they did a bad job of it.

there's a reason there's MCP plugins for LangChain. Some companies will need massively customized workflows that LangChain is appropriate for, where it only needs to dig into a couple potentially publically accessed MCPS for things.

I could see a future where companies have their developer portal where now they have their APIs document, the pretty in swagger, the samples, etc, but they'll have a MCP endpoint (potentially), where they're safely exposing the data to an LLM. Your langchain node step to to get context, could call out to some of these hosted/shared mcps where you do standard stuff, like post to a Slack channel, grab some data from a SFDC instance, etc....