Transport à distance
- Leçon 14
- 50 min
- Module 5 : Accès à distance et autorisation
Où nous en sommes
Dans le module 4, nous avons créé un hôte qui découvre des outils, les exécute et résiste aux mauvaises réponses. Mais le serveur tourne encore sur l'ordinateur de Sam, et la personne qui le démarre est l'appelant. Dans cette leçon, nous exposons le même serveur avec HTTP pour plus de personnes et plus d'applications, et nous voyons ce qui change, comme passer d'un cahier personnel à un comptoir de magasin.
Leçon 14 sur 22 · MCP : connecter les applications d'IA aux outils et aux donnéesTransport à distance
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
Rendez le serveur MCP de Larkfield accessible à plusieurs personnes et à plusieurs applications d’IA. Vous exposez le même serveur avec Streamable HTTP et lui envoyez une requête manuellement. Vous voyez ensuite ce qui change par rapport à un processus local : l’appelant, le réseau et HTTPS.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Comment le serveur stdio détermine son appelant à partir de l’environnement, dans Transport local.
- Comment l’hôte du cours découvre les outils et les exécute, dans Intégration du client.
- Les jetons d’accès, leur audience et leurs portées, dans OAuth et OIDC du cours Authentification, autorisations et applications multilocataires.
Votre projet
~/projects/support-mcpà la fin du module 4 :python -m pytest -qaffiche49 passed(49 tests réussis).curl, inclus dans macOS, Linux et Windows 10 ou une version ultérieure. Dans PowerShell, tapezcurl.exe, et noncurl.- Trois fenêtres de terminal. Dans chacune, allez dans
~/projects/support-mcpet activez l’environnement virtuel.
Un cahier et un comptoir de magasin
Section intitulée « Un cahier et un comptoir de magasin »Sam garde un cahier sur son bureau. Sam est la seule personne à le lire. Le cahier n’a donc besoin ni de serrure ni de liste de lecteurs. La personne qui l’ouvre est Sam.
L’équipe veut maintenant offrir les mêmes renseignements à un comptoir donnant sur la rue. Beaucoup de personnes viennent au comptoir, toute la journée. Trois choses changent à la fois. Le comptoir a besoin d’une adresse pour que les gens le trouvent. Quelqu’un doit vérifier une carte pour chaque visiteur, chaque fois, car n’importe qui peut se présenter. Et le trajet vers le comptoir se fait en public. Il faut donc une porte fermée pour protéger la conversation.
Le problème : le serveur se trouve sur un seul portable
Section intitulée « Le problème : le serveur se trouve sur un seul portable »Jusqu’ici, support-mcp s’exécutait comme processus enfant sur le même ordinateur que son hôte. Cela fonctionne pour l’assistant personnel de Sam. Cela ne fonctionne pas pour l’assistant du service de soutien, qui s’exécute sur un serveur partagé. Cela ne fonctionne pas non plus pour l’application partenaire d’Omar, qui s’exécute dans une autre entreprise.
Il y a un deuxième problème, plus grave. Le serveur stdio détermine son appelant à partir de son environnement. Transport local a montré ce qui arrive quand l’environnement ne fournit rien : le serveur utilise ses valeurs par défaut, Sam chez Larkfield. Si un service partagé déterminait son appelant à partir de son propre environnement, chaque personne connectée serait Sam. Omar, Tomás et un inconnu sur le réseau liraient tous les billets de soutien de Larkfield comme membres du personnel.
Le serveur distant a donc besoin de deux nouvelles choses. Il lui faut un transport qui fonctionne sur un réseau. Et il lui faut une preuve de l’identité de l’appelant dans chaque requête, pas dans le processus.
L’idée : Streamable HTTP et un jeton dans chaque requête
Section intitulée « L’idée : Streamable HTTP et un jeton dans chaque requête »Streamable HTTP est le transport MCP pour un serveur qui s’exécute comme service web. Le serveur écoute à une seule URL, le point de terminaison MCP : ici, http://127.0.0.1:8000/mcp. Le client envoie chaque message JSON-RPC dans le corps d’une requête HTTP POST à cette URL. Le serveur répond avec un seul corps JSON, ou avec un flux d’événements quand il doit envoyer plusieurs messages. Ce flux explique le nom « Streamable » (qui peut être transmis en continu).
Dans la révision 2026-07-28, chaque requête est indépendante. Elle contient la même enveloppe _meta qu’avec stdio, plus des en-têtes qui répètent ses renseignements clés. MCP-Protocol-Version et Mcp-Method accompagnent chaque requête. Mcp-Name accompagne un appel d’outil, une lecture de ressource ou une demande de requête. Le serveur ne conserve aucune session, c’est-à-dire aucun souvenir des requêtes précédentes du même client. Un service très sollicité peut donc exécuter plusieurs copies du serveur, et n’importe quelle copie peut répondre à n’importe quelle requête.
Deux anciennes conceptions apparaissent encore dans les tutoriels. La révision 2025-11-25 utilisait Streamable HTTP avec une session. Après initialize, le serveur fournissait un en-tête Mcp-Session-Id que chaque requête suivante devait répéter. La première révision, 2024-11-05, avait un autre transport, HTTP+SSE, avec deux points de terminaison. Apprenez à reconnaître ces deux conceptions comme anciennes. 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.
L’appelant est déterminé par un jeton d’accès, la carte-clé d’hôtel du cours sur l’authentification. L’hôte l’envoie dans l’en-tête Authorization: Bearer … de chaque requête. Le serveur le vérifie chaque fois : la signature, l’émetteur, l’expiration et l’audience. L’audience doit être l’URL du serveur lui-même, http://127.0.0.1:8000/mcp. L’organisation vient d’un deuxième en-tête, X-Support-Tenant, défini par la configuration de l’hôte. Aucun argument d’outil ne la nomme, comme avant.
Description textuelle du diagramme
Local, stdio. Une personne sur un ordinateur. L’hôte démarre support-mcp comme processus enfant avec SUPPORT_USER=usr-sam et SUPPORT_TENANT=larkfield, et communique avec lui par stdin et stdout. L’appelant est la personne qui a démarré le processus. Il n’y a aucun port, donc aucun autre ordinateur ne peut l’atteindre, et aucun jeton.
Distant, Streamable HTTP. Plusieurs personnes et applications, une URL. L’assistant de soutien, un assistant d’éditeur et l’application partenaire ont chacun un client MCP. Chacun envoie POST /mcp avec un en-tête Authorization: Bearer … et un en-tête X-Support-Tenant à http://127.0.0.1:8000/mcp.
La personne se connecte au fournisseur d’identité d’exercice, http://127.0.0.1:8400, qui signe les jetons d’accès. Le serveur lit les clés publiques du fournisseur (JWKS) pour les vérifier. L’appelant est l’utilisateur nommé dans un jeton valide, pour chaque requête. Tout ce qui peut atteindre le port peut envoyer une requête. Hors de votre propre ordinateur, utilisez donc uniquement HTTPS.
Un petit exemple : une requête avec curl
Section intitulée « Un petit exemple : une requête avec curl »Voici une vraie requête, envoyée manuellement avec curl, et la vraie réponse du serveur. Amira envoie le même tools/call pour le billet T-30002 que vous avez envoyé avec stdio au module 3. Cette fois, il passe par HTTP.
Description textuelle du diagramme
La requête contient huit lignes d’en-tête et un corps.
Authorization: Bearer eyJhbGciOiJSUzI1NiIs…: qui. Un jeton d’accès pour ce serveur, ici celui de Sam.X-Support-Tenant: larkfield: où. L’organisation, tirée des paramètres de l’hôte.Accept: application/json, text/event-stream: le client peut lire du JSON ou un flux. Avecapplication/jsonseulement, le serveur répond 406.MCP-Protocol-Version: 2026-07-28: quelle révision. Sans cet en-tête, le serveur traite la requête selon l’ancienne génération.Mcp-Method: tools/calletMcp-Name: get_ticket: quoi. Ils doivent correspondre au corps, sinon le serveur répond −32020.
Le corps est une requête JSON-RPC, avec la même enveloppe _meta qu’avec stdio. La réponse est HTTP/1.1 200 OK, avec un seul corps JSON de 1 324 octets et isError: false. Elle n’a aucun en-tête Mcp-Session-Id.
Comparez avec stdio. Le message JSON-RPC est le même, tout comme la réponse. Elle contient 1 324 octets ici et 1 325 avec stdio, où chaque ligne se termine par un saut de ligne. Seule l’enveloppe autour du message a changé. Les en-têtes répètent la méthode et le nom de l’outil. Un serveur mandataire ou une passerelle peut ainsi acheminer ou limiter une requête sans lire son corps.
Larkfield : exposer le serveur avec HTTP
Section intitulée « Larkfield : exposer le serveur avec HTTP »Le projet contient déjà les éléments nécessaires : une application Starlette de la trousse SDK, une vérification de jeton et un petit fournisseur d’exercice. Vous les copiez depuis l’instantané end-of-m05. Le fournisseur est le sujet d’Intégration d’OAuth; ici, vous le démarrez seulement.
-
Dans le terminal 3, copiez les fichiers de cette leçon :
Fenêtre de terminal S=../nextia-learning-labs/C28/snapshots/end-of-m05cp "$S"/support_mcp/{http,__main__,server,identity}.py support_mcp/cp "$S/scripts/local_http.py" scripts/cp -R "$S/idp" .cp "$S/tests/conftest.py" tests/cp "$S/.env.example" "$S/README.md" .Fenêtre de terminal $S = "..\nextia-learning-labs\C28\snapshots\end-of-m05"foreach ($f in "http", "__main__", "server", "identity") { Copy-Item "$S\support_mcp\$f.py" support_mcp\ }Copy-Item "$S\scripts\local_http.py" scripts\Copy-Item -Recurse "$S\idp" .Copy-Item "$S\tests\conftest.py" tests\Copy-Item "$S\.env.example", "$S\README.md" . -
Exécutez les tests. Le serveur stdio doit encore fonctionner comme avant :
Fenêtre de terminal python -m pytest -q................................................. [100%]49 passed in 7.29s -
Dans le terminal 1, créez la clé de signature du fournisseur une seule fois, puis démarrez le fournisseur :
Fenêtre de terminal python -m idp initpython -m idpSigning key b067a5e8442c44b0 in /Users/you/projects/support-mcp/.idpVotre identifiant de clé et votre dossier seront différents. La deuxième commande n’affiche rien et continue de s’exécuter. Elle écoute sur
http://127.0.0.1:8400. -
Dans le terminal 2, démarrez le serveur MCP avec HTTP :
Fenêtre de terminal python -m support_mcp --httpStreamableHTTP session manager startedC’est une ligne de journal de la trousse SDK sur stderr. Son nom vient de l’ancienne révision; les requêtes de la révision 2026-07-28 n’obtiennent aucune session. Le serveur écoute sur
http://127.0.0.1:8000/mcp. -
Dans le terminal 3, envoyez une requête sans jeton :
Fenêtre de terminal curl -i -X POST http://127.0.0.1:8000/mcp -H "Accept: application/json, text/event-stream" -H "Content-Type: application/json" -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\"}"HTTP/1.1 401 Unauthorizedcontent-type: application/jsonwww-authenticate: Bearer error="invalid_token", error_description="Authentication required", resource_metadata="http://127.0.0.1:8000/.well-known/oauth-protected-resource/mcp"{"error": "invalid_token", "error_description": "Authentication required"}Dans PowerShell, tapez
curl.exe; sa gestion des guillemets du JSON n’a pas été testée. Le serveur a refusé avant même que MCP démarre.resource_metadataindique où un client peut apprendre comment obtenir un jeton. Intégration d’OAuth suit ce lien. -
Obtenez un jeton d’exercice pour Sam et examinez son contenu :
Fenêtre de terminal TOKEN=$(python -m idp token --user usr-sam)python -c 'import jwt,sys,json; print(json.dumps(jwt.decode(sys.argv[1], options={"verify_signature": False}), indent=2))' "$TOKEN"Fenêtre de terminal $TOKEN = python -m idp token --user usr-sampython -c "import jwt,sys,json; print(json.dumps(jwt.decode(sys.argv[1], options={'verify_signature': False}), indent=2))" $TOKEN{"iss": "http://127.0.0.1:8400","sub": "usr-sam","aud": "http://127.0.0.1:8000/mcp","iat": 1791673121,"nbf": 1791673121,"exp": 1791673721,"jti": "1965650eff254c559a7c2302cc400f67","client_id": "support-host","scope": "knowledge:read tickets:read"}python -m idp tokenest un raccourci d’exercice : il signe un jeton sans connexion. Le jeton nomme l’utilisateur (sub), le serveur visé (aud) et les actions permises (scope). Il est valide pendant 600 secondes. Il ne nomme aucune organisation ni aucun rôle. -
Posez une question à l’hôte avec HTTP :
Fenêtre de terminal python -m host "What is the return window?" --http http://127.0.0.1:8000/mcp --token "$TOKEN" --tenant larkfieldDans PowerShell, écrivez
--token $TOKEN.[host] discovered 2 tools: search_knowledge, get_ticket {"protocol": "2026-07-28", "server": "support-mcp"}[model] wants search_knowledge {"arguments": {"query": "What is the return window?"}}[host] read-only tool on the allow-list: run it {"decision": "auto"}[server] result: 1078 characters {"ms": 17.4, "clipped": false}[model] final answerFrom "Returns policy" (policy://larkfield/returns-policy): … The version that applies is the one in force on the date your order was delivered. ## Return window You can return an unused item …Le modèle simulé et l’hôte sont les mêmes qu’au module 4. Seule la connexion a changé : une URL, un jeton et une organisation remplacent le processus enfant.
Le terminal 2 affiche maintenant une ligne de journal pour l’appel : "user": "usr-sam", "tenant": "larkfield", "role": "staff", "client": "support-host". L’utilisateur vient du jeton, l’organisation de l’en-tête et le rôle de la table des adhésions.
Lire le nouveau code
Section intitulée « Lire le nouveau code »support_mcp/__main__.py a une nouvelle option. Sans --http, rien n’a changé. Avec cette option, l’application Starlette de la trousse SDK s’exécute dans uvicorn, un serveur web pour Python :
if not a.http: from support_mcp.server import build_server
build_server(transport="stdio").run("stdio") return 0import uvicorn
from support_mcp.http import build_app
uvicorn.run(build_app(), host="127.0.0.1", port=a.port, log_level="warning")host="127.0.0.1" signifie « cet ordinateur seulement ». Un autre ordinateur sur votre réseau ne peut pas se connecter. C’est le choix sûr pour l’exercice, car le serveur n’a pas HTTPS.
Une ligne a changé dans support_mcp/server.py. L’appelant dépend maintenant du transport :
mcp.caller_of = (lambda ctx: identity.local_caller()) if transport == "stdio" else identity.http_callerLes outils n’ont pas changé du tout. get_ticket demande encore d’abord « qui est l’appelant? », puis vérifie une portée, puis lit les données d’une seule organisation. Seule la réponse à « qui? » vient d’ailleurs. Identité et autorisations examine http_caller.
support_mcp/http.py construit l’application web. Il fournit deux choses à la trousse SDK : un vérificateur de jetons et les paramètres d’autorisation :
mcp = build_server( knowledge, transport="http", token_verifier=verifier or JwtVerifier(issuer, resource_url), auth=AuthSettings( issuer_url=issuer, resource_server_url=resource_url, required_scopes=list(READ_SCOPES), validate_token_resource=False, # the verifier checks the audience itself ),)return mcp.streamable_http_app()JwtVerifier.check effectue la vérification de jeton du cours sur l’authentification, avec PyJWT. Il autorise uniquement l’algorithme RS256 et le type at+jwt, et prend la clé dans le JWKS du fournisseur. Ensuite, il vérifie la signature, l’émetteur, l’audience et l’expiration. Si la vérification échoue, la trousse SDK répond 401. La raison va uniquement dans le journal du serveur, sous "event": "token_refused". resource_url vaut MCP_RESOURCE_URL, soit http://127.0.0.1:8000/mcp par défaut : le nom du serveur lui-même, donc l’audience qu’il accepte.
À vous de jouer : omettre un en-tête
Section intitulée « À vous de jouer : omettre un en-tête »Changez une seule chose à la fois dans la requête du petit exemple. Avant d’exécuter chaque commande, prédisez la réponse. Le corps de la requête est dans un fichier, donc les deux interpréteurs de commandes peuvent l’envoyer.
-
Enregistrez le corps de la requête sous
call.jsondans le dossier du projet :{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_ticket","arguments":{"ticket_id":"T-30002"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"curl","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}}} -
Envoyez-le avec tous les en-têtes, comme dans le schéma :
Fenêtre de terminal curl -i -X POST http://127.0.0.1:8000/mcp -H "Authorization: Bearer $TOKEN" -H "X-Support-Tenant: larkfield" -H "Accept: application/json, text/event-stream" -H "Content-Type: application/json" -H "MCP-Protocol-Version: 2026-07-28" -H "Mcp-Method: tools/call" -H "Mcp-Name: get_ticket" --data-binary "@call.json"Dans PowerShell, tapez
curl.exeet gardez le reste. Vous obtenezHTTP/1.1 200 OKet le billet. -
Envoyez-le de nouveau sans les trois derniers en-têtes.
-
Envoyez-le de nouveau avec tous les en-têtes, mais avec
Mcp-Name: search_knowledge.
Afficher les réponses
Sans les trois en-têtes MCP (étape 3) :
HTTP/1.1 400 Bad Requestcontent-type: application/jsonmcp-session-id: 1e0f4c83ef7c4e98bb43a1f32aaebcd0
{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"Bad Request: Missing session ID"}}Sans l’en-tête MCP-Protocol-Version, la trousse SDK 2.3.0 traite la requête selon l’ancienne génération. Dans cette génération, un client envoie d’abord initialize, puis répète l’identifiant de session. Le serveur crée donc même une session et renvoie son identifiant. Le terminal 2 affiche Created new transport with session ID: … (nouveau transport créé avec l’identifiant de session : …) et Terminating session: … (fin de la session : …). L’ancienne génération a besoin d’une session; la génération actuelle n’en a pas besoin.
Avec le mauvais Mcp-Name (étape 4) :
{"jsonrpc":"2.0","id":1,"error":{"code":-32020,"message":"mcp-name header does not match the request body's 'name' parameter"}}Les en-têtes répètent le corps, donc le serveur vérifie qu’ils concordent. Une passerelle qui achemine ou limite selon l’en-tête peut alors lui faire confiance. Sans l’en-tête Mcp-Name, la réponse est la même : −32020.
Ce qui change par rapport à stdio, et ce que cela coûte
Section intitulée « Ce qui change par rapport à stdio, et ce que cela coûte »| Question | Local : stdio | Distant : Streamable HTTP |
|---|---|---|
| Qui démarre le serveur? | L’hôte, comme processus enfant | Vous, comme service qui continue de s’exécuter |
| Qui est l’appelant? | La personne qui l’a démarré | L’utilisateur dans un jeton d’accès valide, pour chaque requête |
| Combien d’appelants? | Un | Plusieurs, en même temps |
| Réseau | Aucun | Un port; ici, 127.0.0.1 seulement |
| Où circulent les secrets? | Nulle part | Le jeton, dans chaque requête |
Ce tableau est aussi le début de docs/remote-design.md, que vous complétez dans Intégration d’OAuth.
Utilisateurs. Un serveur local a un seul appelant pendant toute son exécution. Un serveur distant peut recevoir une requête de Sam, puis la suivante d’Ines. Le serveur vérifie donc un jeton dans chaque requête et ne conserve jamais l’appelant d’une requête précédente.
Réseau. Un port est une porte ouverte. Tout ce qui peut l’atteindre peut envoyer une requête. Le serveur doit donc refuser ce qu’il ne peut pas vérifier. Ce cours lie le serveur à 127.0.0.1 et n’ouvre jamais le port au réseau.
HTTPS. Un jeton porteur fonctionne pour quiconque le détient, comme une carte-clé. Avec HTTP sans chiffrement, quiconque peut voir le trafic réseau peut le copier. Hors de votre propre ordinateur, exposez le point de terminaison MCP et le fournisseur uniquement avec HTTPS. Le cours n’a pas testé HTTPS, un vrai fournisseur d’identité ou un déploiement dans le nuage.
Vitesse. Sur le portable de l’équipe du cours, un appel get_ticket après démarrage prenait une médiane de 0,68 ms avec stdio et de 1,16 ms avec HTTP. HTTP ajoute un peu de temps par appel. Mais il évite le démarrage d’un processus pour chaque hôte. Démarrer le serveur stdio et lister ses outils prenait une médiane de 296,5 ms. Vos temps seront différents.
Utilisez-le quand un serveur est partagé : par plusieurs personnes, par une application sur un autre ordinateur ou par un partenaire. Ne l’utilisez pas pour un outil que vous seul exécutez sur votre propre portable. stdio est alors plus simple et n’ouvre aucun port. Le coût représente un vrai travail : un fournisseur, des clés, des jetons qui expirent, un service à maintenir en exécution et HTTPS pour tout accès au-delà de votre ordinateur.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
Une longue trace d'erreur qui se termine par : MCPError : Server returned an error response
Symptôme : l’hôte fonctionnait il y a dix minutes. Maintenant, il affiche 86 lignes qui se terminent ainsi :
| mcp.shared.exceptions.MCPError: Server returned an error response +------------------------------------Cause : le jeton a expiré. Les jetons d’exercice durent 600 secondes. Le serveur répond à tout problème de jeton par le même code 401. Le client ne peut donc pas connaître la cause. Le journal du serveur dans le terminal 2 l’indique :
{"ts": "…", "event": "token_refused", "reason": "expired", "ms": 0.3}Le client de la trousse SDK a essayé server/discover, reçu 401, puis essayé l’ancien initialize et reçu encore 401. Vous voyez donc deux lignes token_refused (jeton refusé) pour une seule exécution.
Solution : obtenez un nouveau jeton dans le même terminal (TOKEN=$(python -m idp token --user usr-sam)), puis relancez l’hôte. Un véritable hôte renouvelle le jeton ou demande à la personne de se reconnecter.
Erreur courante
Illegal header value b'Bearer ' (valeur d'en-tête non valide)
Symptôme : l’hôte s’arrête immédiatement avec httpx2.LocalProtocolError: Illegal header value b'Bearer ' (valeur d’en-tête non valide).
Cause : le jeton est vide. Vous avez omis --token, ou vous avez défini $TOKEN dans un autre terminal. Chaque terminal a ses propres variables.
Solution : définissez TOKEN dans le terminal où vous exécutez l’hôte. echo $TOKEN doit afficher un long texte qui commence par eyJ.
Erreur courante
Adresse déjà utilisée, ou code 401 après un changement de port
Symptôme 1 : le serveur ne démarre pas :
ERROR: [Errno 48] error while attempting to bind on address ('127.0.0.1', 8000): [errno 48] address already in useUn autre programme, ou une deuxième copie du serveur, utilise le port 8000. Arrêtez l’autre copie avec Ctrl+C, ou utilisez un autre port. Le numéro d’erreur diffère entre Windows et Linux.
Symptôme 2 : vous avez démarré le serveur avec MCP_PORT=8001 et MCP_RESOURCE_URL=http://127.0.0.1:8001/mcp. Chaque requête reçoit maintenant 401, et le terminal 2 consigne "reason": "wrong_audience" (audience incorrecte).
Cause : vous avez créé le jeton dans un terminal où MCP_RESOURCE_URL avait encore sa valeur par défaut. La valeur aud du jeton était http://127.0.0.1:8000/mcp, et le serveur sur le port 8001 accepte seulement sa propre URL. L’équipe du cours a observé exactement ce résultat : 401 avec l’ancien jeton, 200 avec un jeton créé pour 8001.
Solution : définissez la même valeur de MCP_RESOURCE_URL dans chaque terminal : celui du serveur et celui qui crée les jetons. Elle doit correspondre à l’URL utilisée par les clients, car c’est l’audience.
Arrêtez les serveurs. Appuyez sur Ctrl+C dans les terminaux 1 et 2 quand vous avez terminé. Gardez .idp/ : ce dossier contient la clé d’exercice, et les prochaines leçons l’utilisent. .gitignore le contient déjà.
Réinitialisation. Si votre projet ne fonctionne plus, copiez l’instantané end-of-m04 comme dans La place de MCP, puis répétez l’étape 1.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Nommez deux éléments que le serveur stdio obtenait de son environnement. Indiquez où le serveur HTTP obtient chacun à la place.
Afficher la réponse
L’utilisateur : de SUPPORT_USER avec stdio, du sub d’un jeton d’accès valide avec HTTP. L’organisation : de SUPPORT_TENANT avec stdio, de l’en-tête X-Support-Tenant défini par la configuration de l’hôte avec HTTP. Les portées changent aussi de source : de SUPPORT_SCOPES à scope dans le jeton. Le rôle provient de la table des adhésions du serveur dans les deux cas.
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 envoyez un tools/call correct au serveur HTTP avec un jeton valide, mais sans l'en-tête MCP-Protocol-Version. Quelle réponse recevez-vous, et pourquoi?
Afficher la réponse
HTTP 400 avec l’erreur JSON-RPC −32600 « Bad Request : Missing session ID » (requête incorrecte : identifiant de session manquant), et un en-tête mcp-session-id. Sans l’en-tête de version, la trousse SDK 2.3.0 traite la requête selon l’ancien fonctionnement de Streamable HTTP. Ce fonctionnement exige d’abord une requête initialize, puis l’identifiant de session dans chaque requête. La révision 2026-07-28 n’a pas de session. Un client actuel envoie donc toujours l’en-tête.
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 : avec le fournisseur et le serveur en marche, envoyez tools/list avec curl, sans jeton. Quel statut et quel en-tête recevez-vous, et vers quoi l'en-tête pointe-t-il?
Afficher la réponse
HTTP/1.1 401 Unauthorized (non autorisé), avec www-authenticate: Bearer error="invalid_token", error_description="Authentication required", resource_metadata="http://127.0.0.1:8000/.well-known/oauth-protected-resource/mcp" (jeton non valide, authentification requise). Il pointe vers les métadonnées de la ressource protégée du serveur. Ce document indique au client quel serveur d’autorisation émet les jetons pour ce serveur.
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
- Streamable HTTP fournit MCP à une seule URL, le point de terminaison MCP. Chaque message JSON-RPC constitue le corps d’une requête HTTP
POST. - Dans la révision 2026-07-28, chaque requête est indépendante : l’enveloppe
_metaet les en-têtesMCP-Protocol-Version,Mcp-MethodetMcp-Name. Ce dernier accompagne un appel, une lecture ou une requête. Il n’y a pas de session. Les sessions (Mcp-Session-Id) et HTTP+SSE sont des mécanismes anciens. - Un jeton d’accès dans chaque requête identifie l’appelant, avec l’URL du serveur lui-même comme audience. L’organisation provient de l’en-tête
X-Support-Tenantde l’hôte. - Un serveur distant est une porte sur un réseau : vérifiez chaque requête et liez-le à
127.0.0.1pour les exercices. Utilisez HTTPS au-delà de votre propre ordinateur.
Votre projet fournit maintenant les mêmes outils avec stdio et HTTP, avec 49 tests. Ensuite, vous verrez comment le serveur transforme un jeton et un en-tête en décision : autorisé, ou refusé par quelle vérification.
Leçon suivante : Identité et autorisations