Aller au contenu
English

Limites de ressources et observabilité

  • Leçon 21
  • 50 min
  • Module 7 : Exploiter et maintenir l'intégration

Où nous en sommes

Dans la leçon précédente, nous avons fixé ce que le serveur promet et nous l'avons testé avec chaque client. Mais un serveur qui fonctionne toute la journée a aussi besoin de limites, et de traces qui expliquent ce qui a mal tourné. Dans cette leçon, nous répertorions chaque limite et son emplacement, nous consignons chaque refus dans une ligne de journal sans secrets et nous mesurons un appel local, comme une cuisine de restaurant qui fonctionne avec des limites.

Leçon 21 sur 22 · MCP : connecter les applications d'IA aux outils et aux donnéesLimites de ressources et observabilité

Ce que vous saurez faire

Rendez le serveur sûr pour une journée entière et facile à comprendre quand un problème survient. Vous répertoriez chaque limite et son emplacement, puis vous repérez celles qui manquent. Vous consignez chaque refus dans une ligne de journal sans secrets. Ensuite, vous observez une requête sur la liaison et mesurez le coût d’un appel local.

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

Ce que vous devez savoir

Votre projet

  • ~/projects/support-mcp, avec l’environnement virtuel activé : python -m pytest -q affiche 90 passed (90 tests réussis).
  • Pour la dernière partie : Node.js 22.19 ou une version ultérieure, pour MCP Inspector.

Une cuisine très occupée fonctionne avec des limites. Une portion a une taille fixe. Chaque four a une minuterie. La cuisine accepte seulement un certain nombre de commandes à la fois. Sans ces limites, une grande table peut bloquer toute la cuisine.

La cuisine conserve aussi les bons de commande. Chaque bon indique la table, le plat, l’heure et le résultat : servi, retourné ou « plus de poisson ». Quand un client se plaint, le responsable lit les bons et trouve la réponse en une minute. Les bons ne montrent jamais le numéro de carte du client.

Un serveur MCP a besoin des deux. Les limites empêchent une personne qui l’appelle de tout utiliser. Les bons permettent d’expliquer chaque réponse plus tard.

Le serveur a déjà plusieurs limites. Elles se trouvent à quatre endroits, et personne ne les a répertoriées. Amira n’a même jamais défini certaines limites. L’équipe du cours a envoyé des requêtes de recherche de plus en plus grandes par Streamable HTTP, avec un jeton valide :

SDK client, query of 200 characters: isError=False, answer 234 characters, 23 ms
SDK client, query of 201 characters: isError=True, answer 327 characters, 1 ms
SDK client, query of 1,000,000 characters: isError=True, answer 327 characters, 9 ms
raw POST, body of 3,146,040 bytes: HTTP 200, '{"jsonrpc":"2.0","id":1,"result":{"content":[{"text":"Error executing tool search_knowledge: 1 validation error for sear', 12 ms
raw POST, body of 5,243,192 bytes: HTTP 413, 'Request body too large', 3 ms

Le schéma d’entrée refusait chaque requête de plus de 200 caractères, et l’erreur restait courte. Mais le serveur lisait 3 Mo avant de refuser. Un corps de 5 Mo recevait HTTP 413 à cause d’une limite dans le SDK 2.3.0 : 4 Mio par défaut. Cette limite protège le serveur, mais aucun document du cours ne la mentionnait.

Le deuxième problème est plus grave. Dans Identité et autorisations, les appels refusés de Tomás ne laissaient aucune trace dans le journal du serveur. L’équipe du cours a testé six types de refus à la fin du module 6, puis lu stderr du serveur :

Refus Réponse au client Journal du serveur à la fin du module 6
Tomás, sans adhésion (stdio) −32003 forbidden (interdit) rien
Sam avec seulement knowledge:read, get_ticket −32003 insufficient_scope (portée insuffisante) rien
Omar (lecture seule) propose un remboursement −32003 the role read_only cannot … (le rôle read_only ne peut pas…) tool_call (appel d’outil), "outcome": "forbidden" (résultat : interdit), aucune raison
Ines chez Larkfield, sans adhésion (HTTP) −32003 forbidden rien
Un jeton sans tickets:read (HTTP) HTTP 403 rien
Un jeton expiré (HTTP) HTTP 401 token_refused (jeton refusé), "reason": "expired" (raison : expiré) (deux fois)

