MCP 成为无状态……且无会话的协议

MCP devient un protocole sans état… et sans session

Silicon.fr by Clément Bohic 2026-07-29 09:32 Original
摘要
MCP协议最新规范(2026-07-28)正式转为无状态、无会话模式,以降低复杂性和提升弹性。TypeScript、Python、Go、C#等主流SDK已全面支持,Rust SDK处于测试阶段;需要会话的应用必须锁定在旧版(2025-11-25),至少继续支持12个月。这一转变简化了负载均衡与部署,但核心协议移除了任务原生支持,并引入多轮请求(MRTR)等新机制。

MCP协议最新规范(2026-07-28)正式转向无状态、无会话架构,彻底废除先前的有状态会话机制。原本的设计方案是默认无状态,并保留有状态作为备选,但考虑到这样会大幅增加协议复杂度,迫使客户端与服务器同时维护两套独立逻辑,从而扩大Bug表面,该共存方案最终被放弃。以另一种形式重新引入会话的想法也因现有应用普遍难以正确实现会话概念而遭否决。任何需要继续使用会话的场景,必须将服务器固定在上一版规范(2025-11-25),该版本仍将获得至少12个月的支持。

在协议层面,无状态意味着每个请求各自独立、可单独解析,有利于提升系统弹性和可靠性。与之相对,有状态模式依赖初始握手建立持久状态,导致客户端会话与特定服务器实例绑定,无法直接使用简单的无状态负载均衡器(如L4/L7轮询),除非引入会话亲和性等复杂机制。一旦负责会话的实例故障,状态即告丢失,客户端必须检测故障、重建连接并重新完成全部能力协商,同时双方都需实现繁琐的生命周期管理逻辑。新模型将原先在握手中集中完成的协议版本协商与能力发现,下放到请求层面,通过`_meta`对象及专用端点予以实现。

应用层面同样为了适配无会话特性进行了根本性调整。原本在2025-11-25规范中纳入核心协议的“任务”(Tasks)——即用于表征批处理等操作的替代执行模式——现已移出核心,转为官方扩展。状态管理的替代方案则采用由服务器端生成、以参数形式传递的显式标识符。但这一设计也带来待明确的问题,例如缺乏传达标识符生存时间(TTL)的原生机制,以及上下文压缩时可能产生孤立状态的风险。

另一项重要变更是引入了MRTR(多轮往返请求)模式,使服务器可以请求更多信息以处理某一请求,且无需依赖服务器实例间的共享存储层或有状态负载均衡器。授权部分也迎来显著进展,最关键的是采用CIMD(客户端ID元数据文档)取代DCR(动态客户端注册),后者暂时保留以维持向后兼容。同时,客户端凭证现与其颁发机构绑定,不可跨授权服务器复用。

