Aller au contenu
English

Travail final

  • Après les études de cas
  • environ 3 h

Où nous en sommes

Dans ce cours, vous avez appris à connecter des applications d'IA à des outils et à des données avec un seul protocole : des rôles clairs, des contrats limités, l'inspection, l'autorisation sur le serveur et une exploitation sûre. Maintenant, deux boutiques de location partagent un service de soutien, et les deux veulent les mêmes connaissances de soutien dans deux applications d'IA. Dans ce travail, vous concevez et créez leur serveur MCP, et vous prouvez qu'il tient ses promesses.

Ce que vous saurez faire

Appliquez chaque module du cours à un serveur que vous concevez vous-même. Vous créez un serveur MCP pour le service de soutien de deux boutiques de location fictives. Il offre une recherche et une consultation de billets de soutien en lecture seule, une ressource de politiques et une requête (prompt) réutilisable. Ajoutez une écriture simulée seulement après la réussite de ses tests d’autorisations. Elle doit avoir sa propre autorisation et l’approbation d’une personne. Puis, prouvez que le serveur tient ses promesses avec des tests, des exécutions enregistrées et une liste de vérification de compatibilité.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 180 minutes
  • Vous avez terminé les modules 1 à 7. Chaque partie ci-dessous nomme les leçons qu’elle utilise.
  • Le certificat exige aussi au moins une étude de cas : Un serveur MCP sur un vrai jeu de données ouvert ou Revue de sécurité d’une intégration MCP. Ce travail ne les exige pas.
  • Le projet du cours comme source de code : votre support-mcp à la fin du module 7, ou l’instantané end-of-m07 du dépôt des laboratoires. Vous pouvez en copier du code : le fournisseur d’exercice idp/, l’hôte host/, identity.py, logs.py, http.py, les scripts et les fonctions d’aide aux tests. Indiquez dans votre rapport ce que vous avez copié et modifié. Ne copiez pas ses données, ses outils et ses tests pour simplement les renommer. Le réviseur cherche les décisions propres aux besoins de ce serveur.
  • Python 3.12, la trousse SDK Python officielle de MCP 2.3.0 (révision de la spécification 2026-07-28), et Node.js 22.19 ou plus récent pour MCP Inspector 2.10.1. Aucun compte, aucune clé et aucune dépense. Un vrai modèle est facultatif.
  • Chaque tentative de ce travail vise votre propre serveur sur votre ordinateur, avec des personnes et des dossiers fictifs.
  • Vous pouvez travailler en plusieurs séances. Exécutez les tests après chaque modification.

Harbour Cycles, la boutique de location de vélos des exercices du module, partage maintenant son service de soutien avec une deuxième boutique fictive, Quayside Scooters. Les deux boutiques veulent les mêmes connaissances de soutien dans deux applications d’IA : l’assistant de clavardage du site et l’assistant de l’éditeur du personnel. Une application partenaire pour les hôtels suivra. Au lieu de trois intégrations, vous créez un serveur MCP, rental-support-mcp.

Kwame pose ses trois questions : « Qui fait l’appel? Que peut cette personne faire? Dans quelle organisation? » Grace en ajoute une pour l’écriture : « Est-ce qu’un système peut rembourser de l’argent sans l’approbation d’une personne? »

Vos données. Rédigez-les vous-même et indiquez partout qu’elles sont synthétiques :

  • Pour chaque boutique, au moins 5 documents de politiques en Markdown et au moins 8 billets. Par exemple : conditions de location, dommages, retours tardifs, dépôts, casques et sécurité. Un document de chaque boutique est réservé au personnel.
  • Au moins 6 personnes avec des adhésions : un propriétaire, un membre du personnel et un membre en lecture seule dans chaque boutique. Une personne a une adhésion dans les deux boutiques, avec un rôle différent dans chacune. Une personne n’a aucune adhésion.
  • Un billet construit dont le texte tente de faire agir l’assistant, comme T-30201 dans le cours. Indiquez qu’il est construit.

Utilise Outils, Ressources, Requêtes et Tests de contrat et de compatibilité.

  1. Rédigez d’abord docs/capability-catalog.md. Indiquez chaque besoin, la capacité qui y répond, qui la choisit (modèle, application ou personne), ses limites et les idées rejetées, avec leur raison.
  2. Créez deux outils en lecture seule : une recherche dans les politiques de la personne appelante et la consultation d’un billet par son identifiant. Imposez une limite à chaque entrée (longueur, motif ou plage) et donnez aux deux outils un schéma de sortie. Gardez chaque résultat sous une taille que vous mesurez. Rédigez des descriptions d’une ligne et marquez les deux outils comme étant en lecture seule. Les annotations sont des indications, pas des contrôles.
  3. Ajoutez un modèle de ressource pour les politiques, avec des URI stables, et une liste de ressources adaptée à la personne appelante. Une politique manquante renvoie −32602 avec data.uri.
  4. Ajoutez une requête que la personne choisit, par exemple « rédiger une réponse à ce billet en utilisant nos politiques ». Elle vérifie l’identifiant du billet avant de produire du texte.
  5. Enregistrez le contrat dans contract/capabilities.json avec un script. Ajoutez un test de contrat et un test de structure des erreurs. Montrez une modification que le test de contrat détecte, et une autre que seul le test de structure des erreurs détecte.

