MCP devient sans état : Ce que le protocole 2026 change pour les développeurs d'agents IA
Le protocole de contexte de modèle a dépassé son architecture initiale basée sur les sessions. La spécification du 2026-07-28 rend MCP sans état, facilite la mise à l'échelle derrière une infrastructure HTTP standard, et le rend mieux adapté aux agents IA de production. Voici ce qui a changé, pourquoi cela compte, et ce que les développeurs doivent examiner dans les serveurs MCP existants.
Le Modèle Context Protocol s'est rapidement transformé d'un simple moyen de connecter les modèles d'IA aux outils et données en une infrastructure d'agent sérieuse.
Cette évolution a créé un problème.
Les premières générations de serveurs MCP distants étaient conçues autour de sessions au niveau du protocole. Un client initialisait une connexion, le serveur délivrait un identifiant de session, et les requêtes suivantes restaient associées à cette session.
Cela fonctionne bien lorsqu'un client d'IA parle à un seul processus serveur. Cela devient moins attrayant lorsque le même service MCP doit s'étendre à plusieurs conteneurs, régions ou instances cloud.
La spécification MCP 2026-07-28 change fondamentalement cette architecture : le cycle de vie moderne de MCP est sans état au niveau du protocole.
Pour les développeurs construisant des agents d'IA de production, ce n'est pas qu'un détail de protocole. Cela change la manière dont les services MCP peuvent être déployés, mis à l'échelle et intégrés à une infrastructure HTTP conventionnelle.
Pourquoi MCP devait devenir sans état
Les versions précédentes de MCP utilisaient une poignée d'initialisation. Un client se connectait à un serveur MCP, envoyait une requête initialize et négociait des capacités et une version de protocole. Avec Streamable HTTP, un serveur pouvait également délivrer un Mcp-Session-Id identifiant la session lors des requêtes ultérieures.
Si plusieurs instances de serveur MCP sont derrière un équilibreur de charge, l'infrastructure peut donc nécessiter un routage collant ou un stockage de session partagé. La nouvelle architecture supprime cette exigence du protocole lui-même.
Ce qui a changé dans MCP 2026-07-28 ?
La session au niveau du protocole disparaît du cycle de vie moderne. La poignée d'initialisation initialize utilisée par l'ère de protocole précédente n'est plus partie intégrante de ce cycle, et le mécanisme Mcp-Session-Id a été supprimé.
Au lieu de cela, les clients modernes découvrent un serveur et envoient des requêtes contenant suffisamment d'informations sur le protocole pour être traitées indépendamment. Le résultat pratique est important : la requête A et la requête B n'ont plus besoin d'atteindre la même instance de serveur MCP simplement parce qu'elles appartiennent à la même session de protocole.
Un équilibreur de charge conventionnel peut les distribuer entre les instances disponibles.
MCP sans état ne signifie pas applications sans état
Supprimer la session de protocole de MCP ne signifie pas qu'une application ne peut plus maintenir d'état.
Imaginez un outil MCP qui crée un panier d'achats. Au lieu de stocker un panier caché dans une session MCP, l'outil peut retourner un identifiant explicite :
basket_id: basket_84721
Un appel d'outil ultérieur peut accepter cet identifiant :
add_item(
basket_id: "basket_84721",
product_id: "product_42"
)
L'état existe toujours. Il appartient simplement à l'application plutôt qu'au protocole de transport. Ce modèle sera familier aux développeurs web : les API REST exposent régulièrement des identifiants pour des paniers, des tâches, des conversations, des fichiers ou des flux de travail au lieu d'attendre qu'une connexion HTTP se souvienne de l'état de l'application.
Pourquoi cela est important pour la mise à l'échelle horizontale
Considérons un serveur MCP distant fonctionnant sur trois instances d'application :
AI client
|
Load balancer
|
+---------+---------+
| | |
MCP #1 MCP #2 MCP #3
Avec l'état de session au niveau du protocole, l'infrastructure peut devoir maintenir un client particulier attaché à une instance ou répliquer ses données de session. Avec le cycle de vie moderne sans état, chaque requête compatible peut être traitée indépendamment.
Cela rend plus facile l'application de l'équilibrage de charge round-robin, la mise à l'échelle automatique, les conteneurs éphémères, les déploiements progressifs, les environnements sans serveur et les déploiements Kubernetes multi-instances.
La découverte remplace une partie du modèle d'initialisation ancien
S'il n'y a pas d'échange d'initialisation à long terme, un client a toujours besoin de savoir ce que le serveur supporte. Le nouveau cycle de vie introduit la découverte de serveur.
Au lieu de s'appuyer sur des informations négociées une fois et conservées comme état de session, les implémentations MCP modernes peuvent exposer leurs capacités via le modèle de découverte. La spécification 2026 introduit également des informations TTL pour les résultats de liste, permettant aux clients de savoir combien de temps les informations découvertes peuvent raisonnablement être réutilisées.
Pour les grands déploiements, la mise en cache des listes d'outils inchangées réduit l'encombrement inutile.
Les interactions serveur-vers-client devaient aussi changer
Passer au sans état crée un défi plus difficile pour les interactions initiées par le serveur. Supposons qu'un outil est en cours d'exécution et a besoin d'informations supplémentaires de la part de l'utilisateur.
L'architecture MCP 2026 introduit les Requêtes à Plusieurs Allers-Rétours (MRTR) pour soutenir les interactions nécessitant des entrées supplémentaires du client sans restaurer une session de protocole permanente.
Les requêtes initiées par le serveur doivent également être associées à une requête client active. Cela rend les interactions plus faciles à comprendre d'un point de vue infrastructurel et de sécurité.
MCP devient plus facile à comprendre pour les passerelles
Les requêtes MCP modernes peuvent exposer des informations de routage dans les en-têtes HTTP, y compris des informations sur la méthode MCP invoquée. Une passerelle API ou un limiteur de débit peut donc prendre des décisions sans analyser chaque corps JSON-RPC.
Pour les équipes d'infrastructure, cela ouvre la porte au routage conventionnel, à l'observabilité, aux quotas, au limitage de débit et à l'analyse du trafic.
Le travail d'Apigee de Google illustre cette direction : l'infrastructure de passerelle peut exposer des opérations d'une spécification OpenAPI en tant qu'outils MCP et gérer la traduction de protocole plutôt que de nécessiter un ensemble complet séparé de MCP.
La sécurité devient une préoccupation de déploiement première
Mettre à l'échelle MCP n'est utile que si l'accès aux outils peut aussi être contrôlé en toute sécurité.
Le travail de 2026 inclut un durcissement de l'autorisation autour des concepts OAuth et OpenID Connect, y compris une validation plus forte des émetteurs, une isolation des informations d'identification et une gestion des portées.
L'écosystème plus large ajoute également des contrôles administratifs concernant les serveurs MCP pouvant être utilisés. GitHub, par exemple, a introduit des listes blanches MCP d'entreprise en août 2026 afin que les administrateurs puissent contrôler centralisés les serveurs MCP utilisés par les clients GitHub Copilot supportés.
Les serveurs MCP peuvent exposer des bases de données, des systèmes de déploiement, des applications métier ou d'autres capacités privilégiées à un agent d'IA. L'authentification, l'autorisation, les permissions des outils et l'auditabilité appartiennent donc à l'architecture.
Les serveurs MCP existants doivent-ils être réécrits ?
Pas nécessairement.
La transition est soutenue par les SDK officiels. Les implémentations peuvent supporter le trafic moderne tout en conservant le comportement de compatibilité pour les clients de l'ère de protocole antérieure, permettant une migration graduelle plutôt qu'une migration brutale.
Une stratégie de migration sensée est de déterminer si un serveur MCP existant dépend réellement de sessions de protocole. Les outils de type requête/réponse conventionnels peuvent être simples à migrer. Les données de session, les abonnements ou les comportements serveur-vers-client plus anciens peuvent nécessiter plus de travail architectural.
Ce que les développeurs devraient revoir maintenant
Si vous maintenez un serveur MCP, auditez cinq domaines.
Premièrement, identifiez les données d'application stockées implicitement contre une session MCP et déterminez si elles devraient plutôt avoir un identifiant d'application explicite.
Deuxièmement, vérifiez votre version de SDK MCP et le support pour la révision de protocole 2026-07-28.
Troisièmement, examinez les interactions serveur-vers-client et adoptez le modèle de plusieurs allers-retours plus récent si nécessaire.
Quatrièmement, examinez l'authentification et l'autorisation plutôt que de traiter la migration de protocole comme un changement de transport uniquement.
Enfin, testez derrière plus d'une instance d'application. Les requêtes consécutives devraient pouvoir atteindre différentes instances en toute sécurité.
MCP devient une infrastructure, pas seulement un protocole de développement
MCP a commencé comme une couche d'interopérabilité entre les modèles et les capacités externes. Il est maintenant adopté dans les outils de développement d'IA, les plateformes cloud et les écosystèmes d'agents.
Google a intégré MCP dans ses produits et API de développement, tandis que le SDK Apps d'OpenAI est construit sur MCP pour combiner des outils et des données externes avec des expériences interactives à l'intérieur de ChatGPT.
À mesure que l'adoption s'étend, l'infrastructure MCP doit soutenir des charges de travail très différentes des intégrations locales pour lesquelles les premières implémentations étaient optimisées.
Faire du cœur du protocole un protocole sans état est donc une étape importante de maturation.
Pour les développeurs, la leçon est simple : un serveur MCP devrait de plus en plus être conçu comme un service web évolutif, avec un état d'application explicite, des frontières d'autorisation claires et une infrastructure qui ne dépend pas d'une longue session de protocole.
Cela rend MCP moins inhabituel à exploiter — et considérablement plus pratique pour la prochaine génération d'agents d'IA de production.