Intégration du client
- Leçon 11
- 50 min
- Module 4 : Connecter une application d'IA
Où nous en sommes
Dans le module 3, nous avons créé support-mcp et nous l'avons vérifié avec MCP Inspector. Mais un serveur est utile seulement quand une application d'IA l'utilise. Dans cette leçon, nous créons cette application : un petit hôte avec un client MCP et un modèle simulé, pour que chaque exécution produise les mêmes messages, sans frais. C'est comme une répétition avec une doublure.
Leçon 11 sur 22 · MCP : connecter les applications d'IA aux outils et aux donnéesIntégration du client
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
Créez l’application d’IA qui utilise le serveur de Larkfield. Vous ajoutez un petit hôte avec un client MCP et un modèle simulé. Chaque exécution produit ainsi les mêmes messages, sans frais. Vous gardez tout le code propre au modèle dans un seul fichier. Ensuite, si vous le voulez, vous passez à un vrai modèle pour voir ce qui change et ce qui reste pareil.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les notions d’hôte, de client et de serveur, présentées dans Participants et limites.
- Ce qu’est un appel d’outil, présenté dans Décrire un outil du cours Créer des applications fiables avec les API de LLM.
- Comment un hôte démarre un serveur stdio avec le client de la trousse SDK, présenté dans Transport local.
Votre projet
~/projects/support-mcpaprès Examiner le comportement, avec l’environnement virtuel actif :python -m pytest -qaffiche40 passed(40 tests réussis).- Le dépôt des exercices dans
~/projects/nextia-learning-labs. Récupérez d’abord les fichiers les plus récents :git -C nextia-learning-labs pull. - Aucun compte ni aucune clé. Un vrai modèle est optionnel, à la fin de la leçon.
Une répétition avec une doublure
Section intitulée « Une répétition avec une doublure »Une équipe de théâtre prépare une nouvelle pièce. L’éclairage doit changer quand l’acteur dit « Regardez, la tempête! ». La vedette coûte cher et vient seulement la dernière semaine. L’équipe travaille donc avec une doublure qui lit le texte de la même façon chaque fois.
La doublure n’est pas aussi bonne que la vedette. Ce n’est pas important, car l’équipe ne teste pas le jeu d’acteur. Elle teste les signaux, l’éclairage et les portes. Si un signal ne fonctionne pas, elle sait que le problème vient de l’équipe. La doublure ne change jamais une réplique.
Quand la vedette arrive, la scène ne change pas. Seule la personne sur scène change, et la vedette peut dire une réplique un peu différemment.
Le problème : un vrai modèle dans chaque test
Section intitulée « Le problème : un vrai modèle dans chaque test »Amira a un serveur qui fonctionne. Le service de soutien a maintenant besoin d’une application d’IA qui l’utilise. Sam tape « Rédigez une réponse au billet T-30002 », et l’assistant consulte le billet de soutien et les politiques. Amira pourrait connecter un vrai modèle tout de suite. Deux raisons en font une mauvaise première étape.
D’abord, un vrai modèle ne donne pas deux fois la même réponse. L’équipe du cours a posé deux fois la même question, avec le même modèle, le même hôte et le même serveur. À la première exécution, le modèle a demandé deux outils à la fois. Il a nommé la politique « Remboursements manuels et crédits de courtoisie ». À la deuxième exécution, il a fait trois appels et choisi ses propres mots de recherche. Il a nommé la « Politique de remboursement et de paiement ». Si cette deuxième exécution avait échoué, Amira n’aurait pas su si son code ou le modèle était en cause. Un vrai modèle exige aussi un compte, une clé, un réseau et de l’argent.
Ensuite, chaque fournisseur de modèles a son propre format. Un serveur MCP décrit un outil avec un nom, une description et un inputSchema (schéma d’entrée). L’API de clavardage utilisée dans le cours veut le même outil sous la forme {"type": "function", "function": {"name", "description", "parameters"}}. Si cette conversion est répartie dans l’application, changer de fournisseur exige des changements partout.
L’idée : un hôte, un client, une interface de modèle
Section intitulée « L’idée : un hôte, un client, une interface de modèle »L’hôte est l’application d’IA : le programme que la personne utilise. Il gère la conversation et décide de ce qui s’exécute. À l’intérieur, un client MCP garde une connexion avec un seul serveur. Vous avez rencontré ces deux noms dans Participants et limites. Cette leçon ajoute le troisième élément, le modèle, derrière une petite interface :
decide(messages, tools) -> DecisionL’hôte donne au modèle la conversation jusqu’ici et les outils, dans le format du fournisseur. Le modèle renvoie une décision : des appels d’outils à faire ou une réponse finale. Aucun autre élément de l’hôte ne sait à quel modèle il parle. Le code qui connaît le format d’un fournisseur est l’adaptateur de modèle. Il se trouve dans un seul fichier, host/models.py.
Le premier adaptateur est un modèle simulé : une doublure qui suit des règles fixes au lieu de réfléchir. « Mock » signifie une imitation faite pour les tests. Le modèle simulé de Larkfield a trois règles. Si la question contient un identifiant de billet, il demande get_ticket. S’il n’a pas encore fait de recherche, il demande search_knowledge. Sinon, il écrit une réponse à partir des résultats. Comme la doublure, il n’est pas intelligent, mais il ne change jamais une réplique. Si quelque chose ne fonctionne plus, la cause se trouve donc dans votre hôte, votre client ou votre serveur.
Description textuelle du diagramme
Sam tape une question dans l’hôte, python -m host. L’hôte a quatre parties :
__main__.pylit la question et les options. Il demande une confirmation à la personne quand l’hôte en a besoin.app.pycontient la boucle et les vérifications de l’hôte : découvrir, interroger le modèle, vérifier, appeler et limiter le résultat.models.pycontientdecide(messages, tools), qui renvoie uneDecision. Il contient deux modèles.MockModela des règles fixes et n’utilise aucun réseau.OpenAICompatibleModelutilise votre propre clé et communique en HTTPS avec l’API d’un fournisseur de modèles.- Le client MCP est le
Clientde la trousse SDK, un pour chaque serveur.StdioServerParameterslui indique la commande, les arguments et l’environnement (env=).
Le client communique en JSON-RPC sur stdin et stdout avec support-mcp. Ce processus enfant a SUPPORT_USER et SUPPORT_TENANT dans son environnement. Changez le modèle, et seul models.py change. Changez le serveur, et seuls les paramètres du client changent. La boucle et les vérifications dans app.py restent les mêmes.
Un petit exemple : le modèle simulé décide
Section intitulée « Un petit exemple : le modèle simulé décide »Avant de connecter quoi que ce soit, observez le modèle simulé prendre deux décisions. Ici, les descriptions des outils sont vides, car le modèle simulé lit seulement leurs noms. Lisez le code maintenant. Après les étapes ci-dessous, vous pourrez le coller dans python, dans le dossier de votre projet :
from host.models import MockModel
tools = [{"type": "function", "function": {"name": "get_ticket", "description": "", "parameters": {}}}, {"type": "function", "function": {"name": "search_knowledge", "description": "", "parameters": {}}}]messages = [{"role": "system", "content": "You are the help desk's assistant."}, {"role": "user", "content": "Draft a reply to ticket T-30002"}]model = MockModel()print(model.decide(messages, tools))messages.append({"role": "tool", "tool_call_id": "call_1", "content": '{"tool": "get_ticket", "result": {"ticket_id": "T-30002", "status": "open", "subject": "Charged twice for order LK-182074"}}'})print(model.decide(messages, tools))Decision(tool_calls=[ToolCall(id='call_1', name='get_ticket', arguments={'ticket_id': 'T-30002'})], answer=None, usage={}, raw=None)Decision(tool_calls=[ToolCall(id='call_2', name='search_knowledge', arguments={'query': 'Charged twice for order LK-182074'})], answer=None, usage={}, raw=None)Lisez les deux lignes. La première fois, la question contient T-30002, donc la règle « identifiant de billet → get_ticket » s’applique. Ensuite, la conversation contient un résultat de billet, mais aucune recherche. Le modèle simulé fait donc une recherche avec l’objet du billet. Il n’appelle rien lui-même : une Decision est seulement une demande écrite sous forme de données. L’hôte décide quoi en faire, dans la prochaine leçon. usage (utilisation) est vide, car aucun jeton n’a été utilisé. raw (données brutes) est vide, car aucun fournisseur n’a répondu.
Larkfield : ajouter l’hôte
Section intitulée « Larkfield : ajouter l’hôte »-
Dans
~/projects/support-mcp, avec l’environnement virtuel actif, copiez l’hôte depuis l’instantanéend-of-m04:Fenêtre de terminal S=../nextia-learning-labs/C28/snapshots/end-of-m04mkdir -p hostcp "$S"/host/{__init__,models,app,__main__}.py host/cp "$S/.env.example" "$S/README.md" .Fenêtre de terminal $S = "..\nextia-learning-labs\C28\snapshots\end-of-m04"New-Item -ItemType Directory -Force host | Out-Nullforeach ($f in "__init__", "models", "app", "__main__") { Copy-Item "$S\host\$f.py" host\ }Copy-Item "$S\.env.example", "$S\README.md" .L’hôte n’a besoin d’aucun nouveau paquet. Il utilise la trousse SDK installée au module 3 et le module
urllibde Python pour un vrai modèle. -
Posez une question à l’hôte :
Fenêtre de terminal python -m host "Draft a reply to ticket T-30002"[host] discovered 2 tools: search_knowledge, get_ticket {"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": "tool_call", "user": "usr-sam", "tenant": "larkfield", "role": "staff", "client": "local", "tool": "get_ticket", "outcome": "ok", "ms": 0.06}[server] result: 558 characters {"ms": 24.2, "clipped": false}[model] wants search_knowledge {"arguments": {"query": "Charged twice for order LK-182074"}}[host] read-only tool on the allow-list: run it {"decision": "auto"}{"ts": "…", "event": "tool_call", "user": "usr-sam", "tenant": "larkfield", "role": "staff", "client": "local", "tool": "search_knowledge", "outcome": "ok", "results": 3, "ms": 0.24}[server] result: 1025 characters {"ms": 2.5, "clipped": false}[model] final answerTicket T-30002 (open): Charged twice for order LK-182074.From "Refunds and payments policy" (policy://larkfield/refunds-and-payments): … Refunds to a gift card appear at once. ## Double charges If you were charged twice for the same order, we refund the extra charge …Vos valeurs
msseront différentes. L’exécution complète a pris environ 0,8 seconde sur le portable de l’équipe du cours. -
Vérifiez que rien d’autre n’a changé :
python -m pytest -qaffiche encore40 passed. Les tests de l’hôte arrivent dans Résultats et défaillances.
Chaque ligne commence par le nom de celui qui a agi. Les lignes [host] (hôte) sont les décisions de l’hôte. Les lignes [model] (modèle) sont les décisions du modèle, ici le modèle simulé. Les lignes [server] (serveur) sont les résultats reçus par le client MCP. Les lignes JSON entre elles sont les journaux du serveur. Le client de la trousse SDK transmet la sortie stderr du serveur à votre terminal, comme dans Transport local. Les deux dernières lignes sont la réponse : le modèle simulé copie le meilleur résultat de recherche, avec son titre et son URI.
L’hôte a trouvé deux outils et le protocole 2026-07-28 sans aucune négociation initiale. Le Client de la trousse SDK a envoyé server/discover et tools/list. La prochaine leçon suit ces messages un par un.
Lire le code de l’hôte
Section intitulée « Lire le code de l’hôte »Commencez par l’interface dans host/models.py. Une décision se compose de deux petites classes de données :
@dataclassclass ToolCall: id: str name: str arguments: dict
@dataclassclass Decision: tool_calls: list[ToolCall] = field(default_factory=list) answer: str | None = None usage: dict = field(default_factory=dict) raw: dict | None = NoneChaque classe de modèle a une méthode, decide(messages, tools), qui renvoie une Decision. MockModel.decide suit ses trois règles, avec une expression régulière qui trouve les identifiants de billets. OpenAICompatibleModel.decide envoie les mêmes messages et tools à une API de complétion de clavardage avec urllib. Ensuite, elle transforme les tool_calls (appels d’outils) du fournisseur en objets ToolCall. Voilà toute la partie propre au fournisseur : environ 40 lignes. make_model(name) choisit la classe à partir de l’option --model : mock (par défaut) ou openai.
Passons au côté MCP, dans host/app.py. L’hôte indique comment démarrer le serveur :
def server_params(user: str, tenant: str, scopes: str | None = None) -> StdioServerParameters: """How the host starts the local server: a child process that speaks MCP on stdin/stdout.""" env = {**os.environ, "SUPPORT_USER": user, "SUPPORT_TENANT": tenant, "PYTHONUNBUFFERED": "1"} if scopes: env["SUPPORT_SCOPES"] = scopes return StdioServerParameters(command=sys.executable, args=["-m", "support_mcp"], env=env)C’est le env= de Transport local. Sans lui, la trousse SDK 2.3.0 transmet seulement six variables au serveur : HOME, LOGNAME, PATH, SHELL, TERM et USER. Le serveur ne verrait jamais la personne ni l’organisation. Les options --user et --tenant les définissent, avec Sam chez Larkfield par défaut. PYTHONUNBUFFERED=1 fait écrire chaque ligne de journal immédiatement par le serveur.
Notez que cet hôte copie tout son environnement. Le serveur verrait donc aussi MODEL_API_KEY si vous la définissez. Ici, les deux programmes sont les vôtres. Pour un serveur que vous n’avez pas écrit, transmettez seulement ce dont il a besoin. Limites des identifiants revient sur ce point.
__main__.py ouvre la connexion avec async with Client(app.server_params(...)) as client:. Le client démarre le processus enfant et l’arrête à la fin du bloc. Un hôte, un client, un serveur.
Enfin, la conversion entre les deux formats :
def tool_spec(tool) -> dict: """An MCP tool, as an OpenAI-style function definition for the model.""" return { "type": "function", "function": {"name": tool.name, "description": tool.description or "", "parameters": tool.input_schema}, }Pour get_ticket, le résultat contient le nom et la description d’une ligne que vous avez corrigée au module 3. Il contient aussi le schéma d’entrée, avec le motif ^T-\d{5}$. Le schéma de sortie et les annotations ne sont pas transmis, donc le modèle ne les voit jamais. Ensemble, les définitions des deux outils totalisent 1 168 caractères. Un fournisseur qui veut une autre structure exige seulement une autre fonction tool_spec et un autre adaptateur.
Optionnel : le même hôte avec un vrai modèle
Section intitulée « Optionnel : le même hôte avec un vrai modèle »Vous pouvez sauter cette partie. La suite du cours n’exige aucun vrai modèle.
Il vous faut une clé pour une API de clavardage compatible avec OpenAI, ou un serveur de modèle local offrant cette API. Vous pouvez ensuite exécuter le même hôte avec ce modèle. Fixez d’abord une limite de dépenses chez votre fournisseur. Puis définissez trois variables dans votre interpréteur de commandes et ajoutez --model openai :
export MODEL_BASE_URL="https://api.example.com/v1" # your provider's URL, ending in /v1export MODEL_NAME="your-model"read -rs MODEL_API_KEY && export MODEL_API_KEY # paste the key, then press Enterpython -m host "Draft a reply to ticket T-30002." --model openai$env:MODEL_BASE_URL = "https://api.example.com/v1" # your provider's URL, ending in /v1$env:MODEL_NAME = "your-model"$env:MODEL_API_KEY = Read-Host "Key" -MaskInputpython -m host "Draft a reply to ticket T-30002." --model openairead -rs et -MaskInput empêchent l’affichage de la clé et son ajout à l’historique de votre interpréteur de commandes. L’adaptateur envoie la clé dans deux en-têtes, api-key et Authorization. Azure lit le premier, et la plupart des autres services lisent le second. Certains modèles refusent d’utiliser des outils, sauf si vous définissez aussi MODEL_REASONING_EFFORT=none. Le modèle du cours était l’un d’eux.
L’équipe du cours a exécuté cet exemple avec chat-small, un petit modèle sur Azure. Voici la deuxième exécution de la section sur le problème, telle que l’hôte l’a affichée, sans les journaux du serveur :
[host] discovered 2 tools: search_knowledge, get_ticket {"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"}[server] result: 558 characters {"ms": 43.6, "clipped": false}[model] wants search_knowledge {"arguments": {"query": "duplicate charge payment refund duplicate payments billing receipt screenshot processing", "limit": 3}}[host] read-only tool on the allow-list: run it {"decision": "auto"}[server] result: 1252 characters {"ms": 4.3, "clipped": false}[model] final answer
Hi Hugo,
I’m sorry you may have been charged twice for order LK-182074. Please send us a receipt or screenshot showing both $449.00 charges so we can verify them with our payments team. If we confirm a duplicate charge, Finance will refund the extra payment within 3 business days.
Policy used: **Refunds and payments policy**.Comparez-la avec l’exécution simulée. Les lignes de l’hôte sont du même type, tout comme les résultats du serveur. Seules les lignes [model] ont changé. Le vrai modèle a choisi ses propres mots de recherche et sa propre valeur limit (limite), puis rédigé une vraie réponse. La réponse s’appuie sur les données : le billet indique 449,00 dollars, et la politique indique « dans les 3 jours ouvrables ».
Description textuelle du diagramme
La même question, « Rédigez une réponse au billet T-30002 », dans trois exécutions :
| Modèle simulé (règles) | chat-small, exécution A | chat-small, exécution B | |
|---|---|---|---|
| Appels de modèle | 0 sur le réseau | 2 | 3, un outil par appel |
| Outils demandés | get_ticket T-30002, puis search_knowledge « Facturation en double pour la commande LK-182074 » |
get_ticket T-30002 et search_knowledge « politique de réponse du soutien à la clientèle … » ensemble, au premier appel |
get_ticket T-30002, puis search_knowledge « facturation double paiement remboursement paiements en double … » |
| Réponse | la ligne du billet et l’extrait de la « Politique de remboursement et de paiement » | une réponse à Hugo, qui nomme « Remboursements manuels et crédits de courtoisie » | une réponse à Hugo, qui nomme « Politique de remboursement et de paiement » |
| Jetons en entrée / sortie | aucun | 532 + 1 053 / 61 + 80 | 352 + 554 + 877 / 21 + 31 + 76 |
L’hôte, le client MCP et le serveur étaient les mêmes. L’exécution A a été enregistrée avec le serveur terminé du cours, qui offre aussi un troisième outil.
Combien cela a-t-il coûté? L’exécution B a utilisé 1 783 jetons en entrée et 128 en sortie. Cela représente environ 0,00024 $ US aux tarifs payés par l’équipe du cours. Sur cinq exécutions de cette question, la médiane était de 3 appels de modèle, 2 309 jetons en entrée et 146 en sortie. Chaque question coûtait de 0,0003 à 0,0004 $ US. La durée médiane d’un appel de modèle était de 1,2 seconde. Toutes les exécutions avec un vrai modèle pour ce cours, soit 70 appels, ont coûté 0,0074 $ US. Les prix changent : consultez la page actuelle de votre fournisseur.
Quand un modèle simulé suffit, et ce que cela coûte
Section intitulée « Quand un modèle simulé suffit, et ce que cela coûte »Utilisez le modèle simulé pour tout ce qui ne concerne pas le jugement du modèle. Cela comprend la connexion, la découverte, les vérifications de l’hôte, les défaillances et les tests. Il est gratuit, n’exige aucun réseau et donne les mêmes messages chaque fois. L’échec d’un test a donc une signification. Le cours l’utilise dans chaque leçon, et les tests de Résultats et défaillances l’utilisent aussi.
Utilisez un vrai modèle quand la question concerne le modèle. Choisit-il le bon outil? Écrit-il de bons mots de recherche? Suit-il les instructions du serveur? Résiste-t-il à un billet qui tente de le tromper? Un modèle simulé ne peut pas répondre à ces questions.
Cette séparation a aussi des coûts :
- Un modèle simulé masque le comportement réel. L’exécution A a demandé deux outils dans une seule décision : un appel d’outils parallèle. Le modèle simulé ne le fait jamais. Votre hôte doit quand même le gérer, et la prochaine leçon montre comment.
- Un fichier de plus à garder à jour. Quand un fournisseur change son format,
models.pychange. C’est le but : seulmodels.pychange. - L’interface est petite par choix.
decide()transmet des messages et des outils, rien de plus. Une fonctionnalité propre à un fournisseur exige du travail dans l’adaptateur, comme la transmission de la réponse mot par mot.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
ValueError : unknown model 'nonsense': use mock or openai
Symptôme : l’hôte s’arrête avant de se connecter. La dernière ligne d’une longue trace d’erreur est ValueError: unknown model 'nonsense': use mock or openai (modèle « nonsense » inconnu : utilisez mock ou openai).
Cause : la valeur de --model ne figure pas parmi les noms que make_model() connaît.
Solution : utilisez --model mock (par défaut) ou --model openai. Si vous ajoutez votre propre adaptateur, ajoutez son nom à make_model() dans host/models.py, le seul fichier qui connaît les modèles.
Erreur courante
KeyError : 'MODEL_BASE_URL'
Symptôme : avec --model openai, la trace d’erreur se termine par KeyError: 'MODEL_BASE_URL' (clé « MODEL_BASE_URL » introuvable).
Cause : la variable n’est pas définie dans cet interpréteur de commandes. Le projet lit l’environnement, pas .env.example. Un nouveau terminal démarre sans votre commande export précédente.
Solution : définissez MODEL_BASE_URL, MODEL_NAME et MODEL_API_KEY dans le même terminal, comme ci-dessus. Vérifiez l’URL avec echo $MODEL_BASE_URL (PowerShell : $env:MODEL_BASE_URL). N’affichez jamais la clé.
Réinitialisation. Si votre projet ne fonctionne plus, copiez l’instantané end-of-m04 comme dans La place de MCP, avec end-of-m04 plutôt que start. Il contient aussi les tests de ce module.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Nommez les trois parties de l'hôte de Larkfield, en plus de la ligne de commande. Laquelle doit changer quand le service de soutien passe à un autre fournisseur de modèles?
Afficher la réponse
app.py contient la boucle et les vérifications de l’hôte. Le client MCP est le Client de la trousse SDK, avec ses StdioServerParameters. L’adaptateur de modèle se trouve dans models.py, derrière decide(messages, tools) -> Decision. Un nouveau fournisseur change seulement models.py : une nouvelle classe d’adaptateur et son nom dans make_model(). Si le fournisseur veut les outils sous une autre forme, tool_spec change aussi. La boucle, les vérifications et le client restent les mêmes.
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 : Sam demande au modèle simulé « Quel est le délai de retour? ». Il n'y a aucun identifiant de billet. Quelle est la première décision du modèle simulé, puis sa décision après le retour du résultat?
Afficher la réponse
D’abord, search_knowledge avec la requête What is the return window? (quel est le délai de retour?). Il n’y a aucun identifiant de billet. La règle pour get_ticket ne s’applique donc pas, et aucune recherche n’a encore eu lieu. Après le résultat, toutes ses règles ont servi. Il donne donc une réponse finale : le titre, l’URI et l’extrait du meilleur résultat, From "Returns policy" (policy://larkfield/returns-policy): … (tiré de « Politique de retour »). La sortie de l’hôte affiche une ligne [model] wants search_knowledge (le modèle demande search_knowledge), puis [model] final answer (réponse finale du modèle).
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 host avec la question « Rédigez une réponse au billet T-30002 » et --user usr-omar. Omar a un accès en lecture seule chez Larkfield. Quelles lignes [host] et [model] apparaissent? Que contiennent les lignes du journal du serveur?
Afficher la réponse
Les mêmes lignes que pour Sam : discovered 2 tools (2 outils découverts), wants get_ticket (demande get_ticket) avec T-30002, et la décision de la liste d’autorisation. Ensuite, wants search_knowledge (demande search_knowledge) avec le sujet du billet, puis la réponse finale avec la ligne du billet et la politique de remboursement. Les membres en lecture seule peuvent lire les billets et faire des recherches. Les lignes du journal du serveur indiquent maintenant "user": "usr-omar" (utilisateur : usr-omar) et "role": "read_only" (rôle : lecture seule). L’hôte a transmis SUPPORT_USER=usr-omar au serveur avec env=. Le serveur a trouvé le rôle dans sa propre table d’adhésions.
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
- L’hôte est l’application d’IA. Il contient un client MCP par serveur et communique avec le modèle par une seule interface :
decide(messages, tools) -> Decision. - Un modèle simulé suit des règles fixes. Utilisez-le pour tester la connexion, les vérifications de l’hôte et les défaillances, gratuitement et de la même façon chaque fois.
- Gardez le code propre au fournisseur dans un seul adaptateur de modèle (
models.py). Un nouveau fournisseur change ce fichier, pas l’hôte ni le client. - L’hôte démarre le serveur avec
env=, car le client de la trousse SDK ne transmet que six variables par défaut. - Un vrai modèle est facultatif. Il fait ses propres choix : deux exécutions réelles de la même question ont donné des résultats différents.
Votre projet contient maintenant host/, et python -m host répond avec le modèle simulé. Ensuite, vous suivrez chaque message d’une requête et chaque décision que l’hôte prend en cours de route.
Leçon suivante : Découverte et exécution