Partie 2 : inspection et intégration du client réussies

Section intitulée « Partie 2 : inspection et intégration du client réussies »

Utilise Transport local, Les messages JSON-RPC, Examiner le comportement, Intégration du client, Découverte et exécution et Résultats et défaillances.

  1. Exécutez le serveur sur stdio. Envoyez chaque ligne de journal vers stderr, jamais vers stdout.
  2. Examinez-le avec MCP Inspector 2.10.1 dans les deux générations de protocole : celle par défaut (négociation initiale ancienne, 2025-11-25) et --protocol-era modern (2026-07-28). Vérifiez la liste d’outils, un appel valide, un échec de validation, une lecture de ressource et la requête. Lisez chaque description comme le modèle la lira.
  3. Connectez l’hôte du cours, ou votre propre copie, d’abord avec le modèle simulé. Montrez une question traitée de bout en bout : les appels d’outils autorisés par l’hôte et la politique nommée dans la réponse.
  4. Montrez les décisions propres à l’hôte. Il n’envoie jamais un outil absent de la liste de découverte. Un outil lent atteint la limite de temps. Un résultat trop volumineux est tronqué et signalé.
  5. Facultatif : posez la même question avec un vrai modèle. Fixez d’abord une limite de dépenses et indiquez le nom du modèle pour cette exécution.

Partie 3 : autorisation côté serveur et tests de locataires, puis écriture

Section intitulée « Partie 3 : autorisation côté serveur et tests de locataires, puis écriture »

Utilise Transport à distance, Identité et autorisations, Intégration d’OAuth, Entrées et sorties non fiables, Approbation des actions à effet et Limites des identifiants.

  1. Servez les mêmes outils sur Streamable HTTP, lié à 127.0.0.1. Vérifiez chaque jeton sur le serveur : signature, émetteur, expiration et audience égale à l’URL du serveur. Annoncez uniquement les portées de lecture dans les métadonnées de la ressource protégée.
  2. Prenez l’organisation depuis la connexion, jamais depuis un argument d’outil. Prenez le rôle dans votre table d’adhésions, jamais dans le jeton. Aucun outil n’a d’argument d’organisation.
  3. Rédigez un script de tentatives, comme scripts.attempts. Il essaie chaque personne dans les deux boutiques et les jetons invalides : absent, autre audience, expiré. Les requêtes demandent une recherche, un billet de chaque boutique et le document réservé au personnel. Le script nomme le contrôle qui refuse chaque tentative. Il termine avec le nombre de tentatives autorisées et refusées. Transformez les lignes importantes en tests.
  4. Seulement quand ces tests réussissent, ajoutez une écriture simulée, par exemple propose_deposit_refund(ticket_id, amount, reason). Elle exige sa propre portée et le rôle de membre du personnel ou de propriétaire. Elle lit le billet dans l’organisation de la personne appelante et impose une limite d’affaires. Elle enregistre une proposition avec un identifiant d’opération et l’opération exacte. La même proposition soumise deux fois reste une seule proposition. Un propriétaire de cette organisation, autre que l’auteur de la proposition, l’approuve en dehors de l’application d’IA.
  5. Faites passer votre billet construit par l’hôte avec --model mock-obedient et une personne qui accepte tout (tous deux construits). Montrez que les contrôles du serveur arrêtent chaque demande du billet. Transformez cette exécution en test.
  6. Démarrez le serveur stdio avec une liste d’autorisation des paramètres, pour qu’il ne voie jamais la clé du modèle. Ne transmettez jamais le jeton d’une personne à un autre service.

Partie 4 : compatibilité avec versions fixées et notes de déploiement

Section intitulée « Partie 4 : compatibilité avec versions fixées et notes de déploiement »