Avec un jeton expiré, l’hôte affichait une trace d’erreur de 86 lignes. Elle se terminait par MCPError: Server returned an error response (le serveur a renvoyé une réponse d’erreur). La vraie raison, expired (expiré), figurait seulement dans le journal du serveur. Pour quatre refus, elle ne figurait nulle part.

L’idée : des limites par couche et un événement par décision

Section intitulée « L’idée : des limites par couche et un événement par décision »

Des limites par couche. Chaque couche limite ce qu’elle comprend le mieux. L’hôte limite ce qu’il donne au modèle. Le transport limite la taille d’une requête. Le contrat limite chaque entrée et sortie. La règle d’affaires limite les actions permises. Une limite non répertoriée ne sera vérifiée par personne après la prochaine mise à niveau.

Quatre colonnes de limites. L'hôte, python -m host : arguments jusqu'à 2 000 caractères; limite de temps de 10 secondes, HOST_TOOL_TIMEOUT; résultat jusqu'à 4 000 caractères, tronqué et marqué; au plus 6 étapes par question. Le transport, Streamable HTTP : corps de requête jusqu'à 4 Mio, sinon HTTP 413, valeur par défaut du SDK 2.3.0; durée de vie du jeton de 600 secondes; clés de signature en cache pendant 10 minutes. Le contrat du serveur : requête de 3 à 200 caractères, limite de 1 à 5; extrait jusqu'à 300 caractères, texte du billet jusqu'à 1 500; les 3 derniers messages; montant de 0 à 10 000 avec 2 décimales. La règle d'affaires : remboursement jusqu'à 100,00, sinon over_limit; un propriétaire approuve, hors de l'application. En dessous, en rouge et en pointillés, éléments non créés dans ce cours qu'un déploiement à distance ajoute devant le serveur : requêtes par minute par personne; appels simultanés par personne; limite de temps pour le travail du serveur lui-même; ligne de journal pour un code 413.
Chaque limite de support-mcp et son emplacement. La ligne rouge n'est pas mise en place dans ce cours.
Description textuelle du diagramme
  • L’hôte : arguments ≤ 2 000 caractères; limite de temps de 10 secondes; résultat ≤ 4 000 caractères, tronqué et marqué; au plus 6 étapes.
  • Le transport (HTTP) : corps de requête ≤ 4 Mio (HTTP 413, valeur par défaut du SDK); durée de vie du jeton de 600 secondes; clés de signature en cache pendant 10 minutes.
  • Le contrat du serveur : requête de 3 à 200 caractères, limit (limite) de 1 à 5; extrait ≤ 300, texte du billet ≤ 1 500; 3 derniers messages; montant de 0 à 10 000.
  • La règle d’affaires : remboursement ≤ 100,00, sinon over_limit (limite dépassée); un propriétaire approuve hors de l’application.
  • Non mis en place : requêtes par minute par personne, appels simultanés par personne, limite de temps pour le travail du serveur lui-même, ligne de journal pour un code 413.

La ligne rouge est importante. Résultats et défaillances montrait que le délai maximal de l’hôte arrête l’attente, pas le travail. Rien n’empêche une personne d’envoyer mille recherches par minute. Sur un portable, c’est acceptable. Un déploiement à distance place ces limites devant le serveur, dans une passerelle ou un mandataire inverse. Notez-les comme éléments à traiter, pas comme fonctionnalités.

