Aller au contenu
English

Tenir compte des versions

  • Leçon 3
  • 45 min
  • Module 1 : Comprendre le problème d'intégration

Où nous en sommes

Dans la leçon précédente, nous avons lancé le plus petit serveur MCP et lu ses six messages. Mais MCP évolue vite, et beaucoup d'exemples en ligne utilisent d'anciens messages et du code ancien : un tutoriel qui fonctionnait l'an dernier peut échouer aujourd'hui. Dans cette leçon, nous notons les versions dont notre projet dépend, et nous apprenons à reconnaître les anciennes, comme une recette d'un vieux livre de cuisine.

Ce que vous saurez faire

MCP évolue vite, et les anciens exemples sont partout. Notez la révision du protocole, la version du SDK et les hôtes dont votre projet dépend. Reconnaissez les anciens messages et le code ancien. Faites échouer un test quand le SDK installé ne correspond pas à celui que vous avez choisi.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 45 minutes

Ce que vous devez savoir

Votre projet

  • ~/projects/support-mcp, de la dernière leçon, avec l’environnement virtuel actif : python -m pytest -q affiche 10 passed (10 tests réussis).
  • Le dépôt des laboratoires dans ~/projects/nextia-learning-labs. Aucun compte et aucune clé.

Imaginez une fiche de recette tirée d’un vieux livre de cuisine familial. Elle indique « une tasse de farine » et « un four modéré, thermostat à gaz 4 ». Vous la suivez dans une cuisine moderne, avec un four électrique et des tasses métriques. Le gâteau reste plat.

La recette n’avait rien de mauvais. Quelqu’un l’avait écrite pour une autre cuisine, à une autre époque, sans le préciser sur la fiche. Une personne attentive ajoute les détails sur la fiche : quel four, quelle tasse, quelle année pour la farine. La prochaine personne sait alors quoi changer.

Les exemples de code fonctionnent de la même façon. Un exemple qui fonctionnait pour son auteur peut échouer pour vous, car il visait une autre version. Si l’exemple ne précise pas la version, vous la découvrez en rencontrant un échec.

Tomás veut créer un serveur rapidement. Il trouve un tutoriel et copie son code :

tutorial_server.py (copied from an older tutorial)
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("hello-server")
@mcp.tool()
def hello(name: str) -> str:
"""Say hello to someone."""
return f"Hello, {name}!"
if __name__ == "__main__":
mcp.run()

Il l’exécute dans l’environnement virtuel du projet, où le SDK 2.3.0 est installé :

Traceback (most recent call last):
File "…/tutorial_server.py", line 1, in <module>
from mcp.server.fastmcp import FastMCP
File "…/.venv/lib/python3.12/site-packages/mcp/server/fastmcp.py", line 16, in <module>
raise ModuleNotFoundError(_MESSAGE, name=__name__)
ModuleNotFoundError: No module named 'mcp.server.fastmcp'. This is mcp 2.x, where FastMCP was renamed to MCPServer (from mcp.server.mcpserver import MCPServer) and other APIs changed; see the migration guide at https://py.sdk.modelcontextprotocol.io/v2/migration/#fastmcp-renamed-to-mcpserver or pin 'mcp<2' to keep running v1 code.

Cet échec est une chance. Il est visible, et le message indique ce qui a changé. D’autres différences sont plus discrètes. Un client et un serveur peuvent ne pas s’entendre sur les messages eux-mêmes. Une requête échoue alors avec une erreur qui ne mentionne aucune version, comme vous le verrez plus bas. Pour comprendre ces deux types d’échecs, vous devez connaître les différents numéros de version.