Utilise Tenir compte des versions, Tests de contrat et de compatibilité, Limites de ressources et observabilité et Fonctionnalités optionnelles et évolutives.

  1. Fixez chaque version à un seul endroit : révision de la spécification, trousse SDK, Inspector, Python et chaque paquet. Inscrivez-les dans le README et dans docs/compatibility.md.
  2. Créez une matrice de compatibilité avec un script. Utilisez le Client de la trousse SDK en modes auto (automatique) et legacy (ancien). Testez dans le même processus, sur stdio et sur Streamable HTTP, avec les mêmes vérifications dans chaque ligne. Ajoutez les lignes d’Inspector. Chaque ligne nomme sa génération de protocole. Indiquez ce que vous n’avez pas testé, comme les hôtes de bureau et les trois anciennes révisions de négociation initiale.
  3. Énumérez chaque limite et son emplacement : hôte, transport, contrat et règle d’affaires. Indiquez les limites que vous n’avez pas mises en place, comme le nombre de requêtes par minute.
  4. Écrivez une ligne de journal structurée par appel et par refus : qui, quoi, résultat et heure. Jamais de jeton, de clé ou de texte de billet. Ajoutez un test vérifiant qu’un refus écrit sa ligne et un test vérifiant que le masquage supprime un jeton.
  5. Rédigez docs/deployment.md : HTTPS, vrai fournisseur d’identité et correspondance de ses paramètres avec les vôtres, durées de validité des jetons et emplacement de la table d’adhésions. Ajoutez les limites de débit qu’une passerelle impose et la façon de relancer la matrice après une mise à niveau de la trousse SDK. Pour chaque partie, indiquez si elle est testée, testée une fois, ou décrite mais non testée.

Un parcours sans erreur qui fonctionne ne suffit pas. Montrez chacun de ces cas avec un test ou une exécution enregistrée, et précisez lequel. Chaque tentative vise votre propre serveur, avec des dossiers fictifs.

  1. Un jeton absent, un jeton expiré et un jeton pour une autre audience reçoivent chacun HTTP 401. Le journal du serveur indique la raison.
  2. Un jeton sans les portées de lecture reçoit HTTP 403 insufficient_scope (portée insuffisante).
  3. Une personne sans adhésion reçoit le même −32003 pour une organisation réelle et une organisation fictive.
  4. L’identifiant d’un billet de l’autre boutique, sur la connexion de cette boutique, reçoit le même « introuvable » qu’un identifiant inexistant.
  5. Un membre en lecture seule ne voit pas le document réservé au personnel : il est « introuvable » pour cette personne.
  6. La personne ayant deux adhésions obtient le bon rôle dans chaque boutique, avec le même jeton.
  7. Un identifiant mal formé produit une erreur d’outil. L’hôte n’envoie jamais un outil absent de la liste de découverte.
  8. L’écriture est refusée sans sa portée, pour un membre en lecture seule, pour le billet de l’autre boutique et au-delà de la limite. L’auteur ne peut pas approuver sa propre proposition.
  9. Le modèle obéissant avec le billet construit n’enregistre aucune proposition au-delà de la limite et aucun remboursement.
  10. Une description d’outil modifiée fait échouer le test de contrat jusqu’à ce qu’une personne l’accepte.

Avant de remettre votre travail, prouvez que le projet fonctionne à partir de zéro, sur votre ordinateur :

  1. Copiez le projet dans un nouveau dossier, sans .venv, .idp, .support ni fichiers de messages enregistrés.
  2. Créez un nouvel environnement virtuel, installez les dépendances depuis requirements-dev.txt et créez la clé d’exercice.
  3. Exécutez tous les tests, le script de tentatives, la vérification du contrat et la matrice de compatibilité.
  4. Démarrez le fournisseur et le serveur sur HTTP. Répondez à une question par l’hôte avec un nouveau jeton.

Collez les commandes et leurs sorties dans votre rapport. Si une étape exige un élément absent du README, corrigez le README et reprenez les étapes.

Votre dossier de projet (sans .venv, .idp et .support), avec vos données, code, tests, scripts, contract/capabilities.json, documents et REPORT.md :

# Rental support MCP server
## Capability contracts (the catalog, the bounds, the contract file, the two tests and what each caught)
## Inspection and the host (Inspector in both eras, the host with the mock model, the host's own decisions)
## Authorization (the token checks, the caller, the attempts table, the tests, then the write)
## Compatibility (the pinned versions, the matrix with eras, what was not tested)
## Deployment notes (the limits map, the logs, docs/deployment.md, the evidence level of each part)
## Failure paths (each of the ten, with the test or the run that shows it)
## Fresh-environment run (the commands and their outputs)
## Limits (made-up data, your computer, what you copied, what you did not test)

Un réviseur attribue à chaque élément obligatoire la mention démontré, partiellement démontré ou pas encore démontré, avec une raison concrète. Pour terminer le cours, les quatre éléments doivent être démontrés. Vous pouvez améliorer un élément et le soumettre de nouveau.