Un événement par décision. Un journal structuré consigne chaque événement sous forme d’un objet JSON sur une ligne, toujours avec les mêmes noms de champs. Un programme peut compter et filtrer ces lignes; une personne peut les lire. Chaque événement répond à quatre questions. Qui : l’utilisateur, l’organisation, le rôle et le client. Quoi : l’outil ou l’URI. Ce qui s’est passé : le résultat ou la raison. Combien de temps : la durée en millisecondes. Il ne contient jamais de jeton, d’adresse courriel ou de texte d’un billet de soutien.

Chaque refus est aussi une décision. Chaque refus reçoit donc une ligne, avec sa raison. Le client reçoit toujours seulement −32003 et le message. Le journal reçoit la raison, pour les personnes qui exploitent le serveur.

D’abord, observez le danger. Un développeur fatigué ajoute une ligne de débogage qui consigne les en-têtes de requête. Exécutez-la avec le fichier logs.py actuel. Cette ligne de débogage est construite pour la leçon :

Fenêtre de terminal
python -c 'from idp import keys; from support_mcp import logs; t = keys.access_token("usr-sam", "knowledge:read tickets:read", "http://127.0.0.1:8000/mcp"); logs.get_logger().event("debug", headers={"authorization": "Bearer " + t, "x-support-tenant": "larkfield"}, note="call back grace@larkfield.example", reply="token " + t)'
{"ts": "…", "event": "debug", "headers": {"authorization": "Bearer eyJhbGciOiJSUzI1…", "x-support-tenant": "larkfield"}, "note": "call back grace@larkfield.example", "reply": "token eyJhbGciOiJSUzI1…"}

L’usage des guillemets dans cette commande diffère sous PowerShell et n’a pas été testé. La sortie ci-dessus est tronquée après 16 caractères du jeton. Votre terminal affiche le jeton entier. Toute personne qui lit ce journal peut appeler le serveur comme Sam pendant 10 minutes. L’adresse courriel est une donnée personnelle, en texte clair.

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

    Fenêtre de terminal
    S=../nextia-learning-labs/C28/snapshots/end-of-m07
    cp "$S"/support_mcp/{logs,identity,server,writes,http}.py support_mcp/
    cp "$S/tests/test_logs.py" tests/
    cp "$S"/scripts/{latency,tee}.py scripts/
    cp "$S/README.md" .
  2. Exécutez de nouveau la même ligne de débogage. Maintenant, logs.py supprime les secrets avant d’écrire :

    {"ts": "…", "event": "debug", "headers": {"authorization": "[redacted]", "x-support-tenant": "larkfield"}, "note": "call back [email]", "reply": "token [token]"}
  3. Faites une demande comme Tomás, qui n’a aucune adhésion :

    Fenêtre de terminal
    python -m host "Draft a reply to ticket T-30002" --user usr-tomas
    [host] discovered 3 tools: search_knowledge, get_ticket, propose_refund {"protocol": "2026-07-28", "server": "support-mcp"}
    [model] wants get_ticket {"arguments": {"ticket_id": "T-30002"}}
    [host] read-only tool on the allow-list: run it {"decision": "auto"}
    {"ts": "…", "event": "refused", "tool": "get_ticket", "user": "usr-tomas", "tenant": "larkfield", "client": "local", "reason": "no_membership"}
    [server] protocol error -32003: forbidden: you have no access to this organization {"code": -32003}
    …

    Chaque appel refusé a maintenant sa ligne, avec la raison no_membership (aucune adhésion). Tomás voit toujours seulement « forbidden » (interdit).

  4. Exécutez les tests des journaux :

    Fenêtre de terminal
    python -m pytest -q tests/test_logs.py
    .... [100%]
    4 passed in 0.29s

Le masquage agit sur chaque champ, à toute profondeur. Il supprime les champs dont le nom contient authorization, token, secret, password, api_key ou credential. Il supprime donc aussi MODEL_API_KEY. Il supprime également certaines valeurs selon leur forme : un jeton porteur, un jeton signé commençant par eyJ ou une adresse courriel :