Une connexion MCP dépend de trois éléments versionnés. Chacun a son propre numéro.

  1. La révision de la spécification. La spécification est le document qui définit les messages et les règles de MCP. Chaque révision porte sa date de publication comme nom. Ce cours utilise 2026-07-28, la révision stable la plus récente. Les précédentes sont 2024-11-05, 2025-03-26, 2025-06-18 et 2025-11-25. Une date rend l’ordre clair : une date plus récente indique un protocole plus récent.
  2. La version du SDK. Le SDK est la bibliothèque qui écrit et lit les messages pour vous. Ce cours utilise le SDK Python officiel de MCP 2.3.0, le paquet pip nommé mcp. Son premier chiffre, 2, est la version majeure. Une nouvelle version majeure peut renommer des éléments, comme Tomás vient de le voir : FastMCP est devenu MCPServer. La série 1.x reçoit encore des corrections de bogues critiques et de sécurité, mais aucune nouvelle fonctionnalité.
  3. L’hôte et son client. Chaque hôte fournit son propre client, et chaque client prend en charge certaines révisions, mais pas les autres. Dans ce cours, vous utilisez trois clients : le Client du SDK, MCP Inspector 2.10.1 au module 3 et l’hôte du cours au module 4.

Le cours le précise donc en une phrase : ce cours utilise la révision 2026-07-28 de la spécification MCP avec le SDK Python officiel de MCP 2.3.0. Écrivez une phrase semblable pour chaque projet MCP que vous créez.

Une rangée de cinq révisions de la spécification : 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25 et 2026-07-28. Au-dessus des quatre premières, une bande grise en pointillés : anciennes révisions, négociation initialize en premier, ancien fonctionnement. Au-dessus de 2026-07-28, une bande bleue : version actuelle, aucune négociation, server/discover et _meta. En dessous, une bande grise en pointillés : SDK 1.x, FastMCP et McpError, maintenance seulement, code ancien dans les vieux tutoriels. Une bande bleue couvre les cinq révisions : SDK 2.3.0, ce cours, MCPServer et MCPError, utilise 2026-07-28 et accepte encore la négociation des quatre anciennes révisions provenant d'anciens clients. Un encadré gris en pointillés : HTTP+SSE, le transport à distance de 2024-11-05, ancien, non enseigné. Une légende : le gris et les pointillés indiquent ce qu'il faut reconnaître dans les anciens exemples, sans le copier; le bleu indique les bases de ce cours.
Les cinq révisions de la spécification et les deux séries du SDK. Le gris indique les éléments anciens : reconnaissez-les, mais ne les copiez pas.
Description textuelle du diagramme

Cinq révisions de la spécification, de la plus ancienne à la plus récente : 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25 et 2026-07-28.

  • Les quatre premières (anciennes) : une connexion commence par la négociation initialize. Les anciens tutoriels utilisent le code du SDK 1.x, avec FastMCP et McpError. Le SDK 1.x reçoit seulement des corrections de bogues critiques et de sécurité. La révision 2024-11-05 avait aussi un transport à distance nommé HTTP+SSE, que ce cours n’enseigne pas.
  • 2026-07-28 (actuelle) : aucune négociation. La découverte est une requête, server/discover, et chaque requête contient _meta.
  • SDK 2.3.0 (ce cours) : MCPServer et MCPError. Il utilise 2026-07-28 et accepte encore la négociation des quatre anciennes révisions provenant d’anciens clients.

La révision la plus récente a changé la façon de démarrer une connexion. L’équipe du cours a envoyé les deux formes manuellement à votre serveur hello, une ligne JSON à la fois. Elle a enregistré les réponses. Au module 3, vous écrivez vous-même de tels messages.

Un ancien client (révision 2025-06-18) commence par une négociation : un premier échange pour convenir de la révision avant toute autre requête.

