Participants et limites
- Leçon 2
- 50 min
- Module 1 : Comprendre le problème d'intégration
Où nous en sommes
Dans la leçon précédente, nous avons vu la place de MCP : un serveur partagé que toute application peut utiliser, au lieu d'une intégration sur mesure pour chaque paire. Mais qui fait quoi dans une connexion MCP, et qui vérifie chaque requête? Dans cette leçon, nous nommons l'hôte, le client et le serveur, nous lançons le plus petit serveur et nous lisons ses six messages. Nous commençons par une aire de restauration avec trois cuisines.
Leçon 2 sur 22 · MCP : connecter les applications d'IA aux outils et aux donnéesParticipants et limites
1. Comprendre le problème d'intégration
2. Concevoir des capacités de serveur utiles
3. Créer et examiner un serveur local
4. Connecter une application d'IA
5. Accès à distance et autorisation
6. Protéger les outils et le contrôle de l'utilisateur
7. Exploiter et maintenir l'intégration
Ce que vous saurez faire
Nommez les trois parties de toute connexion MCP : l’hôte, le client et le serveur. Lancez le plus petit serveur MCP. Lisez les six messages échangés entre son client et son serveur. Déterminez quelle partie doit effectuer chaque vérification.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les trois façons de connecter une application et ce que MCP standardise, présentés dans La place de MCP.
- Un décorateur Python, comme
@app.get(...)dans Créer et déployer votre première API.
Votre projet
~/projects/support-mcpde la dernière leçon, avec l’environnement virtuel actif :python -m pytest -qaffiche8 passed(8 tests réussis).- Le dépôt des laboratoires dans
~/projects/nextia-learning-labs, de la dernière leçon. - Une connexion Internet pour une installation : la trousse SDK et ses paquets occupent environ 30 Mo sur disque. Aucun compte ni aucune clé.
Une aire de restauration avec trois cuisines
Section intitulée « Une aire de restauration avec trois cuisines »Imaginez une aire de restauration. Vous êtes à une table et un seul serveur vous sert. Derrière lui se trouvent trois petites cuisines : pizzas, nouilles et salades. Chaque cuisine a son propre menu.
Le serveur garde un carnet de commandes distinct pour chaque cuisine. Une commande de nouilles va dans le carnet des nouilles, sous la forme attendue par cette cuisine. Le serveur décide aussi quoi transmettre. Si un client demande « les clés de la cuisine », le serveur ne note pas cette demande.
Chaque cuisine prépare seulement les plats de son menu. Elle vérifie aussi chaque bon de commande reçu. Si un bon demande un plat absent du menu, la cuisine le refuse, même si le serveur l’a écrit clairement. Les ingrédients sont dans une réserve derrière la cuisine. Les clients ne voient jamais cette réserve.
Quatre rôles, quatre types de décisions. Le serveur décide quoi transmettre. Le carnet transmet la commande sous la forme attendue par la cuisine. La cuisine décide ce qu’elle prépare. La réserve contient ce qui existe.
Le problème : « l’IA a lu le mauvais billet »
Section intitulée « Le problème : « l’IA a lu le mauvais billet » »Tomás fait part d’une inquiétude à l’équipe. « Imaginez que l’assistant de l’éditeur montre à Sam un billet de soutien de Bramble Books. Où est le bogue? Dans le modèle, dans l’éditeur, dans MCP ou dans notre code? »
Personne ne peut encore répondre, car l’équipe n’a pas de noms pour les différentes parties. Tomás propose une solution rapide : « Ajoutez une ligne aux instructions du modèle : ne jamais lire les billets de l’autre magasin. »
Cette correction n’est pas au bon endroit. Le modèle écrit seulement du texte, et ce texte peut être erroné. Un billet peut même contenir des mots qui tentent de changer le comportement du modèle. Le cours Sécurité de l’IA, vie privée et conception responsable l’a montré. Si la seule protection est une phrase dans les instructions du modèle, rien ne la garantit.
Vous avez besoin de noms pour les parties et d’une règle indiquant quelle partie doit effectuer chaque vérification. C’est ce que cette leçon vous apporte.
L’idée : hôte, client et serveur
Section intitulée « L’idée : hôte, client et serveur »Une connexion MCP comprend toujours les mêmes trois participants. Ils correspondent aux rôles de l’aire de restauration.
- L’hôte est l’application d’IA qu’une personne utilise : l’assistant de soutien, l’assistant de l’éditeur ou l’application du partenaire. Il conserve la conversation et communique avec le modèle. Il décide quels appels proposés par le modèle sont réellement exécutés. C’est le serveur à la table.
- Le client est une partie de l’hôte qui communique par MCP avec un seul serveur. Un hôte qui utilise trois serveurs contient trois clients. Le client demande au serveur ce qu’il offre, envoie des requêtes et retourne les résultats à l’hôte. C’est le carnet de commandes : il transmet les requêtes et ne décide de rien.
- Le serveur est un programme qui offre des capacités : ce qu’un client peut découvrir et utiliser. Dans le module 2, vous découvrirez les trois types : outils, ressources et requêtes. Le serveur vérifie chaque requête reçue. C’est la cuisine.
Sous le serveur se trouve le service métier : le code et les données qui existaient déjà. Pour Larkfield, il s’agit de knowledge.py et du dossier data/. Il ne fait pas du tout partie de MCP. C’est la réserve.
Demander à un serveur ce qu’il offre porte un nom : la découverte des capacités. Le client le fait avant tout appel, pour que l’hôte puisse présenter les outils au modèle.
Description textuelle du diagramme
Trois hôtes contiennent chacun un client MCP : l’assistant de soutien, l’assistant de l’éditeur et l’application du partenaire. Chaque hôte a son propre modèle; l’image montre celui du premier. Les trois clients envoient des messages MCP, écrits en JSON-RPC, à un seul serveur, support-mcp. Le serveur offrira les outils search_knowledge et get_ticket, les ressources policy://larkfield/… et la requête draft_reply. Il fait des appels Python ordinaires à knowledge.py, le service métier, qui lit data/ : 14 documents et 21 billets.
- Hôte, l’application d’IA : communique avec la personne et le modèle, et décide quels appels d’outils sont réellement exécutés.
- Client MCP, dans l’hôte : une connexion à un serveur. Il découvre ce que le serveur offre, envoie des requêtes et reçoit des résultats.
- Serveur MCP, support-mcp : offre des outils, des ressources et des requêtes, et vérifie l’appelant à chaque requête.
- Service métier : les règles et les données. Il ne connaît ni MCP ni les modèles.
Les capacités du serveur dans l’image sont un plan. Vous les concevrez dans le module 2 et les créerez dans le module 3. Aujourd’hui, vous lancez un serveur beaucoup plus petit pour voir les trois participants à l’œuvre.
Un petit exemple : le plus petit serveur
Section intitulée « Un petit exemple : le plus petit serveur »Ce cours utilise la révision 2026-07-28 de la spécification MCP avec la trousse SDK Python officielle de MCP, version 2.3.0. Une trousse SDK, ou trousse de développement logiciel, est une bibliothèque qui gère le protocole pour vous. La prochaine leçon explique ce que signifient ces deux numéros de version et comment les vérifier.
Voici le plus petit serveur utile. Il se trouve dans examples/hello_server.py de l’instantané end-of-m01 :
"""The smallest MCP server: one tool. Run it with: python -m examples.hello_server (stdio)."""
from mcp.server.mcpserver import MCPServer
mcp = MCPServer("hello-server", version="1.0.0")
@mcp.tool()def hello(name: str) -> str: """Say hello to someone.""" return f"Hello, {name}!"
if __name__ == "__main__": mcp.run("stdio")Lisez-le depuis le début. MCPServer("hello-server", version="1.0.0") crée un serveur avec un nom et une version. Le décorateur @mcp.tool() transforme une fonction ordinaire en outil. La trousse SDK tire trois éléments de la fonction. Le nom de la fonction, hello, devient le nom de l’outil. La chaîne de documentation devient la description que lit le modèle. L’indication de type name: str devient le schéma d’entrée : un argument obligatoire, une chaîne de caractères.
La dernière ligne démarre le serveur sur stdio : il lit les messages sur son entrée standard et écrit les réponses sur sa sortie standard. Un hôte lance ce type de serveur local comme processus enfant. Le client communique avec lui par ces deux flux. Le module 3 explique stdio en détail.
L’hôte est scripts/participants.py. C’est un script, donc il n’a ni modèle ni personne. Cela suffit pour voir les trois participants :
server = StdioServerParameters(command=sys.executable, args=["-m", "examples.hello_server"])print(f"host: this script (process {os.getpid()})")async with Client(server) as client: print(f"client: the SDK's Client, protocol {client.protocol_version}") info = client.server_info print(f"server: {info.name} {info.version}, a child process that talks on stdin/stdout") tools = await client.list_tools() for t in tools.tools: print(f" tool {t.name}: {t.description}") result = await client.call_tool("hello", {"name": "Amira"}) print(f"call: hello(name='Amira') -> {result.content[0].text}")StdioServerParameters indique comment lancer le serveur : ce Python, avec -m examples.hello_server. Client(server) le lance et établit la connexion. Ensuite, l’hôte demande les outils et en appelle un.
Exécutez-le
Section intitulée « Exécutez-le »-
Installez la trousse SDK, exactement à cette version :
Fenêtre de terminal python -m pip install "mcp==2.3.0"Cela installe aussi 27 paquets nécessaires à la trousse SDK, comme
pydantic,anyioetstarlette. Dans la prochaine leçon, vous inscrirez la version dansrequirements.txt. -
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-m01cp -R "$S/examples" .mkdir scriptscp "$S/scripts/__init__.py" "$S/scripts/participants.py" scripts/cp "$S/tests/test_participants.py" tests/Fenêtre de terminal $S = "..\nextia-learning-labs\C28\snapshots\end-of-m01"Copy-Item -Recurse "$S\examples" .mkdir scriptsCopy-Item "$S\scripts\__init__.py", "$S\scripts\participants.py" scripts\Copy-Item "$S\tests\test_participants.py" tests\ -
Lancez l’hôte :
Fenêtre de terminal python -m scripts.participantshost: this script (process 24484)client: the SDK's Client, protocol 2026-07-28server: hello-server 1.0.0, a child process that talks on stdin/stdouttool hello: Say hello to someone.call: hello(name='Amira') -> Hello, Amira!Votre numéro de processus sera différent. Toutes les autres lignes seront identiques.
-
Lancez les tests :
Fenêtre de terminal python -m pytest -qLa dernière ligne est
10 passed(10 tests réussis) : les 8 tests du service métier et 2 nouveaux tests. -
Lancez le serveur seul, sans hôte :
Fenêtre de terminal python -m examples.hello_serverRien ne se passe. Le serveur attend des messages sur son entrée. Tapez
hello(bonjour) et appuyez sur Entrée. Toujours aucune réponse, carhellon’est pas un message MCP. -
Arrêtez le serveur. Sur macOS et Linux, appuyez sur Ctrl+D : cela ferme l’entrée et le serveur s’arrête. Sur Windows, appuyez sur Ctrl+Z, puis sur Entrée. L’équipe du cours n’a pas testé les touches Windows.
L’étape 5 montre un point important. Un serveur ne démarre pas une conversation. Il attend un client et répond seulement aux messages qui respectent la forme du protocole.
Le premier test dans tests/test_participants.py montre une autre chose. Il passe l’objet serveur lui-même à Client(hello_server). Le client communique alors avec le serveur dans le même processus, sans processus enfant. Les messages restent les mêmes, ce qui permet des tests rapides.
Ce qui a circulé entre eux
Section intitulée « Ce qui a circulé entre eux »L’hôte a affiché cinq lignes. En dessous, le client et le serveur ont échangé six messages : trois requêtes et trois réponses. L’équipe du cours les a enregistrés avec un petit programme placé entre les deux, qui copie chaque ligne. Dans le module 3, vous lirez vous-même ces messages, depuis votre propre serveur.
Description textuelle du diagramme
L’hôte crée le Client. Le client lance le processus enfant python -m examples.hello_server. Ensuite viennent trois requêtes et leurs réponses :
- Le client envoie
server/discover(id 1), avec_metaqui indique la révision 2026-07-28. Le serveur répond : versions prises en charge 2026-07-28, serveurhello-server1.0.0. - L’hôte appelle
list_tools(). Le client envoietools/list(id 2). Le serveur répond avec un outil,hello(name). - L’hôte appelle
call_tool("hello", name="Amira"). Le client envoietools/call(id 3). Le serveur exécutehello("Amira")et répond"Hello, Amira!"(bonjour, Amira!) avecisError: false(aucune erreur). Le client retourne le résultat à l’hôte.
Cela fait six lignes de JSON sur l’entrée et la sortie standard du processus enfant.
Voici les six messages enregistrés, avec le temps écoulé depuis le démarrage, leur direction et leur taille. Une flèche -> va du client au serveur, et <- indique le retour.
| Temps | Direction | Message | Octets |
|---|---|---|---|
| 0,2 ms | -> |
server/discover, id 1 |
246 |
| 301,6 ms | <- |
résultat 1 : supportedVersions ["2026-07-28"] (versions prises en charge), serverInfo (informations du serveur) hello-server 1.0.0 |
344 |
| 302,4 ms | -> |
tools/list, id 2 |
241 |
| 303,0 ms | <- |
résultat 2 : un outil, hello, avec son schéma d’entrée |
515 |
| 303,8 ms | -> |
tools/call, id 3, {"name": "hello", "arguments": {"name": "Amira"}} |
285 |
| 304,6 ms | <- |
résultat 3 : "Hello, Amira!", isError: false |
263 |
Le premier message sert à découvrir les capacités. La réponse à tools/list contient ce que le décorateur a créé à partir de la fonction :
{"description": "Say hello to someone.", "inputSchema": {"type": "object", "properties": {"name": {"title": "Name", "type": "string"}}, "required": ["name"], "title": "helloArguments"}, "name": "hello", "outputSchema": {"properties": {"result": {"title": "Result", "type": "string"}}, "required": ["result"], "title": "helloOutput", "type": "object"}}C’est la partie de la réponse qui décrit l’outil, présentée sur plusieurs lignes. Un hôte montre cette description et ce schéma à son modèle, pour que celui-ci puisse proposer un appel. Le outputSchema (schéma de sortie) vient du type de retour, -> str.
Regardez les temps. La première réponse est arrivée environ 300 ms après le démarrage. La majeure partie de ce temps vient du lancement du processus enfant : Python, puis la trousse SDK. Le programme d’enregistrement placé entre les deux ajoute un peu de temps. Ensuite, chaque réponse a pris moins de 1 ms. Les mesures du cours pour le serveur Larkfield complet concordent. Démarrer un serveur stdio et lister ses outils a pris un temps médian de 296,5 ms sur 10 démarrages. Ces mesures proviennent du portable de l’équipe du cours. Votre ordinateur donnera d’autres chiffres.
Larkfield : qui vérifie quoi
Section intitulée « Larkfield : qui vérifie quoi »Répondez maintenant à Tomás. Confiez chaque vérification à la partie qui peut l’effectuer de manière fiable.
| Partie | Chez Larkfield | Responsable de | Non responsable de |
|---|---|---|---|
| Personne | Sam, un agent de soutien | demander et approuver les actions | connaître le protocole |
| Modèle | le modèle de l’assistant | proposer des appels et écrire du texte | toute vérification : son texte n’est pas une garantie |
| Hôte | l’assistant de soutien | la conversation; les appels proposés qui sont exécutés; demander à la personne | décider ce que le serveur autorise |
| Client | le Client de la trousse SDK dans l’hôte |
la découverte, les requêtes et les résultats pour un serveur | toute décision |
| Serveur | support-mcp |
ses capacités; vérifier chaque requête et l’appelant | choisir l’outil que veut le modèle |
| Service métier | knowledge.py |
les données et la règle « au sein d’une seule organisation » | le protocole |
Deux lignes de ce tableau sont des frontières de confiance. L’hôte ne doit pas faire confiance à la proposition du modèle : il la vérifie. Vous l’avez fait dans Créer des applications fiables avec les API de LLM. Et le serveur ne doit pas faire confiance à l’hôte. Le serveur ne voit pas ce que l’hôte a vérifié. L’hôte d’un partenaire n’utilise même pas le code de Larkfield. Donc, chaque requête qui atteint le serveur y est vérifiée à nouveau.
La réponse à Tomás est maintenant claire. « Ne jamais lire les billets de l’autre magasin » est une règle du serveur et du service métier. Une phrase destinée au modèle est une indication, pas un contrôle. Dans le module 3, le serveur apprend l’organisation à partir de son mode de lancement, jamais du modèle. Un modèle ne peut donc même pas demander l’autre magasin.
Cette séparation a un autre avantage. Un hôte peut changer sans aucun changement au serveur. L’assistant de l’éditeur de Sam et l’assistant de soutien utilisent du code et des modèles différents. Mais ils accèdent au même serveur avec les mêmes messages.
Quand la séparation aide et ce qu’elle coûte
Section intitulée « Quand la séparation aide et ce qu’elle coûte »La séparation aide quand plusieurs applications utilisent les mêmes capacités, comme l’a montré la dernière leçon. Elle aide aussi pour les tests. Vous pouvez tester le serveur avec un simple client, sans aucun modèle, comme le fait test_participants.py. Et vous pouvez tester un hôte avec un serveur qui fournit des réponses enregistrées.
Elle a aussi des coûts :
- Un démarrage de processus. Un serveur local est un processus enfant. Ici, la première réponse a demandé environ 300 ms. Pour un hôte qui démarre le serveur une fois et le garde actif, cela convient. Pour un hôte qui le redémarre à chaque question, les délais s’accumulent.
- Deux programmes à déboguer. Une erreur peut se trouver dans l’hôte, dans le serveur ou dans les messages échangés entre eux. Le module 3 vous donne des outils pour voir chaque message.
- Un élément de plus à protéger. Le serveur est maintenant une porte d’accès au service métier. Tout ce qui l’atteint doit y être vérifié, pour chaque hôte.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
Aucun module nommé 'anyio' (ou 'mcp')
Symptôme : python -m scripts.participants s’arrête immédiatement :
File "…/support-mcp/scripts/participants.py", line 10, in <module> import anyioModuleNotFoundError: No module named 'anyio'Cause : le Python qui exécute le script n’a pas la trousse SDK. Vous avez sauté l’étape 1, ou l’environnement virtuel n’est pas actif. anyio vient avec la trousse SDK. C’est donc le premier module manquant à importer.
Solution : activez l’environnement virtuel, puis exécutez de nouveau python -m pip install "mcp==2.3.0".
Erreur courante
Le serveur semble bloqué
Symptôme : python -m examples.hello_server n’affiche rien et ne revient jamais à l’invite de commande.
Cause : c’est normal. Un serveur stdio attend les messages d’un client sur son entrée et n’affiche jamais de salutation. Du texte sur sa sortie briserait le protocole, car le client lit cette sortie comme des messages.
Solution : arrêtez-le avec Ctrl+D (macOS et Linux) ou Ctrl+Z, puis Entrée (Windows). Démarrez-le plutôt avec un hôte, par exemple python -m scripts.participants.
Réinitialisation. Cette leçon ajoute des fichiers et un paquet, sans modifier de données. 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. Cet instantané contient aussi les fichiers de la prochaine leçon.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Nommez le participant responsable de chaque action (personne, modèle, hôte, client, serveur ou service métier) : (a) décider d'exécuter ou non un appel get_ticket proposé; (b) envoyer tools/list; (c) refuser un billet de Bramble Books à un appelant de Larkfield; (d) choisir l'outil à proposer.
Afficher la réponse
(a) L’hôte. Il vérifie la proposition du modèle et décide de l’exécuter ou non. Il peut demander à la personne. (b) Le client, dans l’hôte : il découvre les capacités. (c) Le serveur et le service métier. Le serveur vérifie chaque requête, et knowledge.py cherche les billets dans une seule organisation. L’hôte peut aussi masquer des éléments, mais le serveur ne doit pas compter sur lui. (d) Le modèle fait la proposition. Il n’offre aucune garantie. C’est pourquoi (a) et (c) existent.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Prédisez : vous remplacez la chaîne de documentation de hello par 'Greet a person by name.', puis exécutez encore participants.py. Quelle ligne affichée change? Quel message enregistré transmet le nouveau texte au client?
Afficher la réponse
La ligne tool hello: Say hello to someone. (outil hello : saluer quelqu’un) devient tool hello: Greet a person by name. (outil hello : saluer une personne par son nom). Le nouveau texte passe dans la réponse à tools/list (identifiant 2), dans la description de l’outil. L’hôte montrerait cette description à son modèle. Le nom de l’outil et son schéma d’entrée ne changent pas. Le nom de la fonction et l’indication de type n’ont pas changé.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Vérification pratique : exécutez python -m scripts.participants. Quelle ligne montre le client? Quelle ligne montre que le serveur est un processus distinct?
Afficher la réponse
client: the SDK's Client, protocol 2026-07-28 (client : le Client de la trousse SDK, protocole 2026-07-28) montre le client et la révision du protocole convenue avec le serveur. server: hello-server 1.0.0, a child process that talks on stdin/stdout (serveur : hello-server 1.0.0, un processus enfant qui communique par stdin/stdout) montre le serveur, lancé par le client comme processus enfant. La ligne host: (hôte) affiche le numéro de processus de l’hôte, qui change à chaque exécution.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Hôte : l’application d’IA. Il communique avec la personne et le modèle, et décide quels appels exécuter.
- Client : dans l’hôte, un par serveur. Il découvre les capacités, envoie les requêtes et retourne les résultats. Il ne décide rien.
- Serveur : offre des capacités et vérifie chaque requête. En dessous, le service métier conserve les données et leurs règles, en dehors de MCP.
- Le plus petit serveur compte 15 lignes. Son exécution comprend 6 messages :
server/discover,tools/list,tools/callet leurs réponses. La première réponse attend environ 300 ms, le temps que le processus démarre. - Chaque vérification revient à un participant qui peut la faire de façon fiable : jamais au modèle, ni seulement à l’hôte.
Votre projet contient maintenant examples/hello_server.py et scripts/participants.py, et python -m pytest -q affiche 10 passed (10 tests réussis). Ensuite, vous noterez les versions dont le projet dépend.
Leçon suivante : Tenir compte des versions