support_mcp/logs.py (redact)
def redact(value):
"""A copy of `value` without tokens, secrets or email addresses."""
if isinstance(value, dict):
return {k: "[redacted]" if SECRET_NAME.search(str(k)) else redact(v) for k, v in value.items()}
if isinstance(value, list | tuple):
return [redact(v) for v in value]
if isinstance(value, str):
value = BEARER.sub("Bearer [redacted]", value)
value = JWT.sub("[token]", value)
return EMAIL.sub("[email]", value)
return value

Le masquage est une protection supplémentaire, pas une conception. Une liste de noms n’est jamais complète : une clé dans un champ nommé config passe. La conception consiste à consigner seulement les champs choisis : identifiants, résultats et durées. Cette protection sert le jour où quelqu’un consigne trop de données.

Les événements de refus proviennent d’un seul endroit. Chaque refus est maintenant une erreur Refused (refusé), qui connaît sa raison, l’utilisateur et l’organisation. La fonction caller() du serveur vérifie l’adhésion et la portée, puis écrit une ligne quand elle refuse :

support_mcp/server.py (caller)
def caller(ctx: Context, scope: str | None = None, **what) -> identity.Caller:
try:
who = mcp.caller_of(ctx)
if scope:
identity.require_scope(who, scope)
return who
except identity.Refused as e:
log.event("refused", **what, **e.log_fields())
raise

L’équipe du cours a testé de nouveau les six refus avec les nouveaux fichiers. Chacun a maintenant une ligne :

Refus Journal du serveur à la fin du module 7
Tomás, sans adhésion (stdio) refused (refusé), get_ticket, usr-tomas, larkfield, no_membership
Sam avec seulement knowledge:read refused, get_ticket, usr-sam, staff, insufficient_scope
Omar propose un remboursement refused, propose_refund, T-30002, 25, usr-omar, read_only, role
Ines chez Larkfield (HTTP) refused, search_knowledge, usr-ines, larkfield, no_membership
Un jeton sans tickets:read (HTTP) refused, usr-sam, insufficient_scope, tickets:read, 403 (deux fois)
Un jeton expiré (HTTP) token_refused, expired (deux fois)

Pourquoi deux fois par HTTP? Le client du SDK envoie server/discover. Sur un code 401 ou 403, il essaie aussi l’ancien initialize, en mode auto (automatique). Deux requêtes, deux refus, deux lignes. L’hôte affiche toujours sa trace d’erreur de 86 lignes pour un jeton expiré. C’est à l’hôte de corriger cela. Un bon hôte intercepte le code 401 et dit à la personne « veuillez vous reconnecter ». Le serveur a fait sa part : la raison figure dans son journal.

Une ligne de journal indique ce que le serveur a décidé. Elle ne montre pas les messages. Pour les voir, placez un enregistreur entre un hôte et le serveur. scripts/tee.py démarre le serveur et transmet chaque ligne sans modification dans les deux sens. Il écrit aussi chaque ligne dans un fichier, avec l’heure et le sens.

Tout hôte qui démarre des serveurs stdio depuis un fichier de configuration peut l’utiliser. Vous changez seulement la commande. Inspector lit le même format de fichier que plusieurs hôtes de bureau. Créez mcp-tee.json dans le dossier du projet :

mcp-tee.json
{
"mcpServers": {
"support-mcp": {
"command": "python",
"args": ["-m", "scripts.tee", "--out", "messages.jsonl", "--", "python", "-m", "support_mcp"]
}
}
}

Ensuite, exécutez un appel par cet enregistreur (--config remplace la commande du serveur, donc -- n’est pas nécessaire) :

Fenêtre de terminal
npx @modelcontextprotocol/inspector@2.10.1 --cli --config mcp-tee.json --server support-mcp --method tools/call --tool-name get_ticket --tool-arg ticket_id=T-30002

L’appel fonctionne comme avant. messages.jsonl contient maintenant 7 lignes, de initialize au résultat (version par défaut d’Inspector). Chaque ligne ressemble à celle-ci, abrégée :

{"t_ms": 262.9, "dir": "->", "bytes": 114, "message": {"method": "tools/call", "params": {"name": "get_ticket", "arguments": {"ticket_id": "T-30002"}}, "jsonrpc": "2.0", "id": 2}}