-> {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": {"name": "old-tutorial-client", "version": "1.0"}}}
<- {"jsonrpc":"2.0","id":1,"result":{"capabilities":{…},"protocolVersion":"2025-06-18","serverInfo":{"name":"hello-server","version":"1.0.0"}}}
-> {"jsonrpc": "2.0", "method": "notifications/initialized"}
-> {"jsonrpc": "2.0", "id": 2, "method": "tools/list"}
<- {"jsonrpc":"2.0","id":2,"result":{"tools":[{"description":"Say hello to someone.", … "name":"hello", …}]}}

Le client propose 2025-06-18, et le serveur accepte. Le client confirme avec notifications/initialized. Une notification est un message qui ne reçoit aucune réponse : il n’a pas de id. Après la négociation, tools/list ne contient aucune version. L’accord reste valable pour toute la connexion. Cet état partagé s’appelle une session.

Un client actuel (révision 2026-07-28) n’a ni négociation ni session. Chaque requête contient elle-même la version, dans un champ nommé _meta :

-> {"jsonrpc": "2.0", "id": 1, "method": "server/discover", "params": {"_meta": {"io.modelcontextprotocol/protocolVersion": "2026-07-28", "io.modelcontextprotocol/clientInfo": {"name": "by-hand", "version": "1.0"}, "io.modelcontextprotocol/clientCapabilities": {}}}}
<- {"jsonrpc":"2.0","id":1,"result":{"cacheScope":"private","capabilities":{…},"resultType":"complete","supportedVersions":["2026-07-28"],"ttlMs":0,"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"hello-server","version":"1.0.0"}}}}
-> {"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {"_meta": {…the same _meta…}}}
<- {"jsonrpc":"2.0","id":2,"result":{"cacheScope":"private","resultType":"complete","tools":[{"description":"Say hello to someone.", … "name":"hello", …}],"ttlMs":0,"_meta":{…}}}

La découverte est maintenant une requête ordinaire, server/discover. Sa réponse énumère les révisions que le serveur prend en charge. Chaque requête suivante répète _meta, donc chacune est indépendante.

Une requête qui ne suit aucune des deux formes reçoit une erreur. Voici tools/list sans négociation préalable et sans _meta :

-> {"jsonrpc": "2.0", "id": 1, "method": "tools/list"}
<- {"jsonrpc":"2.0","id":1,"error":{"code":-32602,"message":"Invalid request parameters","data":""}}

Les lignes sont abrégées avec … quand le contenu se répète. Voici les trois cas côte à côte :

Deux colonnes de messages. À gauche, un ancien client, révision 2025-06-18, ancien fonctionnement : du client au serveur, initialize id 1 avec protocolVersion 2025-06-18; du serveur au client, résultat id 1 avec protocolVersion 2025-06-18 et serverInfo hello-server 1.0.0; du client au serveur, notifications/initialized, une notification sans réponse; du client au serveur, tools/list id 2 sans _meta; du serveur au client, résultat id 2, 1 outil, hello. À droite, un client actuel, révision 2026-07-28 : du client au serveur, server/discover id 1 avec _meta protocolVersion 2026-07-28, clientInfo et clientCapabilities; du serveur au client, résultat id 1 avec supportedVersions 2026-07-28 et hello-server 1.0.0; du client au serveur, tools/list id 2 avec le même _meta; du serveur au client, résultat id 2, 1 outil, hello. En dessous, en rouge : aucune des deux formes, tools/list id 1 sans négociation ni _meta, reçoit l'erreur -32602 Invalid request parameters (paramètres de requête non valides).
Le même serveur hello et le SDK 2.3.0 répondent aux deux époques. Le serveur refuse une requête qui ne suit aucune des deux formes.
Description textuelle du diagramme

Un ancien client, révision 2025-06-18 (ancien fonctionnement) :

  1. Du client au serveur : initialize (id 1), protocolVersion: 2025-06-18.
  2. Du serveur au client : résultat (id 1), protocolVersion 2025-06-18, serverInfo: hello-server 1.0.0.
  3. Du client au serveur : notifications/initialized, une notification sans réponse.
  4. Du client au serveur : tools/list (id 2), sans _meta.
  5. Du serveur au client : résultat (id 2), un outil, hello.

Un client actuel, révision 2026-07-28 :

  1. Du client au serveur : server/discover (id 1), avec _meta : protocolVersion 2026-07-28, clientInfo, clientCapabilities.
  2. Du serveur au client : résultat (id 1), supportedVersions ["2026-07-28"], hello-server 1.0.0.
  3. Du client au serveur : tools/list (id 2), avec le même _meta.
  4. Du serveur au client : résultat (id 2), un outil, hello.

Aucune des deux formes : tools/list (id 1) sans négociation ni _meta reçoit l’erreur −32602, « Invalid request parameters » (paramètres de requête non valides).

Pourquoi un seul serveur répond-il aux deux? Le SDK 2.3.0 utilise 2026-07-28 et accepte encore la négociation des anciens clients. Le côté client fonctionne de façon semblable : le Client du SDK essaie d’abord server/discover. Si le serveur est ancien et ne connaît pas cette requête, le client utilise plutôt initialize. C’est pourquoi participants.py a affiché protocol 2026-07-28 : les deux côtés utilisaient la révision la plus récente.

Amira fait trois choses pour support-mcp. Elle fixe la version du SDK, écrit les versions dans le code et ajoute un test qui échoue si elles diffèrent.

  1. Copiez les fichiers de cette leçon depuis l’instantané end-of-m01 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C28/snapshots/end-of-m01
    cp "$S/requirements.txt" "$S/pyproject.toml" "$S/README.md" .
    cp "$S/support_mcp/__init__.py" support_mcp/
    cp "$S/scripts/versions.py" scripts/
    cp "$S/tests/test_versions.py" "$S/tests/conftest.py" tests/

    Le nouveau conftest.py ajoute deux fonctions utilitaires de test pour le module 3. Elles ne changent encore rien.

  2. Ouvrez requirements.txt. Il fixe des versions exactes avec == :

    requirements.txt
    # The MCP Python SDK. It brings Starlette, uvicorn, httpx2, pydantic, PyJWT and cryptography.
    mcp==2.3.0
    PyJWT[crypto]==2.15.1

    PyJWT sert à la connexion au module 5. pyproject.toml fixe les deux mêmes versions.

  3. Ouvrez support_mcp/__init__.py. Les versions font maintenant partie du code :

    support_mcp/__init__.py
    __version__ = "1.0.0"
    SERVER_NAME = "support-mcp"
    # Versions are part of the design: MCP changes fast. This project is built and tested with:
    SPEC_REVISION = "2026-07-28" # the MCP specification revision (the latest stable one)
    SDK_VERSION = "2.3.0" # the official MCP Python SDK (pip package "mcp")
  4. Installez les paquets aux versions fixées :

    Fenêtre de terminal
    python -m pip install -r requirements.txt

    La plupart sont déjà installés, donc pip indique que leurs exigences sont satisfaites.

  5. Affichez le rapport des versions :

    Fenêtre de terminal
    python -m scripts.versions
    specification revision (this project): 2026-07-28
    MCP Python SDK (pinned): 2.3.0
    MCP Python SDK (installed): 2.3.0
    newest revision the SDK speaks: 2026-07-28
    older revisions it still accepts (initialize handshake): 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25
    Python: 3.12.13

    Votre version de Python peut différer. Elle doit être 3.12 ou plus récente.

  6. Exécutez les tests :

    Fenêtre de terminal
    python -m pytest -q

    La dernière ligne est 13 passed (13 tests réussis). Votre projet correspond maintenant à l’instantané end-of-m01.

Chaque ligne du rapport provient d’un endroit différent, et c’est le but. « Pinned » (version fixée) provient de SDK_VERSION, la décision du projet. « Installed » (version installée) provient du paquet que pip a réellement installé. « Newest revision » (révision la plus récente) et « older revisions » (anciennes révisions) proviennent des constantes du SDK lui-même. Elles indiquent donc les révisions que le code utilise réellement. Quand une ligne contredit une autre, quelque chose a changé sans décision.

tests/test_versions.py transforme cela en trois tests. Le premier échoue si le SDK installé ne correspond pas à la version fixée, ou si requirements.txt ne la fixe pas. Le deuxième échoue si la révision la plus récente du SDK n’est pas 2026-07-28. Le troisième vérifie que le rapport nomme les anciennes révisions. Ainsi, une mise à niveau silencieuse fait échouer un test, plutôt que de surprendre dans une leçon trois modules plus tard.

Vous lirez de nombreux exemples MCP. Utilisez ces indices pour situer un exemple dans le temps avant de le copier.

Ce que vous voyez dans l’exemple Il vise Quoi faire
from mcp.server.fastmcp import FastMCP SDK 1.x Utilisez MCPServer de mcp.server.mcpserver, comme dans hello_server.py.
McpError SDK 1.x Le nom en 2.x est MCPError.
Des attributs en camelCase, comme result.serverInfo SDK 1.x La version 2.x utilise snake_case, comme client.server_info dans participants.py.
initialize, puis notifications/initialized Révisions 2025-11-25 ou antérieures Reconnaissez cette forme. Le SDK 2.3.0 l’accepte encore des anciens clients. Les clients actuels envoient server/discover.
Un identifiant de session conservé entre les requêtes Révisions 2025-11-25 ou antérieures La révision 2026-07-28 n’a pas de session. Le module 5 présente les en-têtes HTTP actuels.
Le transport HTTP+SSE Révision 2024-11-05 Ancien. Le module 5 utilise Streamable HTTP.

Si un exemple ne nomme aucune version, examinez sa date et ses importations. Décidez ensuite : adaptez-le aux noms actuels, ou ne l’utilisez pas. Ne mélangez jamais du code 1.x et 2.x dans un même projet.

Les hôtes dont vous pouvez garantir le fonctionnement

Section intitulée « Les hôtes dont vous pouvez garantir le fonctionnement »

Un relevé des versions indique aussi les clients que vous avez testés. « Cela fonctionne avec MCP » n’est pas une promesse utile, car chaque hôte a son propre client. Voici le relevé de ce cours :

Participant Version Testé par le cours
Spécification Révision 2026-07-28 Oui
Bibliothèque du serveur et du client SDK Python officiel de MCP 2.3.0 Oui
Anciens clients avec négociation Révision 2025-11-25 Oui, au module 7; le SDK accepte les trois révisions antérieures, mais le cours ne les teste pas
MCP Inspector 2.10.1, nécessite Node.js 22.19 ou plus récent Oui, au module 3
Hôte du cours Le dossier host/ du projet, module 4 Oui
Assistants de bureau et éditeurs de code Leur propre version Non : le cours montre seulement leur configuration
Système d’exploitation Python 3.12 sur macOS Oui; les commandes Windows et Linux sont écrites, mais non testées

Le module 7 transforme ce tableau en matrice de compatibilité avec de vrais résultats de tests.

Fixez les versions exactes dans chaque projet que d’autres personnes exécutent : un cours, un service d’équipe, une intégration partenaire. Chaque installation obtient alors le même code, et chaque message des leçons correspond aux vôtres.

Fixer les versions a un coût. Une version fixée ne reçoit pas de corrections automatiquement. Planifiez donc une mise à niveau comme une décision. Lisez le journal des modifications du SDK, changez la version fixée et la constante, exécutez les tests, puis examinez les échecs. Le test que vous avez ajouté aujourd’hui est la première alarme de ce processus.

Notez une limite. Ce projet fixe exactement ses deux paquets directs, mais il n’a pas de fichier de verrouillage. Les 27 paquets que le SDK apporte peuvent encore recevoir des versions plus récentes lors d’une installation ultérieure. C’est acceptable pour un projet de cours. Pour un service en production, un fichier de verrouillage fixe la version de chaque paquet.

Erreur courante

Le SDK installé ne correspond pas à la version fixée

Symptôme : après l’installation séparée d’une autre version, python -m scripts.versions termine avec un avertissement, et un test échoue :

MCP Python SDK (pinned): 2.3.0
MCP Python SDK (installed): 2.2.0
…
WARNING: the installed SDK is not the pinned one. Run: pip install -r requirements.txt
> assert version("mcp") == support_mcp.SDK_VERSION
E AssertionError: assert '2.2.0' == '2.3.0'
…
FAILED tests/test_versions.py::test_the_installed_sdk_is_the_pinned_one - Ass...
1 failed, 12 passed in 1.68s

Cause : quelque chose a installé une autre version du SDK dans l’environnement virtuel. Par exemple, la commande pip install mcp==2.2.0 copiée d’une ancienne note. L’équipe du cours a provoqué cet échec volontairement, dans un deuxième environnement.

Solution : exécutez python -m pip install -r requirements.txt. Le test réussit de nouveau, et le rapport affiche 2.3.0 deux fois.

Erreur courante

Aucun module nommé 'mcp.server.fastmcp'

Symptôme : le code copié d’un ancien tutoriel s’arrête à sa première importation, avec le message présenté au début de cette leçon.

Cause : le code visait le SDK 1.x. Le projet utilise le SDK 2.3.0, où FastMCP est devenu MCPServer.

Solution : remplacez l’importation par from mcp.server.mcpserver import MCPServer, et FastMCP(…) par MCPServer(…). Vérifiez ensuite le reste à l’aide du tableau ci-dessus. Ne remplacez pas la version fixée par mcp<2 : cela empêcherait tous les autres fichiers du projet de fonctionner.

Réinitialisation. Si votre projet ne fonctionne plus, copiez l’instantané end-of-m01 comme dans La place de MCP, avec end-of-m01 plutôt que start. Créez ensuite l’environnement virtuel et installez requirements-dev.txt.

Exercice du module : cartographier les intégrations d’un assistant

Section intitulée « Exercice du module : cartographier les intégrations d’un assistant »

Exemple guidé. docs/integration-map.md est l’exemple détaillé de ce module. Amira l’a créé en quatre étapes. D’abord, listez les applications d’IA et leurs utilisateurs. Ensuite, listez ce dont chacune a besoin du service. Puis, décrivez comment chacune se connecte aujourd’hui, sans MCP. Enfin, décrivez ce qui change avec MCP et les cas où MCP n’est pas nécessaire. Le dernier tableau du fichier indique ce que MCP standardise et ce qui reste à la charge de Larkfield. Relisez-le avant l’exercice.

À vous. Harbour Cycles est une boutique fictive de location de vélos. L’assistant conversationnel de son site Web a cinq besoins :

  1. Vérifier la disponibilité des vélos dans le système de réservation de la boutique.
  2. Lire les conditions de location et le guide de sécurité.
  3. Obtenir les prévisions météo auprès d’une API météo publique.
  4. Rembourser le dépôt d’un client.
  5. L’application mobile des mécaniciens et l’assistant de l’éditeur du personnel veulent aussi consulter cette même disponibilité.

Rédigez une courte carte des intégrations de Harbour Cycles. Pour chaque besoin, choisissez : un appel d’API direct, un outil dans une seule application ou une capacité d’un serveur MCP. Pour chaque capacité MCP, nommez une décision qui reste à la charge de Harbour Cycles.

Afficher une solution détaillée
Besoin Choix Pourquoi Ce qui reste à la charge de Harbour Cycles
1. Disponibilité Serveur MCP, avec un outil en lecture seule Trois applications en ont besoin : l’assistant conversationnel, l’application mobile et l’assistant de l’éditeur. Les vélos et les dates que l’appelant peut voir; les limites de taille d’un résultat.
2. Conditions et guide de sécurité Le même serveur MCP, sous forme de documents lisibles (ressources, module 2) Les trois mêmes applications les citent. La version en vigueur; les documents réservés au personnel.
3. Météo Un outil dans l’assistant conversationnel ou un appel d’API direct Une seule application en a besoin, et l’API publique est déjà simple. Un serveur ajoute un programme à exécuter, sans réutilisation. La clé de l’API météo et ses conditions d’utilisation.
4. Remboursement du dépôt Pas encore. Plus tard, tout au plus une proposition qu’une personne approuve (module 6) Cette action déplace de l’argent. Un modèle ne doit jamais en décider seul. Qui peut approuver, le montant maximal et la trace de chaque approbation.
5. Mobile et éditeur Leurs propres clients MCP, connectés au même serveur que pour le besoin 1 C’est la raison d’être du serveur : une capacité, trois hôtes. La connexion et les autorisations des utilisateurs de chaque application (module 5).

Calcul : sans MCP, les besoins 1 et 2 dans trois applications donnent 3 × 2 = 6 intégrations sur mesure. Avec MCP, ils donnent 1 serveur. Les détails de votre tableau peuvent varier. Il ne doit pas confier le remboursement à un modèle seul. Les vérifications d’autorisation doivent rester dans le code de la boutique.

Vérifiez votre compréhension

Nommez les trois éléments d'une connexion MCP qui ont leur propre version et donnez les valeurs utilisées dans ce cours.

Afficher la réponse

La révision de la spécification : 2026-07-28, une date qui désigne les messages et les règles du protocole. La version de la trousse SDK : la trousse SDK Python officielle de MCP 2.3.0, qui écrit et lit les messages. L’hôte et son client : chaque hôte possède son propre client. Dans ce cours, ce sont le Client de la trousse SDK, MCP Inspector 2.10.1 et l’hôte du cours. Python 3.12 est une quatrième version à noter.

Vérifiez votre compréhension

Prédisez : un ancien client envoie initialize avec protocolVersion 2025-11-25 au serveur hello, puis notifications/initialized, puis tools/list sans _meta. Que reçoit-il? Et un client qui envoie seulement tools/list, sans négociation initiale ni _meta?

Afficher la réponse

Le premier client reçoit une réponse normale, car la trousse SDK 2.3.0 accepte la négociation initiale des anciennes révisions. Le serveur répond à initialize avec protocolVersion 2025-11-25. La notification ne reçoit aucune réponse, et tools/list renvoie l’outil hello. Le deuxième client reçoit l’erreur −32602, « Invalid request parameters » (paramètres de requête invalides). Sa requête ne correspond à aucune des deux formes : aucune négociation initiale n’a eu lieu, et la requête n’a pas de _meta.

Vérifiez votre compréhension

Vérification pratique : exécutez python -m scripts.versions et python -m pytest -q. Qu'indiquent les lignes « pinned » (fixée) et « installed » (installée), et combien de tests réussissent?

Afficher la réponse

Les deux indiquent 2.3.0 : MCP Python SDK (pinned): 2.3.0 et MCP Python SDK (installed): 2.3.0. Le rapport indique aussi la révision 2026-07-28 et les quatre anciennes révisions. python -m pytest -q affiche 13 passed (13 tests réussis). Si les deux lignes diffèrent, le rapport se termine par un avertissement, et test_the_installed_sdk_is_the_pinned_one échoue.

Vérifiez votre compréhension

Vérification de fin de module : expliquez ce que MCP standardise et ce qui reste la responsabilité de l'application et du serveur. Prenez support-mcp de Larkfield comme exemple.

Afficher la réponse

MCP standardise cinq éléments :

  • comment un client découvre ce qu’un serveur offre (server/discover, tools/list);
  • le format des messages (JSON-RPC 2.0);
  • les transports (stdio et Streamable HTTP);
  • comment un appel est effectué et comment un résultat ou une erreur est renvoyé;
  • comment un serveur distant indique où obtenir un jeton.

Il nomme aussi ses révisions pour que les deux côtés puissent s’entendre sur une révision.

L’application et le serveur décident toujours de tout ce qui concerne le sens et les autorisations. Le serveur décide quelles capacités existent et à quel point elles sont ciblées. Par exemple, il propose get_ticket plutôt qu’un outil de requête de base de données. Le serveur et le service d’affaires vérifient l’identité de l’appelant et ce qu’il peut lire. Par exemple, knowledge.py répond Not found. (introuvable) pour un billet de soutien de Bramble Books demandé par Larkfield. L’hôte décide quels appels proposés exécuter et quand une personne doit les approuver. Le projet décide de ses limites, de ses journaux (logs) et de ses versions fixées. MCP n’est pas un cadriciel d’agents et ne rend pas un outil sûr.

Récapitulatif

  • Trois éléments ont une version : la révision de la spécification (2026-07-28), la trousse SDK (la trousse SDK Python officielle de MCP 2.3.0) et le client de chaque hôte. Notez-les dans une phrase pour chaque projet.
  • Anciens éléments à reconnaître : la négociation initiale initialize et sa session, les noms de la trousse SDK 1.x comme FastMCP et McpError, et le transport HTTP+SSE. Éléments actuels : server/discover et un _meta dans chaque requête.
  • La trousse SDK 2.3.0 répond aux deux générations. Une requête qui ne correspond à aucune des deux formes reçoit −32602.
  • scripts/versions.py et tests/test_versions.py transforment un changement silencieux de version en avertissement et en échec de test.

Résumé du module. Vous pouvez maintenant expliquer la place de MCP et quand un appel d’API direct ou un outil dans une seule application suffit. Vous pouvez nommer l’hôte, le client et le serveur, et préciser quelle partie doit effectuer chaque vérification. Vous avez exécuté le plus petit serveur et lu ses six messages. Vous avez aussi noté les versions dont dépend votre projet. Votre projet correspond à l’instantané end-of-m01 : 13 passed.

Ensuite, vous concevrez les capacités de support-mcp avant de les créer, en commençant par ses outils.

Leçon suivante : Outils