Guide
Tâches longues en MCP : l'extension Tasks
Comment une opération MCP de plusieurs minutes renvoie un identifiant de tâche au lieu de bloquer : états, interrogation, annulation, saisie en cours.
Mis à jour le
Tous les appels d'outil ne reviennent pas en une seconde : un pipeline d'intégration continue, un traitement par lots ou une validation humaine peuvent durer des minutes. L'extension Tasks de MCP (Model Context Protocol) permet au serveur de renvoyer un identifiant durable au lieu de garder la connexion ouverte ; le client interroge ensuite l'avancement et récupère le résultat, même après une reconnexion. Page rédigée d'après la documentation officielle, lue le 16/11/2026. Pour le contexte, la révision du 28/07/2026 a sorti les tâches du cœur du protocole pour en faire cette extension officielle.
Le catalogue d’outils MCP d’ALMA aide à identifier les opérations à intégrer. Pour une tâche longue, demandez explicitement les mécanismes de suivi et de reprise disponibles ; ils ne découlent pas du seul support de MCP.
Pourquoi ne pas simplement attendre
La documentation donne cinq raisons :
- Pas de connexion longue : beaucoup de clients et d'intermédiaires réseau imposent des délais qui rendent l'attente impraticable au-delà de quelques secondes.
- Résistance aux pannes : l'identifiant de tâche est un repère durable ; si le client redémarre, il reprend l'interrogation avec le même.
- Visibilité : chaque tâche porte un statut et un message facultatif.
- Interaction en cours de route : si la tâche a besoin d'une confirmation, elle passe à l'état
input_required. - Décision côté serveur : le serveur choisit pour chaque requête de créer ou non une tâche.
Le déroulé, étape par étape
- Négociation : le client inclut
io.modelcontextprotocol/tasksdans ses capacités par requête ; le serveur annonce la même extension dans les capacités de sa réponse àserver/discover. - Création : pour une requête prise en charge, le serveur répond par un
CreateTaskResult(resultType: "task") qui contient untaskId, un état initial, une durée de vie et un intervalle d'interrogation conseillé. La tâche est créée durablement avant l'envoi de la réponse. - Interrogation : le client appelle
tasks/getavec letaskId. La réponse donne l'état courant et, si la tâche est terminée, le résultat ou l'erreur. - Saisie en cours : si l'état est
input_required, la réponse contient une tableinputRequests(des elicitations par exemple) ; le client répond avectasks/update. Sur ces demandes de saisie, voir elicitation, sampling et roots. - Fin : à
completed, le champresultcontient ce que la requête aurait renvoyé en mode synchrone ; àfailed, le champerrorcontient l'erreur JSON-RPC. - Annulation :
tasks/cancel, à tout moment.
Les cinq états
| État | Sens |
|---|---|
working |
L'opération est en cours |
input_required |
Le serveur attend une saisie du client |
completed |
Terminée, résultat disponible |
failed |
Erreur JSON-RPC pendant l'exécution |
cancelled |
Annulation devenue terminale ; distincte de la seule demande d’annulation |
completed, failed et cancelled sont terminaux : l'état ne change plus ensuite. L'interrogation est le mode par défaut ; un serveur peut aussi pousser des mises à jour par notifications/tasks, auxquelles le client s'abonne avec subscriptions/listen, chaque notification portant l'état complet de la tâche.
Pour qui écrit un client
La documentation liste cinq obligations : déclarer le support de l'extension, être prêt à recevoir soit le résultat normal soit un CreateTaskResult, interroger en respectant pollIntervalMs, traiter les inputRequests, et conserver les identifiants de tâche de façon durable pour reprendre après un plantage.
Pour qui écrit un serveur
Annoncer l'extension dans server/discover, vérifier que le client l'a déclarée avant de renvoyer une tâche (jamais de tâche à un client qui n'a pas déclaré le support), créer la tâche durablement avant de répondre, servir tasks/get, accepter tasks/update et traiter tasks/cancel de façon coopérative. Si votre serveur enveloppe déjà une interface qui a des identifiants de travaux (déploiement cloud, file d'attente), la documentation suggère de renvoyer une tâche à la création du travail et de la résoudre à sa fin.
Reprise après une coupure
Dès réception du taskId, enregistrez-le avec le contexte métier nécessaire pour retrouver le traitement. Après redémarrage, interrogez cet identifiant au lieu de relancer aveuglément la demande initiale. La durée de conservation annoncée reste une limite : un identifiant durable ne garantit pas un résultat conservé indéfiniment.
Testez aussi la coupure avant réception de l'identifiant. Le serveur peut avoir créé la tâche sans que le client ait reçu sa réponse ; une nouvelle demande risque alors de créer un second traitement. Le mécanisme de déduplication ou de rapprochement métier doit être prévu dans votre intégration.
Enfin, distinguez trois événements dans l'interface : annulation demandée, état terminal cancelled, et compensation éventuelle des effets déjà produits. Une demande acceptée ne prouve pas que des fichiers créés ou des messages déjà envoyés ont été annulés.
À vérifier avant de s'y fier
Comme toute extension MCP, Tasks est facultative et exige un accord explicite des deux côtés. La prise en charge varie selon les clients : consultez la matrice de compatibilité des extensions sur modelcontextprotocol.io et testez avec votre client, par exemple avec MCP Inspector.
Questions fréquentes
À quoi sert l'extension Tasks de MCP ?
À gérer les appels qui durent : au lieu de bloquer la connexion, le serveur renvoie un identifiant durable que le client interroge jusqu'au résultat, même après une reconnexion.
Qui décide qu'un appel devient une tâche ?
Le serveur, requête par requête. Le client déclare le support dans ses capacités par requête et gère les deux formes de résultat possibles.
Peut-on annuler une tâche ?
Le client peut envoyer tasks/cancel à tout moment, mais l'annulation est coopérative : le serveur accuse réception sans être obligé d'arrêter le travail.
Références du carnet
Pages consultées pour écrire cet article :