L’enregistreur copie tout, y compris le texte du billet et le nom du client. Traitez donc un fichier tee comme des données privées : excluez-le du dépôt et supprimez-le après utilisation. Dans un hôte de bureau, l’emplacement du fichier de configuration varie selon le produit. Le cours n’en a testé aucun.

L’équipe du cours a enregistré de la même façon la requête de l’hôte « Draft a reply to ticket T-30002 » (rédigez une réponse au billet T-30002). Le fichier contient aussi les lignes de journal du serveur. Voici les trois enregistrements d’une requête côte à côte :

Une requête, trois enregistrements, pour python -m host Draft a reply to ticket T-30002, Sam sur stdio. Trois colonnes : les étapes affichées par l'hôte, la liaison enregistrée par scripts/tee.py et le journal du serveur sur stderr. Hôte : connexion, découverte. Liaison : à 0,3 ms, server/discover, identifiant 1, 246 octets, vers le serveur; à 248,4 ms, son résultat, 605 octets; à 249,0 ms, tools/list, identifiant 2, 241 octets; à 249,7 ms, son résultat, 4 460 octets. Hôte : le modèle veut get_ticket T-30002; liste d'autorisation, exécution. Liaison : à 250,6 ms, tools/call get_ticket, identifiant 3, 297 octets. Journal : à 251,1 ms, tool_call get_ticket ok, usr-sam chez larkfield, staff, 0,05 ms dans l'outil. Liaison : à 251,6 ms, le résultat, identifiant 3, 1 325 octets. Hôte : le modèle veut search_knowledge; liste d'autorisation, exécution. Liaison : à 268,8 ms, tools/call search_knowledge, identifiant 4, 325 octets. Journal : à 269,6 ms, tool_call search_knowledge ok, 3 résultats, usr-sam chez larkfield, staff, 0,22 ms dans l'outil. Liaison : à 269,9 ms, le résultat, identifiant 4, 2 220 octets. Remarque : aucun champ ne relie les trois enregistrements; vous les associez selon l'heure, l'outil, l'utilisateur et l'organisation. La ligne de journal ne contient aucun texte de billet ni jeton; la liaison contient tout, donc gardez les fichiers tee privés.
Une requête enregistrée à la fin de ce module : les étapes de l'hôte, la liaison et le journal du serveur. Les temps sont mesurés depuis le début de la connexion.
Description textuelle du diagramme
  1. Hôte : connexion et découverte. Liaison : server/discover (246 octets) à 0,3 ms, son résultat à 248,4 ms; tools/list (241 octets) et son résultat (4 460 octets).
  2. Hôte : le modèle veut get_ticket T-30002; l’hôte l’exécute. Liaison : tools/call get_ticket à 250,6 ms. Journal : tool_call get_ticket ok (appel get_ticket réussi), Sam chez Larkfield, personnel, 0,05 ms dans l’outil. Liaison : le résultat, 1 325 octets, à 251,6 ms.
  3. Hôte : le modèle veut search_knowledge. Liaison : l’appel à 268,8 ms. Journal : tool_call search_knowledge ok (appel search_knowledge réussi), 3 résultats, 0,22 ms. Liaison : le résultat, 2 220 octets, à 269,9 ms.

Lisez la trace depuis le haut. Le démarrage prend la majeure partie du temps. La première réponse est arrivée après 248 ms, pendant que Python démarrait le processus du serveur. Chaque appel d’outil a pris environ 1 ms sur la liaison, de la requête à la réponse. L’outil lui-même n’a utilisé que 0,05 ms et 0,22 ms de ce temps. Le reste venait du travail du protocole et des tubes de l’enregistreur.

Aucun identifiant commun ne relie l’hôte, la liaison et le journal. Vous associez les trois enregistrements selon l’heure, l’outil, l’utilisateur et l’organisation. Cela fonctionne sur un seul portable. Dans un système avec plusieurs serveurs, vous ajouteriez un identifiant de requête à chaque ligne de journal. Ce cours ne le met pas en place.