目前所有主流一级SDK(TypeScript、Python、Go、C#)均已完整支持新版规范,Rust SDK也已处于Beta阶段。

Summary
MCP’s latest specification (2026-07-28) removes sessions entirely, making the protocol fully stateless to enhance elasticity and reliability, while session support is frozen in the prior version for at least 12 months. The change simplifies load balancing and reduces complexity, with companion updates like tasks becoming an extension, new server-generated IDs for application state, and the Multi Round-Trip Requests (MRTR) pattern. Authorization also shifts to Client ID Metadata Documents (CIMD) with issuer-bound credentials, and all major SDKs (TypeScript, Python, Go, C#, plus Rust in beta) now support the new stateless paradigm.

The Model Context Protocol’s latest specification (2026-07-28) eliminates sessions entirely, making MCP a fully stateless protocol. Earlier proposals envisioned a default-stateless option with stateful sessions reserved for edge cases, but that dual-mode approach was rejected because it would have significantly increased protocol complexity, forcing clients and servers to maintain separate logic paths and expanding the potential for bugs. Plans to reintroduce sessions in alternative forms were also abandoned, as existing applications already implemented the session concept poorly. For those who still require sessions, the only path is to pin servers to the previous spec version (2025-11-25), which will be supported for at least 12 more months.

In the new stateless paradigm, each request is self-contained, enhancing elasticity and reliability. The old stateful model depended on an initial handshake to establish persistent state, binding a client session to a specific server instance. That prevented the use of simple stateless load balancers (e.g., L4/L7 round-robin) without adding complexity like session affinity. An instance failure meant complete state loss, obliging the client to detect the outage, reconnect, and redo the full negotiation—plus implementing lifecycle management logic on both sides. The stateless design unbundles operations that were previously handled in block during the handshake: protocol version negotiation and capability discovery now occur on a per-request basis via the `_meta` object and dedicated endpoints.

Moving to sessionless operation required reworking several adjacent components. Tasks, an alternative execution mode useful for batch operations that entered the protocol in the 2025-11-25 spec, now leaves the core and becomes an official extension. Application-level state management no longer uses sessions; instead, it relies on explicit identifiers generated by the server and passed as arguments. This shift raised issues that needed clarification, including the absence of a native mechanism to communicate identifier TTLs and the risk of orphaned state when context is compressed.

Another major addition is the Multi Round-Trip Request (MRTR) pattern, which lets servers signal that they need more information to process a request without requiring shared storage layers or stateful load balancing. In authorization—typically the most integration-intensive area—Dynamic Client Registration (DCR) is replaced by Client ID Metadata Documents (CIMD), though DCR support remains for backward compatibility. Client credentials are now bound to their issuer, prohibiting reuse across different authorization servers. All primary SDKs—TypeScript, Python, Go, and C#—support the new spec, with Rust support available in beta.

Résumé
La dernière spécification MCP (2026-07-28) bascule entièrement vers un modèle sans état ni session, abandonnant le mode stateful pour réduire la complexité et améliorer l’élasticité et la fiabilité. Les applications doivent désormais gérer l’état via des identifiants serveur explicites, les tâches deviennent une extension officielle, et l’autorisation s’appuie sur CIMD avec des credentials liés à leur émetteur, le tout déjà intégré aux SDK TypeScript, Python, Go et C#.

MCP est désormais un protocole sans état… et sans session. La dernière version de la spec (2026-07-28) entérine ce changement majeur.

Initialement, il était plutôt envisagé que MCP devienne stateless par défaut, avec le stateful en option de dernier ressort. Ce schéma de coexistence n’a pas été retenu, au motif qu’il aurait largement accru la complexité du protocole. Clients et serveurs auraient eu à maintenir des logiques séparées, avec une surface de bugs d’autant plus grande. Quant à l’idée de réintroduire les sessions sous une autre forme, elle a aussi été abandonnée… au motif que les applications existantes implémentaient déjà mal le concept.

Quiconque souhaite continuer à utiliser des sessions doit donc épingler son serveur MCP sur la version précédente de la spec (2025-11-25). Elle restera prise en charge encore au moins 12 mois.

Du sessionless au niveau protocole…

Dans le paradigme stateless, chaque requête est indépendante, interprétable de manière isolée. Cela favorise l’élasticité et la fiabilité. En tout cas par rapport au paradigme stateful.

Ce dernier implique un handshake initial qui établit un état persistant. Une session client étant liée à l’instance de serveur contenant cet état, il en découle l’impossibilité d’utiliser un load balancer stateless simple (type round-robin L4/L7). À moins d’implémenter des mécanismes qui ajoutent de la complexité, comme l’affinité de session.

Sur le sujet de la fiabilité, le modèle stateful implique qu’en cas de panne de l’instance serveur gérant une session, on perd l’état. Le client doit alors détecter la panne, réétablir une connexion et refaire toute la négociation.

L’approche stateful suppose aussi d’implémenter, côté client et serveur, une logique de gestion de cycle de vie.

Le modèle stateless est censé abaisser ces barrières à l’entrée. Il dégroupe des opérations jusque-là gérées en bloc lors du handshake. En particulier, la négociation de version de protocole et la découverte de capacités. Elles se font désormais au niveau des requêtes, à travers l’objet _meta, avec des endpoints spécifiques.

… et au niveau application

Le passage au stateless et au sessionless a exigé des travaux sur de nombreux composants annexes de MCP. Par exemple les tâches. Ce mode d’exécution alternatif, utile pour représenter notamment, les opérations de batch, avait été intégré dans la spec 2025-11-25. Avec la nouvelle version, il sort du cœur du protocole et devient une extension officielle.

Il a aussi fallu instaurer une alternative aux sessions pour la gestion d’état au niveau des applications. La solution retenue se fonde sur des identifiants explicites générés côté serveur et transmis en tant qu’arguments. Plusieurs éléments ont dû être clarifiés dans ce cadre, comme l’absence de mécanisme natif pour communiquer le TTL de ces identifiants ou le risque de production d’états orphelins en cas de compression du contexte.

Du stateless également pour les demandes d’informations supplémentaires par les serveurs

Entre autres changements majeurs, la spec 2026-07-28 introduit aussi le pattern MRTR (Multi Round-Trip Requests) comme moyen, pour les serveurs, de signaler qu’il leur faut des informations supplémentaires pour traiter une requête. Son principale avantage : pas besoin de couche de stockage partagée entre instances de serveurs, ni de load balancer stateful.

Il y a également des avancées sur la partie autorisation (la plus coûteuse en effort d’intégration). En particulier, l’adoption de CIMD (Client ID Metadata Documents) à la place de DCR (Dynamic Client Registration), qui reste pour le moment pris en charge pour la rétrocompatibilité. Les authentifiants clients sont en outre désormais liés à leur émetteur : on ne peut plus les réutiliser entre serveurs d’autorisation.

Tous les SDK de premier niveau (TypeScript, Python, Go, C#) gèrent la nouvelle spec. Le SDK Rust aussi, mais en bêta.

Illustration principale générée par IA

The post MCP devient un protocole sans état… et sans session appeared first on Silicon.fr.

AI Insight
Core Point

MCP (Model Context Protocol) becomes stateless and sessionless, eliminating session complexity to improve elasticity, reliability, and simpler load balancing for AI integrations.

Key Players

Anthropic — AI research company and creator of MCP, based in San Francisco.

Industry Impact
  • ICT: High — removes need for stateful load balancers and session affinity, lowering infrastructure overhead.
  • Computing/AI: High — core change enables scalable, resilient agent-tool communication with independent request handling.
Tracking

Strongly track — breaking spec change requires all MCP adopters to migrate within 12 months while the prior stateful version remains supported.

Related Companies

No companies linked yet

Categories
软件 云计算
AI Processing
2026-07-29 13:30
deepseek / deepseek-v4-pro