Aller au contenu
English

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.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

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 mainEnviron 50 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 8 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é.

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.

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.

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.

Trois hôtes à gauche : l'assistant de soutien, l'assistant de l'éditeur et l'application du partenaire. Chaque hôte contient un client MCP. L'assistant de soutien communique aussi avec un modèle; chaque hôte a son propre modèle. Les trois clients envoient des messages MCP (JSON-RPC) à un seul serveur, support-mcp. Celui-ci offrira les outils search_knowledge et get_ticket, les ressources policy://larkfield/… et la requête draft_reply. Le serveur fait des appels Python à knowledge.py, le service métier, qui lit data/ : 14 documents et 21 billets. Quatre encadrés en dessous indiquent le rôle de chaque partie. Hôte, l'application d'IA : communique avec la personne et le modèle, décide quels appels d'outils sont réellement exécutés. Client MCP, dans l'hôte : une connexion à un serveur, découvre ce qu'il offre, envoie des requêtes, reçoit des résultats. Serveur MCP, support-mcp : offre des outils, des ressources et des requêtes, vérifie l'appelant à chaque requête. Service métier : les règles et les données, ne connaît ni MCP ni les modèles.
Le plan de Larkfield : trois hôtes, chacun avec son propre client MCP, accèdent à un seul serveur. Le serveur se place devant le service métier existant.
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.

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 :

examples/hello_server.py
"""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 :

scripts/participants.py (the main part)
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.

  1. 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, anyio et starlette. Dans la prochaine leçon, vous inscrirez la version dans requirements.txt.

  2. 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 -R "$S/examples" .
    mkdir scripts
    cp "$S/scripts/__init__.py" "$S/scripts/participants.py" scripts/
    cp "$S/tests/test_participants.py" tests/
  3. Lancez l’hôte :

    Fenêtre de terminal
    python -m scripts.participants
    host: this script (process 24484)
    client: the SDK's Client, protocol 2026-07-28
    server: hello-server 1.0.0, a child process that talks on stdin/stdout
    tool 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.

  4. Lancez les tests :

    Fenêtre de terminal
    python -m pytest -q

    La dernière ligne est 10 passed (10 tests réussis) : les 8 tests du service métier et 2 nouveaux tests.

  5. Lancez le serveur seul, sans hôte :

    Fenêtre de terminal
    python -m examples.hello_server

    Rien ne se passe. Le serveur attend des messages sur son entrée. Tapez hello (bonjour) et appuyez sur Entrée. Toujours aucune réponse, car hello n’est pas un message MCP.

  6. 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.

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.

Une séquence entre trois participants : l'hôte, participants.py; le client, Client de la trousse SDK; le serveur, hello_server.py. L'hôte crée le Client. Le client lance le processus enfant python -m examples.hello_server, puis envoie server/discover avec id 1 et _meta 2026-07-28. Le serveur répond supportedVersions 2026-07-28, hello-server 1.0.0. L'hôte appelle list_tools; le client envoie tools/list avec id 2. Le serveur répond avec 1 outil, hello(name). L'hôte appelle call_tool hello avec le nom Amira; le client envoie tools/call avec id 3. Le serveur exécute hello('Amira') et répond 'Hello, Amira!' (bonjour, Amira!), isError false. Le client retourne le résultat à l'hôte. Une note : 3 requêtes et 3 réponses, 6 lignes de JSON sur stdin et stdout du processus enfant.
L'exécution de participants.py, message par message. Les libellés sont abrégés à partir des messages enregistrés.
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 :

  1. Le client envoie server/discover (id 1), avec _meta qui indique la révision 2026-07-28. Le serveur répond : versions prises en charge 2026-07-28, serveur hello-server 1.0.0.
  2. L’hôte appelle list_tools(). Le client envoie tools/list (id 2). Le serveur répond avec un outil, hello(name).
  3. L’hôte appelle call_tool("hello", name="Amira"). Le client envoie tools/call (id 3). Le serveur exécute hello("Amira") et répond "Hello, Amira!" (bonjour, Amira!) avec isError: 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.

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.

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.

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 anyio
ModuleNotFoundError: 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é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.

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é.

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.

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/call et 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