Combien de temps prend un appel, et le transport change-t-il quelque chose? scripts/latency.py appelle get_ticket 200 fois sur une connexion, après 5 appels de préparation, en trois passages. Il le fait sur stdio et sur Streamable HTTP. Il mesure aussi le démarrage d’un serveur stdio. Les lignes de journal du serveur vont vers stderr; masquez-les :

Fenêtre de terminal
python -m scripts.latency --calls 200 --passes 3 2>/dev/null
200 get_ticket calls per pass, 3 passes, on arm64 Darwin 25.6.0
pass 1: stdio median 0.67 ms (p95 0.72), HTTP median 1.11 ms (p95 1.19)
pass 2: stdio median 0.67 ms (p95 0.72), HTTP median 1.12 ms (p95 1.2)
pass 3: stdio median 0.67 ms (p95 0.72), HTTP median 1.15 ms (p95 1.25)
median of the passes: stdio 0.67 ms, HTTP 1.12 ms
start a stdio server and list its tools: median 294.46 ms (10 starts)

La médiane est la valeur du milieu : la moitié des appels étaient plus rapides. Le p95 est le temps que 95 appels sur 100 ne dépassent pas. Les deux comptent : la médiane indique ce qui est normal, et le p95 indique la durée d’un appel lent.

  • stdio
  • Streamable HTTP
Deux exécutions de scripts.latency sur le portable de l'équipe du cours (Apple M4), pendant que d'autres tâches s'exécutaient. 200 appels par passage, 3 passages; la médiane des passages. Vos chiffres seront différents.
Description textuelle du graphique

Un graphique à quatre colonnes. Première exécution : stdio 0.68 ms, Streamable HTTP 1.16 ms. Deuxième exécution, à la fin de ce module : stdio 0.67 ms, Streamable HTTP 1.12 ms. Démarrer un serveur stdio et lister ses outils a pris une médiane de 296.5 ms à la première exécution et de 294.46 ms à la deuxième.

Trois points ressortent. Un appel local est rapide : moins de 1 ms sur stdio. HTTP ajoute environ une demi-milliseconde pour l’encapsulation HTTP et la vérification du jeton. Le démarrage d’un serveur coûte environ 300 ms, soit plus de 400 appels. Un hôte devrait donc garder une connexion ouverte, sans démarrer un serveur pour chaque question.

Ces chiffres concernent un seul portable, avec d’autres tâches en cours. Ils n’indiquent pas une capacité. Ils ne disent rien sur 50 personnes simultanées ou sur un serveur accessible par Internet. Mesurez sur votre propre machine et comparez les exécutions, pas les machines.

  • Limites : ajoutez-en une pour chaque entrée contrôlée par la personne qui appelle, puis inscrivez-la dans la carte des limites. Une limite a un petit coût : une vraie requête un peu trop grande échoue. Choisissez le nombre selon vos données, puis testez-le.
  • Événements structurés : consignez chaque décision : chaque appel, chaque refus, chaque refus de jeton. Les lignes occupent de l’espace disque. Quelqu’un doit les conserver pendant une durée définie, puis les supprimer. Les journaux contiennent des données sur les personnes : ils exigent les mêmes soins que les données elles-mêmes.
  • L’enregistreur tee : utilisez-le pour déboguer et apprendre ce qu’un hôte envoie. Ne le laissez pas actif : il enregistre tout, y compris les secrets.
  • Le script de latence : exécutez-le avant et après une modification qui pourrait ralentir le serveur. Comparez avec votre propre exécution précédente, jamais avec un autre ordinateur.

Erreur courante

Vos latences sont beaucoup plus élevées que celles de la leçon

Symptôme : la médiane avec stdio atteint plusieurs millisecondes, ou les mesures varient beaucoup d’une série à l’autre.

Cause : d’autres programmes utilisent l’ordinateur, ou les lignes de journal stderr s’affichent dans le terminal pendant la mesure.