Élément obligatoire Démontré Partiellement démontré, par exemple Pas encore démontré, par exemple
Contrats de capacités clairs Le catalogue explique chaque choix et les idées rejetées. Chaque entrée et sortie a une limite, et le plus grand résultat est mesuré. Le fichier de contrat et le test de structure des erreurs existent. Chacun a détecté une modification réelle. Les limites existent, mais le plus grand résultat n’a jamais été mesuré. Ou le contrat est enregistré, mais aucun test ne le compare. Un outil renvoie toutes les correspondances intégralement. Ou un outil prend l’organisation comme argument.
Inspection et intégration du client réussies Inspector s’exécute dans les deux générations de protocole, chacune nommée. L’hôte répond à une question de bout en bout avec le modèle simulé. Ses limites de temps et de taille, ainsi que son contrôle des outils inconnus, sont montrés. Inspector s’exécute dans une seule génération, sans préciser laquelle. Ou seul le parcours sans erreur de l’hôte est montré. Aucune inspection. Ou une ligne de journal sur stdout brise la connexion stdio.
Autorisation côté serveur et tests de locataires Chaque refus se produit sur le serveur et est testé : jetons, adhésion, portée, rôle, dossiers de l’autre boutique et document réservé au personnel. L’écriture vient après ces tests, possède ses propres barrières et exige l’approbation d’un propriétaire. Le modèle obéissant ne peut rien enregistrer au-delà de la limite. Les contrôles fonctionnent, mais les tests couvrent une seule boutique. Ou l’écriture a des barrières, mais l’auteur peut approuver sa propre proposition. La liste d’autorisation de l’hôte ou une annotation d’outil est la seule protection. Ou une boutique peut lire le billet de l’autre.
Compatibilité avec versions fixées et notes de déploiement Chaque version est fixée. La matrice s’exécute depuis un script, nomme la génération dans chaque ligne et indique ce qui n’a pas été testé. La carte des limites, les tests de journaux et les notes de déploiement précisent le niveau de preuve de chaque partie. La matrice existe, mais sans générations de protocole. Ou les notes de déploiement disent qu’un vrai fournisseur « fonctionne » sans exécution. Aucune version fixée. Ou « fonctionne avec tous les clients MCP ».

Même si le reste est solide, le travail reste incomplet tant qu’un contrôle entre organisations ou de privilèges échoue. Un parcours sans erreur ne compte pas si une boutique peut lire les billets de l’autre. Il ne compte pas non plus si un membre en lecture seule peut proposer un remboursement. Même chose si un remboursement peut être enregistré sans l’approbation d’un propriétaire.

Les résultats du cours peuvent vous aider à évaluer les vôtres, mais ce ne sont pas des cibles. À la fin du module 7, support-mcp avait 94 tests. Son tableau de tentatives envoyait 72 requêtes : 18 autorisées (dont 3 propositions seulement) et 54 refusées sur le serveur, avec 0 remboursement enregistré. Sa matrice de compatibilité réussissait 6 lignes sur 6, et Inspector réussissait dans les deux générations de protocole. Votre serveur, ses données et votre ordinateur sont différents.

Erreur courante

Un membre en lecture seule peut proposer un remboursement

Symptôme : une proposition est enregistrée pour votre membre en lecture seule. Ou un membre de l’autre boutique peut proposer un remboursement pour le billet de cette boutique.

Cause : l’écriture a été ajoutée avant la réussite des tests d’autorisations. Ou elle vérifie la portée, mais pas le rôle et l’organisation. Une portée indique ce que l’application peut faire. Le rôle indique ce que cette personne peut faire dans cette boutique.

Correction : dans l’écriture elle-même, vérifiez le rôle depuis votre table d’adhésions. Lisez le billet dans l’organisation de la personne appelante. Ajoutez les deux cas au script de tentatives et aux tests. Exécutez-les avant de considérer l’écriture comme terminée.

Récapitulatif

Dans ce cours, vous avez connecté des applications d’IA à des outils et des données avec un seul protocole :

  • Rôles : l’hôte décide ce qui s’exécute, le client parle le protocole, et le serveur possède ses données et ses contrôles.
  • Contrats : outils, ressources et requêtes avec des limites, un contrat enregistré et des structures d’erreurs fixées par un test.
  • Inspection et intégration : stdio pour une personne, Inspector dans les deux générations de protocole et un hôte avec un modèle simulé d’abord.
  • Autorisation sur le serveur : un jeton réservé à ce serveur, l’organisation depuis la connexion et le rôle depuis votre propre table. L’écriture ne fait que proposer jusqu’à l’approbation d’une deuxième personne.
  • Exploitation : une matrice de compatibilité avec les générations de protocole, des limites par couche, des journaux sans secrets et des notes honnêtes sur ce qui n’a pas été testé.

Si vous n’en avez pas encore fait, choisissez une étude de cas pour le certificat : Un serveur MCP sur un vrai jeu de données ouvert ou Revue de sécurité d’une intégration MCP.