Construire des serveurs MCP 2026 scalables et sans état (une analyse technique approfondie)
Guide pratique pour créer des serveurs MCP 2026 scalables et sans état (analyse technique approfondie) : contrats, vérifications et emplacements de code prêts à l’emploi pour les équipes qui implémentent ce modèle.
Utilisez ceci comme une version révisée destinée aux opérateurs des idées présentées dans « Stateless Model Context Protocol: Building Scalable MCP 2026 Specification Servers (Technical Deepdive) » : étapes claires, emplacements de code ordonnés et notes de récupération permettant de gérer les transferts. L’étape « Aperçu » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le projet passe de la démonstration aux environnements partagés.
Le goulot d’étranglement lié à l’état : pourquoi les MCP antérieurs à 2026 ont eu du mal à s’adapter à grande échelle
Pour l’étape « The Stateful Bottleneck Why », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
+--------------------------------------------------------------------------+
| Pre-2026 Stateful Architecture |
| |
| +--------------+ WebSocket / SSE +-----------------------+ |
| | Client Agent | <=======================> | MCP Server Pod A | |
| +--------------+ (Session Pinned) | (In-Memory Session) | |
| +-----------------------+ |
| | |
| State Lookup |
| v |
| +-----------------------+ |
| | Central Redis Cache | |
| +-----------------------+ |
+--------------------------------------------------------------------------+
La friction liée à l’affinité des sessions
Pour l’étape « The Friction of Session », définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Dans les coulisses de MCP 2026–07–28 : routage des en-têtes et RPC auto-descriptif
Pour l’étape « Under the Hood », définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Préférez des sorties structurées avec validation de schéma à du texte libre lorsque l’étape suivante consiste en du code ou une appel d’outil. Pour l’étape « Under the Hood », définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.
+--------------------------------------------------------------------------+
| MCP 2026-07-28 Stateless Architecture |
| |
| +--------------+ HTTP POST (Self-Describing) +---------------+ |
| | Client Agent | --------------------------------> | Round-Robin | |
| +--------------+ Headers: Mcp-Method, Mcp-Name | Load Balancer | |
| +---------------+ |
| | |
| Any Worker Pod | |
| +----------------------+--------+ |
| | | | |
| v v v |
| +--------+ +--------+ +---+|
| | Pod 1 | | Pod 2 | |...||
| +--------+ +--------+ +---+|
+--------------------------------------------------------------------------+
JSON-RPC 2.0 auto-descriptif via _meta
Lors de la phase d’implémentation du JSON-RPC 2.0 auto-descriptif, notez d’abord les exigences du contrat : entrées requises, signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de maintenir l’honnêteté des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Mémorisez les instructions stables du système ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage.
{
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"name": "query_database",
"arguments": {
"query": "SELECT count(*) FROM users WHERE status = 'active';"
}
},
"id": "req-98421",
"_meta": {
"protocolVersion": "2026-07-28",
"clientInfo": {
"name": "AutonomousAgentWorker",
"version": "4.1.0"
},
"progressToken": "tok_998122",
"traceContext": {
"traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
}
}
}
En-têtes de routage HTTP de niveau 7 obligatoires
Lors du traitement de l’étape obligatoire de routage HTTP au niveau 7, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Mémorisez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de surconsommation.
Découverte des serveurs et mise en cache intelligente
Lors du traitement des étapes de Découverte du serveur et d’Intelligence, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Mémorisez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage. Lors du traitement des étapes de Découverte du serveur et d’Intelligence, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés.
{
"jsonrpc": "2.0",
"result": {
"protocolVersion": "2026-07-28",
"capabilities": {
"tools": { "listChanged": false }
},
"serverInfo": {
"name": "Scalable-Stateless-MCP-Server",
"version": "2.0.0"
},
"cacheControl": {
"ttlMs": 3600000,
"cacheScope": "public"
}
},
"id": "disc-001"
}
Création d’un serveur sans état pour la production : FastAPI, FastMCP 2.0 et OAuth 2.1
La phase de création d’un serveur sans état pour la production fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple parfait, un cas d’échec et des notes de rollback avant d’élargir le périmètre. Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stockages de secrets et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Fixez un budget de tokens par tour et par session. Les outils agents élargissent rapidement le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
+-----------------------------------------------------------------------------+
| Stateless Request Dispatching |
| |
| Client Request w/ Bearer JWT |
| + Header: Mcp-Method: tools/call |
| + Header: Mcp-Name: query_database |
| |
| │ |
| ▼ |
| +------------------------------------+ |
| | OAuth 2.1 Bearer Validation | ---> (401 Unauthorized if invalid)|
| | verify_token() | |
| +------------------------------------+ |
| │ |
| ▼ Decoded Claims (user_info) |
| +------------------------------------+ |
| | Header-Based Route Dispatcher | |
| | extract Mcp-Method / Mcp-Name | |
| +------------------------------------+ |
| │ |
| ├──────────────────────────────┐ |
| ▼ ▼ |
| [ tools/call ] [ server/discover ] |
| Execute tool handler Return cached capability |
| Scoped to user_info['sub'] manifest & protocol specs |
+-----------------------------------------------------------------------------+
from fastapi import FastAPI, Depends, HTTPException, Header, Security
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel
from typing import Dict, Any, Optional
import jwt
app = FastAPI(title="Stateless MCP 2026 Server")
security = HTTPBearer()
JWT_SECRET = "production_secret_key"
JWT_ALGORITHM = "HS256"
def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)) -> Dict[str, Any]:
"""
Validates incoming OAuth 2.1 Bearer JWT tokens.
Converts the MCP server into a standard OAuth Resource Server.
"""
try:
payload = jwt.decode(credentials.credentials, JWT_SECRET, algorithms=[JWT_ALGORITHM])
return payload
except Exception:
raise HTTPException(status_code=401, detail="Invalid Bearer token")
class JsonRpcRequest(BaseModel):
jsonrpc: str = "2.0"
method: str
params: Optional[Dict[str, Any]] = None
id: Any
_meta: Optional[Dict[str, Any]] = None
@app.post("/mcp")
async def handle_mcp_request(
request: JsonRpcRequest,
mcp_method: Optional[str] = Header(None, alias="Mcp-Method"),
mcp_name: Optional[str] = Header(None, alias="Mcp-Name"),
user_info: Dict[str, Any] = Depends(verify_token)
):
"""
Stateless MCP Request Handler conforming to the 2026-07-28 specification.
Prefers Mcp-Method and Mcp-Name headers for fast execution dispatch.
"""
effective_method = mcp_method or request.method
# Route: Tool Execution
if effective_method == "tools/call":
tool_name = mcp_name or (request.params.get("name") if request.params else None)
arguments = request.params.get("arguments", {}) if request.params else {}
if tool_name == "query_database":
query = arguments.get("query")
user_id = user_info.get("sub", "anonymous")
# Context is scoped directly to the authenticated token claims
return {
"jsonrpc": "2.0",
"result": {
"content": [
{
"type": "text",
"text": f"Executed query '{query}' for user {user_id}"
}
]
},
"id": request.id
}
# Standard JSON-RPC Method Not Found (-32601)
return {
"jsonrpc": "2.0",
"error": {
"code": -32601,
"message": f"Tool '{tool_name}' not found"
},
"id": request.id
}
# Route: Server Discovery
elif effective_method == "server/discover":
return {
"jsonrpc": "2.0",
"result": {
"protocolVersion": "2026-07-28",
"capabilities": {
"tools": {"listChanged": False}
},
"serverInfo": {
"name": "Scalable-Stateless-MCP-Server",
"version": "2.0.0"
}
},
"id": request.id
}
# Unsupported Protocol Method
return {
"jsonrpc": "2.0",
"error": {
"code": -32601,
"message": f"Method '{effective_method}' unsupported"
},
"id": request.id
}
Gestion du trafic sans analyse au niveau 7 : configuration d’Envoy et de Gateway
La phase de gestion du trafic Layer-7 Zero-Parsing fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Documentez en même temps le parcours optimal et celui de récupération. Les tentatives répétées, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Prévoyez un budget de tokens par tour et par session : les outils agents élargissent de manière importante le contexte ; des plafonds stricts empêchent que les démonstrations se transforment en factures inattendues.
routes:
- match:
prefix: "/mcp"
headers:
- name: "Mcp-Method"
exact_match: "tools/call"
- name: "Mcp-Name"
exact_match: "query_database"
route:
cluster: mcp_database_tools_cluster
- match:
prefix: "/mcp"
route:
cluster: mcp_general_cluster
Gérer l’état sans sessions : requêtes à plusieurs allers-retours et compromis
La phase de gestion de l’état sans sessions fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus embrouillé. Fixez des limites de tokens par tour et par session. Les outils agents élargissent lourdement le contexte ; des plafonds stricts empêchent que les démos ne se transforment en factures inattendues. La phase de gestion de l’état sans sessions fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’une démo à des environnements partagés.
Boucle interactive de demande multi-allers-retours (MRTR)
Pour l’étape MRTR (Multi Round-Trip Request), définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Analyse des compromis architecturaux
Pour l’étape d’analyse des compromis architecturaux, définissez les entrées, le responsable de cette étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours idéal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Déploiement cloud-native : Échelle de MCP sur Kubernetes et Serverless
Pour l’étape MCP de mise à l’échelle des déploiements cloud-natifs, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un pipeline embrouillé. Préférez des sorties structurées avec validation de schéma à du texte libre lorsque l’étape suivante consiste en du code ou une appel d’outil.
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: mcp-tool-server-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: mcp-tool-server
minReplicas: 3
maxReplicas: 50
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
- type: External
external:
metric:
name: nginx_ingress_controller_requests
target:
type: Value
averageValue: 1000m
Conclusion et prochaines étapes
Pour l’étape Conclusion et Prochaines étapes, définissez les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Ressources pour plus d’informations
Pendant l’étape des Ressources pour obtenir plus d’informations, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des jetons ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Liste de contrôle opérationnelle
Lorsque vous travaillez sur l’étape de la Liste de contrôle opérationnelle, écrivez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste garantit que les modifications ultérieures du code restent transparentes.
Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès, et refusez les terminaisons partielles silencieuses.
Cachez les instructions système stables ainsi que les schémas des outils. L’envoi répété d’un préambule identique est une cause fréquente de problèmes.
Exposez les outils ayant des schémas restreints ainsi que des étiquettes explicites indiquant leurs effets secondaires. Les hôtes doivent savoir quels appels modifient l’état avant d’approuver automatiquement.
Ajoutez un test de base qui exerce le chemin critique dans l’CI en utilisant des fixtures, et non des API payantes en ligne, chaque fois que le budget le permet.
Dokumentez à la fois le chemin optimal et le chemin de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure.
Au préalable de promouvoir l’ensemble technique, figez les versions, conservez une transcription exemplaire pour le chemin critique, et vérifiez les étapes de réversion. Les environnements partagés nécessitent des limites de fréquence, des contrôles d’attribution, ainsi qu’un responsable clair pour la rotation des secrets. Préférez une fiabilité solide à des démonstrations brillantes mais ponctuelles.
Note de batch pour ecba7bb3b9c6 : gardez les clés du fournisseur hors du répertoire, fixez un plafond pour les tokens par session, et stockez les transcriptions à côté des fichiers de configuration d’évaluation afin que les remplacements ultérieurs de modèles restent comparables.