That allows already for self discovery etc.
Everyone who will offer mcp offers a good API anyway.
We don't need packages or functions, we can just write the code ourselves, every time it's needed.
We don't need compilers, the computer understands assembly already.
It's a mismatch of use - MCP isn't about telling the LLM about the APIs. It's also about encapsulating and simplifying them so the LLM isn't manually figuring them out every single time from scratch.
i can script across a billion systems that i would never go through the work of getting auth/setting up all the service calls and workflows for.
the mcp doesnt need any new permissions, its just what ive got website access to
The problem is usually not with listing the APIs. Almost all services have OpenAPI specs, and you can (often too) complain about lack of documentation.
Orchestrating these APIs is the annoying "fuzzy" challenge. Imagine you have a VM service, and you provide a set of APIs. Someone comes asking "How do I create a copy of a VM we have in the US region to EU region but with half the CPU/RAM?"
You might point to your OpenAPI spec and say you can:
var s1 = takeSnapshot(vm1);
var s2 = copySnapshot(s1, 'EU');
var vm2 = createVmFromSnapShopt(s2, sizeOverride).
Ok... but is there a makeACopyOfVmWithHalfCPUAndHalfMemoryInEurope(vm1) API? I don't want to copy that code. In 3 months it'll break because `vm1` is of a type that can't be snapshoted and you'll tell me that I should check `vm1.snapshotable`, or that the new size is invalid in the new region because I should be calling `isSizeAvailable()`If this were an MCP, then it would either orchestrate these APIs "correctly" for me checking as corner cases as possible as (presumably from examples it saw on github). When it misses, it's "oh well, even AI couldn't get it. We can all blame AI everybody" As oppose to when a Human misses and someone is like "how amateurish is the implementation that you're not checking if the vm is `snapshotable` or not?
1. There's less bikeshedding for the authors about whether modifying a field in a user object should be a PUT or a POST replacing the original user object. I've spent a non-trivial amount of time bikeshedding over REST verbs.
2. LLMs don't need to understand the REST semantics of the API. It can just look at available RPC methods and make the RPC call it thinks will work.
I think that's really it.
My impression was that MCP used SSE and that not using websockets was one of the main reasons it isn't enterprise ready - because it requires maintaining server side state which makes it difficult to deploy at scale. Did they change it to websockets?
As for the stateless part, they heard you and made sure to bring sessions back to SSE: https://modelcontextprotocol.io/specification/2025-03-26/bas...
I commented elsewhere on this recently, https://news.ycombinator.com/item?id=44063680, but a huge value of LLMs is you don't need a "universally accepted way to do client discovery" - if you have an exposed API that already supports one of the bajillion standards that expose schema information (e.g. Swagger/OpenAPI, GraphQL, SOAP, etc.), then any decent LLM should just be able to figure out how to use it.
This idea that we need "one more universal interop standard to rule them all" seems to me like a very pre-LLM way of thinking.
I don't know jf they are doing it well with MCP, but if a solution has one extra round trip in the model for a dependent read it has to reprocess the entire context or store it into a cache hierarchy possibly burning several hundred gigs of ssd write durability if it isn't a short enough time to cache in system RAM.
Someone should really create a protocol to transfer hyper text where clients could discover resources through embedded links in documents
As such you can make a REST system discoverable via e.g. external schemas (commonly OpenAPI) or self-documentation but there is no guarantee that either exists, and while the latter is intrinsic there is no standard discovery mechanism for the former (cf openapi-specification issues 724 or 2128).
Doesn't seem to have any other real magic. It could be replaced by an additional field which acts as the LLM equivelent of a doc string in python.
Yes, the protocol is not necessarily "enterprise ready" by various definitions, but as the author points out, this is not terribly important, and the history of standards shows us that even messy and "bad" things get widespread adoption because they hit the right notes at the right time for the right people.