Solution : ajoutez 2>/dev/null (PowerShell : 2>$null), fermez les programmes gourmands en ressources et recommencez. Comparez vos séries entre elles, pas avec la leçon.

Erreur courante

Une ligne de journal affiche [email] là où vous attendiez une valeur

Symptôme : un champ nécessaire, comme l’objet d’un billet, affiche [email] (courriel) ou [token] (jeton) dans le journal.

Cause : la valeur contenait une adresse courriel ou du texte ressemblant à un jeton, et le masquage l’a supprimé.

Solution : c’est le comportement prévu. Consignez un identifiant plutôt que du texte libre, par exemple celui du billet. Consultez les détails dans les données au besoin.

Réinitialisation. Si votre projet ne fonctionne plus, copiez l’instantané end-of-m07 comme dans La place de MCP, en remplaçant start par end-of-m07. Ensuite, python -m pytest -q affiche 94 passed (94 tests réussis).

Vérifiez votre compréhension

Ines, qui n'a aucune adhésion chez Larkfield, appelle search_knowledge par HTTP. Que reçoit-elle, et que consigne le journal du serveur? Nommez deux éléments que la ligne de journal doit contenir et deux qu'elle ne doit jamais contenir.

Afficher la réponse

Ines reçoit −32003, « forbidden : you have no access to this organization » (accès interdit : vous n’avez pas accès à cette organisation). La réponse est identique pour une organisation réelle ou inventée. Le journal reçoit une ligne : "event": "refused", "tool": "search_knowledge", "user": "usr-ines", "tenant": "larkfield", "client": "support-host", "reason": "no_membership". Elle indique un refus, l’outil, l’utilisateur, le locataire, le client et le motif : aucune adhésion. Elle doit préciser qui a reçu le refus et pourquoi, par exemple l’utilisateur et le motif. L’organisation et l’outil sont aussi utiles. Elle ne doit jamais contenir son jeton d’accès ni des données personnelles, comme une adresse courriel. Elle ne doit pas non plus contenir le texte de la requête, qui peut inclure des données de clients.

Vérifiez votre compréhension

Faites une prédiction : un hôte démarre un nouveau serveur stdio pour chaque question, et chaque question nécessite deux appels d'outil. Selon les mesures de cette leçon, combien de temps prend environ la partie MCP d'une question? Que changeriez-vous?

Afficher la réponse

Le démarrage du serveur et la liste de ses outils ont pris environ 295 ms en médiane. Deux appels avec stdio prennent environ 0,67 ms chacun. La partie MCP prend donc environ 296 ms, presque entièrement pour le démarrage. Gardez une seule connexion ouverte pour toute la conversation ou toute la session. La partie MCP descend alors à environ 1,4 ms par question. Ces mesures viennent d’un ordinateur portable exécutant d’autres tâches : mesurez sur votre propre ordinateur avant de décider.

Récapitulatif

  • Les limites se trouvent à plusieurs niveaux : hôte, transport, contrat et règle d’affaires. Énumérez-les toutes, y compris la limite de 4 Mio du SDK pour le corps du message. Notez les limites manquantes.
  • Un événement structuré par décision : qui, quoi, ce qui s’est passé et la durée. Chaque refus produit maintenant une ligne refused (refusé) avec son motif.
  • Aucun secret dans les journaux : consignez des champs choisis; le masquage supprime les jetons et les adresses courriel par précaution.
  • scripts/tee.py enregistre les échanges entre tout hôte stdio et le serveur; son fichier contient des données privées.
  • Un appel local : médiane de 0,67 ms avec stdio, de 1,12 ms par HTTP; démarrer un serveur prend environ 300 ms. Ce sont des mesures sur un ordinateur portable, pas une capacité.
  • Votre projet affiche maintenant 94 passed.

Ensuite, vous classez ce que MCP offre encore, et ce qu’il n’offre plus, avant d’en avoir besoin.

Leçon suivante : Fonctionnalités optionnelles et évolutives