跳到正文
DEV Community· CeledogAI·· 6 天前AI 評分33

MCP 為何看似簡單?因為你看錯了重點

MCP Looks Simple Because You're Looking at the Wrong Thing

AI 導讀

MCP 看似簡單,實際上是因為規格很少作出決定,讓身份驗證、錯誤處理和工作階段管理等問題留給實作者處理。作者在整合檢索伺服器與生成伺服器時,遇到 MCP 未有處理的競態問題、不可預測的逾時及工作階段狀態外洩。MCP 適用於快速內部原型等場景,但簡單易上手不代表容易維護,團隊仍需預先處理規格未涵蓋的工作。

正文

CeledogAI

I watched a team ship an MCP server last Tuesday. Three engineers, one afternoon, a tool that connected their app to a vector database. They came away proud. The docs made it look trivial — five lines of code, a JSON schema, done. I stayed quiet because I knew what was coming next.
MCP is dead simple. That sentence sounds like a feature. It isn't. It's a warning label wrapped in marketing copy.
The Model Context Protocol was designed to solve a real fragmentation problem. Every AI app I've touched has been stitching together providers, tools, and data sources with custom adapters that look nothing alike. One uses REST, another gRPC, a third some proprietary SDK that changes without notice. The protocol promised a single interface for connecting language models to external systems. On paper, that's beautiful. In practice, the simplicity is exactly where things fall apart.
I ran into this last spring when our team evaluated MCP for internal tooling. We spent two weeks prototyping three different integrations. The setup itself took maybe an hour total. Then reality hit. Our auth layer didn't map cleanly to MCP's assumptions. Our error handling became a patchwork of try-except blocks because the protocol defines so little about what happens when things go wrong. And every time we wanted to add a new capability — streaming responses, batch operations, retry logic — we were back to writing custom glue code anyway.
The protocol stripped away complexity by making almost no decisions. That's the core tension. Simplicity here doesn't mean well-designed. It means under-specified. When you build something this minimal and call it "easy," the assumption becomes that ease of entry equals ease of maintenance. Those are different problems entirely.
What actually tripped us up wasn't the initial implementation. Anyone can spin up a basic MCP server in an afternoon. It was the gaps between servers, the moments when two tools needed to talk to each other through a protocol that assumes they won't. We had a retrieval server and a generation server working fine independently. Combined, they exposed race conditions in context management that MCP doesn't address. Timeouts became unpredictable. Session state leaked across requests in ways that only showed up under load.
The documentation treats these as edge cases. My experience labeled them as the default state.
There's a deeper issue worth naming. When a protocol positions itself as straightforward, teams skip the hard thinking. We rushed past architectural decisions because everything felt accessible. A more complex system would have forced us to slow down and plan. MCP's simplicity created the illusion that planning wasn't necessary. That illusion is expensive.
I've seen the same pattern repeat across organizations I consult with. Startups launch MCP-integrated products in days. Six months later, they're paying technical debt interest on every change request. The team that built fast now moves slowly because the foundations were laid on sand. Not because MCP is broken. Because simple things scale poorly without deliberate effort invested upfront, and nobody invests that effort when the entry barrier feels non-existent.
The conversation around MCP also tends to ignore who benefits most from its simplicity. Vendor lock-in is still possible even within a standardized protocol. If your entire application logic depends on MCP-specific patterns, migrating away becomes harder, not easier. The protocol abstracts tool connections but creates dependency on its ecosystem. You trade provider lock-in for protocol lock-in. Both are real costs.
Some people argue that MCP's minimalist philosophy is intentional — that staying out of the way lets innovation happen organically. I'm not convinced. Good abstractions don't disappear. They make decisions for you so you can focus elsewhere. A truly useful protocol would handle authentication patterns, error propagation, and session lifecycle rather than leaving those as exercises for implementers.
This isn't a death knell for MCP. It serves certain use cases adequately. Quick internal prototypes. Single-purpose tools with well-defined boundaries. Teams willing to accept that simplicity today might compound into complexity tomorrow. But calling it simple is misleading shorthand for "requires significant unspoken work beyond what the specification describes."
The engineering community should stop treating protocol simplicity as an unquestionable virtue. What matters is whether simplicity reduces actual developer burden or merely shifts it somewhere invisible. MCP shifted ours. Ours is a cautionary signal, not a general principle.
How do you measure whether a protocol's simplicity is real, or just deferred complexity?

來源:DEV Community · dev.to