Aller au contenu
English

Un catalogue de capacités

  • Leçon 4
  • 40 min
  • Module 2 : Demander des capacités, pas des modèles

Où nous en sommes

Dans le module 1, nous avons démarré le parc de Larkfield. Chaque application appelle un modèle par son nom, avec sa propre clé. Quand un modèle change, chaque application doit donc changer. Personne ne voit quelles applications dépendent de quel modèle. Dans cette leçon, les applications demandent plutôt une capacité. Nous précisons les promesses de chaque capacité, y compris les caractéristiques qui diffèrent entre modèles. Une location de voiture illustre l'idée.

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

Ce que vous saurez faire

Donnez à chaque appel de modèle un nom qui décrit son besoin : une capacité. Puis précisez les promesses de chaque capacité : caractéristiques, qualité minimale, latence, données qu’elle peut recevoir et prix. Des erreurs réellement enregistrées vous montreront pourquoi les caractéristiques doivent faire partie de cette promesse.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet ~/projects/ai-estate, identique à l’instantané end-of-m01 : python -m pytest -q affiche 91 passed, 1 deselected (91 tests réussis, 1 non sélectionné).
  • Le dépôt des laboratoires dans ~/projects/nextia-learning-labs, avec l’instantané end-of-m02.
  • Un terminal avec l’environnement virtuel activé. Le port 8320 doit être libre.

Testé sur macOS (Apple silicon) avec Python 3.12.13. Les commandes Windows (PowerShell) et Linux sont fournies, mais le cours ne les a pas exécutées. Chaque réponse de modèle dans cette leçon est rejouée : c’est un véritable enregistrement provenant d’un cours précédent.

Vous réservez une voiture de location pour un voyage en famille. Vous ne réservez pas « la Toyota grise avec la plaque KX 512 ». Vous réservez une catégorie : « une voiture intermédiaire, cinq places, automatique ». L’entreprise choisit la voiture que vous recevez. Quand la Toyota grise est au garage, vous recevez une Hyundai bleue, et votre voyage se déroule quand même.

Mais un détail peut gâcher le voyage. Votre famille tire une petite remorque. La plupart des voitures intermédiaires de cette succursale ont un attelage, mais pas toutes. Si votre réservation indique seulement « intermédiaire », vous pourriez recevoir une voiture sans attelage et le découvrir dans le stationnement. Vous l’écrivez donc dans la réservation : « intermédiaire, cinq places, automatique, avec un attelage ». L’entreprise doit maintenant vous fournir une voiture qui en a un, ou vous prévenir avant le voyage.

Une catégorie de réservation est une promesse assortie de conditions. Vous devez y inscrire les conditions qui comptent pour vous.

Aujourd’hui, chaque application de Larkfield nomme un déploiement de modèle dans son code : chat-small ou chat-strong. C’est comme réserver une voiture par sa plaque. Quand Kwame veut transférer le service de triage vers un modèle plus récent ou moins cher, Amira doit modifier le code. Quand il veut savoir quelles applications dépendent de chat-strong, il doit lire chaque application.

Le problème de la plaque n’est pas le pire. Les modèles ne sont pas interchangeables, et leurs différences ne concernent pas seulement la qualité. Essayez vous-même. Le cours Agents d’IA et orchestration des flux de travail a créé un agent de soutien qui appelle des outils. Il lit une commande avec get_order, puis propose une action. Exécutez le même agent, avec le même code, sur les deux déploiements, avec et sans un paramètre.

  1. Démarrez le parc :

    Fenêtre de terminal
    python -m estate init
    python -m estate up
  2. Dirigez le flux de travail du cours Agents d’IA et orchestration des flux de travail vers le simulateur de fournisseur. Ces trois variables sont ses propres paramètres :

    Fenêtre de terminal
    export RESOLVER_PROVIDER=openai_compatible
    export RESOLVER_BASE_URL=http://127.0.0.1:8320/azure/v1
    export RESOLVER_API_KEY=sim-az-service-team-0001
  3. Exécutez l’agent qui appelle des outils sur le billet de soutien T-90103 avec chat-small :

    Fenêtre de terminal
    RESOLVER_MODEL=chat-small python -m resolver run T-90103 --variant agent
    Run T-90103-agent-chat-small-1 | single agent with tool calling: the model chooses every step | chat-small
    Stopped: provider_error. No proposal: the ticket goes to a person.
    Last error: HTTP 400: Error code: 400 - {'error': {'message': "Function tools with reasoning_effort are not supported for chat-small in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'.", 'type': 'invalid_request_error', 'param': 'reasoning_effort', 'code': None}}
  4. Exécutez-le à nouveau avec le paramètre demandé par l’erreur : reasoning_effort réglé à none (aucun) :

    Fenêtre de terminal
    RESOLVER_MODEL=chat-small RESOLVER_REASONING_EFFORT=none python -m resolver run T-90103 --variant agent

    Les premières lignes (la sortie se poursuit avec la proposition et un brouillon de réponse) :

    Run T-90103-agent-chat-small-2 | single agent with tool calling: the model chooses every step | chat-small
    Outcome: resolve (rule W5) | 2 model call(s), 1 tool call(s) | 4618 tokens in, 220 out | US$0.00057
  5. Faites maintenant les deux mêmes exécutions avec chat-strong. Sur Windows, exécutez d’abord Remove-Item Env:RESOLVER_REASONING_EFFORT :

    Fenêtre de terminal
    RESOLVER_MODEL=chat-strong python -m resolver run T-90103 --variant agent
    RESOLVER_MODEL=chat-strong RESOLVER_REASONING_EFFORT=none python -m resolver run T-90103 --variant agent

    La dernière ligne de chaque exécution :

    Last error: HTTP 400: Error code: 400 - {'error': {'message': "Function tools with reasoning_effort are not supported for chat-strong in /v1/chat/completions. To use function tools, use /v1/responses or set reasoning_effort to 'none'.", 'type': 'invalid_request_error', 'param': 'reasoning_effort', 'code': None}}
    Last error: HTTP 400: Error code: 400 - {'error': {'message': "Unsupported value: 'reasoning_effort' does not support 'none' with this model. Supported values are: 'low', 'medium', 'high', and 'xhigh'.", 'type': 'invalid_request_error', 'param': 'reasoning_effort', 'code': 'unsupported_value'}}
  6. Supprimez les paramètres du flux de travail pour qu’ils ne modifient pas les commandes suivantes :

    Fenêtre de terminal
    unset RESOLVER_PROVIDER RESOLVER_BASE_URL RESOLVER_API_KEY
    python -m resolver reset

    reset (réinitialiser) affiche Fresh practice database: …/state/work/larkfield.sqlite (nouvelle base de données d’exercice). Les exécutions n’ont rien changé aux données d’exercice. La seule proposition attendait simplement une approbation que vous n’avez pas donnée.

Chaque erreur ici est réelle. Le simulateur refuse ces requêtes avec le texte fourni par les véritables déploiements Azure dans les cours précédents. Ce cours a enregistré la première erreur. Le cours Créer des applications fiables avec les API de LLM a enregistré les deux erreurs de chat-strong. La seule réponse qui a fonctionné est l’enregistrement du cours Agents d’IA et orchestration des flux de travail.

Une grille de quatre résultats pour l'agent qui appelle des outils du cours Agents d'IA et orchestration des flux de travail, sur le billet T-90103, avec le même code. Colonnes : chat-small et chat-strong. Lignes : sans paramètre, et reasoning_effort none. chat-small sans paramètre : HTTP 400, les outils de fonction avec reasoning_effort ne sont pas pris en charge pour chat-small, le billet est transféré à une personne. chat-small avec reasoning_effort none : HTTP 200, résolution selon la règle W5, 2 appels de modèle et 1 appel d'outil, un nouvel envoi et une étiquette de retour gratuite qui attendent une approbation. chat-strong sans paramètre : HTTP 400, les outils de fonction ne sont pas pris en charge pour chat-strong. chat-strong avec reasoning_effort none : HTTP 400, reasoning_effort ne prend pas en charge none avec ce modèle. Une seule des quatre exécutions fonctionne.
Le même agent sur deux déploiements. Une seule combinaison de modèle et de paramètre peut appeler des outils par cette API.
Description textuelle du diagramme

La grille comporte deux colonnes, chat-small et chat-strong, et deux lignes : sans paramètre, et reasoning_effort réglé à none. Trois des quatre cellules sont rouges. Sans le paramètre, chat-small répond HTTP 400 : son paramètre de raisonnement par défaut ne prend pas en charge les outils de fonction. Avec reasoning_effort none, chat-small répond. L’agent propose un nouvel envoi et une étiquette de retour gratuite pour T-90103, qui attendent une approbation. Sans le paramètre, chat-strong répond aussi HTTP 400. Avec reasoning_effort none, chat-strong répond HTTP 400 pour une autre raison : ce modèle n’accepte pas none. chat-strong ne peut donc jamais appeler d’outils de fonction par l’API Chat Completions.

Lisez attentivement les erreurs de chat-strong. La première dit « réglez reasoning_effort à ‘none’ ». Vous le faites, et la deuxième indique que ce modèle ne prend pas en charge none. Le conseil de la première erreur convient à chat-small, mais pas à chat-strong. L’agent fonctionne donc sur un déploiement et échoue sur l’autre, peu importe votre réglage.

Les appels échoués ne coûtent rien : python -m provsim bill affiche seulement les deux appels avec réponse de l’exécution réussie. Mais chaque échec a transféré un billet à une personne. Imaginez maintenant que Kwame transfère une application avec appels d’outils de chat-small vers chat-strong parce qu’il est « meilleur ». L’application ne reçoit pas de meilleures réponses. Elle ne reçoit aucune réponse.

La solution est la catégorie de réservation. Une application demande une capacité : un nom décrivant le besoin de l’appel, comme fast-small ou strong-reasoning. La plateforme choisit le modèle qui la fournit. Un catalogue de capacités répertorie ces capacités, chacune avec un contrat : la promesse que chaque modèle associé doit respecter. Le nom décrit le besoin, pas le modèle. Le modèle peut donc changer, et le nom reste.

Le contrat de Larkfield comporte cinq parties :

Partie Ce qu’elle promet La location de voiture
Caractéristiques ce qu’une requête peut utiliser : chat, structured_output (une réponse JSON qui respecte un schéma), tools, images, embeddings l’attelage
Qualité minimale un score minimal sur une évaluation nommée « évaluation de quatre étoiles ou plus »
Latence le délai dans lequel 95 % des réponses arrivent (p95) « prête à 9 h »
Classes de données les données les plus sensibles qu’une requête peut contenir « peut traverser la frontière »
Fourchette de prix le montant maximal que la plateforme peut payer par million de jetons « jusqu’à 60 par jour »

Une classe de données est une étiquette qui indique le degré de sensibilité des données. Larkfield en a quatre, dans config/data-classes.yaml : public (publiques), internal (internes), personal (personnelles : tout ce qui concerne un client) et payment (paiement : numéros de carte, jamais envoyés à un modèle). Mei en est responsable.

Pourquoi nommer l’évaluation, plutôt que d’écrire seulement « bonne qualité »? Parce que « bonne » ne désigne rien que quelqu’un puisse vérifier. « task_success d’au moins 0,95 sur les 70 tâches de résolution du cours Agents d’IA et orchestration des flux de travail » peut être mesuré à nouveau sur un nouveau modèle. La réponse est oui ou non. Vous utiliserez exactement cette mesure dans la dernière leçon de ce module.

Certains catalogues indiquent aussi la taille du contexte : combien de jetons une requête peut contenir. Le premier catalogue de Larkfield ne l’inclut pas. Ajoutez-la quand une application utilisatrice envoie de longues entrées, par exemple plusieurs documents dans une seule requête.

Le catalogue de Kwame compte quatre capacités. Voici la fiche de l’une d’elles, affichée par la commande que vous ajouterez dans un instant :

Capability: strong-reasoning
purpose: multi-step decisions that need the strongest model - resolution plans, judging answers
features: chat, structured_output
quality: task_success >= 0.95 on agents course, 70 resolution tasks
latency p95: 12.0 s
data classes: public, internal, personal
price band: up to US$2.5 in / US$12.0 out per 1M tokens
serves today: azure/chat-strong (gpt-6.1-sol-2026-09-29)
fallback: azure-canada/chat-strong

Lisez-la à partir du haut :

  • caractéristiques : chat et structured_output, mais pas tools. C’est le fait enregistré dans l’expérience : chat-strong ne peut pas appeler d’outils ici. Le contrat ne promet donc pas d’outils, et une application qui en a besoin doit demander une autre capacité.
  • qualité : l’évaluation du flux de travail de soutien, avec son minimum. chat-strong y a obtenu 70 sur 70.
  • latence et fourchette de prix : chat-strong coûte 2 $ US en entrée et 10 $ US en sortie par million de jetons, aux prix des enregistrements. La fourchette permet jusqu’à 2,50 $ US et 12 $ US. Un modèle légèrement plus cher conviendrait donc encore, mais pas un modèle cinq fois plus cher. Les prix changent : consultez la page des prix actuels du fournisseur.
  • classes de données : jusqu’à personal, parce que le flux de travail lit les billets des clients. Jamais payment.
  • modèle actuel et solution de repli : l’association, sujet de la prochaine leçon. La version du modèle entre parenthèses est le modèle exact derrière le nom du déploiement.
Une fiche du catalogue. En haut, support-workflow et release-judge demandent strong-reasoning : l'application nomme une capacité, jamais un modèle. La fiche porte le titre Capability : strong-reasoning, soit capacité : strong-reasoning. À gauche, le contrat, ce qu'il promet : caractéristiques chat et structured_output; qualité minimale task_success d'au moins 0,95 sur les 70 tâches du cours Agents d'IA et orchestration des flux de travail; latence p95 de 12 secondes; classes de données public, internal et personal; fourchette de prix jusqu'à 2,50 $ US en entrée et 12 $ US en sortie par million de jetons. À droite, l'association, ce qui fournit la capacité : actuellement azure chat-strong, version du modèle gpt-6.1-sol-2026-09-29; en dessous, une solution de repli, azure-canada chat-strong, une deuxième région simulée, utilisée si la première échoue avec 429, 5xx ou un dépassement du délai. Une flèche du contrat vers l'association indique respecté par. En bas : python -m estate catalog check, chaque association doit respecter le contrat.
La fiche de strong-reasoning dans le catalogue : le contrat est la promesse; l'association est ce qui la respecte aujourd'hui.
Description textuelle du diagramme

En haut, deux applications, le flux de travail de soutien et le juge des mises en production, demandent strong-reasoning. Elles nomment la capacité, jamais un modèle. La fiche comporte deux moitiés. La moitié gauche est le contrat. Elle énumère les caractéristiques de conversation et de sortie structurée. Elle fixe une qualité minimale de réussite des tâches de 0,95 sur les 70 tâches du cours Agents d’IA et orchestration des flux de travail. Elle indique aussi une latence p95 de 12 secondes et les classes de données publiques, internes et personnelles. Sa fourchette de prix va jusqu’à 2,50 $ US en entrée et 12 $ US en sortie par million de jetons. La moitié droite est l’association : aujourd’hui azure chat-strong, version du modèle gpt-6.1-sol-2026-09-29. Sa solution de repli est le même déploiement dans une deuxième région simulée. La commande python -m estate catalog check vérifie que chaque association respecte le contrat.

Kwame nomme les capacités selon les besoins des applications, pas selon les noms des produits du fournisseur :

Capacité Pour Caractéristiques Qualité minimale p95 Fourchette de prix (entrée / sortie)
fast-small triage, routage, courts brouillons chat, structured_output, tools decisions ≥ 0,85, données de triage du cours Évaluer et tester les systèmes d’IA 6 s 0,50 $ US / 2,00 $ US
strong-reasoning plans de résolution, jugement des réponses chat, structured_output task_success ≥ 0,95, 70 tâches du cours Agents d’IA et orchestration des flux de travail 12 s 2,50 $ US / 12 $ US
embed vecteurs pour trouver des billets semblables embeddings aucune pour l’instant 1 s 0,05 $ US / –
vision photos jointes par les clients chat, images aucune pour l’instant 10 s 2,50 $ US / 12 $ US

Chaque ligne a une raison d’être. fast-small promet tools, parce que chat-small peut appeler des outils avec le bon paramètre. La latence enregistrée du modèle pour les requêtes de triage avait un p95 de 5,16 secondes (rejoué), sous ses 6 secondes. vision figure au catalogue, mais aucun modèle ne la fournit encore : rien dans les enregistrements ne lit les images. L’inscrire signifie « nous le prévoyons », plutôt que de laisser une équipe trouver son propre fournisseur. embed et vision n’ont pas encore de qualité minimale. C’est une lacune, et le catalogue la montre ouvertement.

Sam demande : « Pourquoi ne pas les appeler chat-small et chat-strong, comme les déploiements? » Kwame répond : « Parce que le nom vous indique alors le modèle. Quand un autre modèle fournira chat-small l’an prochain, le nom sera trompeur. » Tomás a l’inquiétude inverse : « Donc, un nom de capacité veut dire que le comportement ne change jamais? » Non. Le contrat maintient les caractéristiques, les règles sur les données et le prix. Les réponses d’un nouveau modèle seront quand même différentes. C’est pourquoi le contrat nomme une évaluation. Et c’est pourquoi changer de modèle est une mise en production, comme le montre la dernière leçon de ce module.

  1. Copiez les fichiers de cette leçon depuis l’instantané end-of-m02 : le dossier config, le module du catalogue et sa commande. Dans ~/projects/ai-estate :

    Fenêtre de terminal
    S=../nextia-learning-labs/C32/snapshots/end-of-m02
    cp -R $S/config .
    cp $S/estate/catalog.py estate/
    cp $S/estate/cli/catalog.py estate/cli/
  2. Examinez les quatre fichiers dans config/. catalog.yaml contient les contrats. models.yaml indique ce que chaque déploiement peut faire. providers.yaml et data-classes.yaml serviront dans la prochaine leçon. Dans models.yaml, trouvez la ligne features: [chat, structured_output] de chat-strong, avec le commentaire no function tools in Chat Completions (real HTTP 400s) (aucun outil de fonction dans Chat Completions, véritables erreurs HTTP 400).

  3. Affichez le catalogue :

    Fenêtre de terminal
    python -m estate catalog list
    fast-small azure/chat-small short structured answers at low cost - triage, routing, short drafts
    strong-reasoning azure/chat-strong multi-step decisions that need the strongest model - resolution plans, judging answers
    embed azure/embed-small vectors for finding similar tickets
    vision nothing yet (planned) read photos that customers attach
  4. Affichez une fiche : python -m estate catalog show strong-reasoning. La commande affiche la fiche de l’exemple détaillé ci-dessus.

  5. Affichez la fiche de vision : python -m estate catalog show vision. La dernière ligne indique serves today: nothing (planned) (modèle actuel : aucun, prévu), et la ligne de qualité indique none >= None on none yet (aucune qualité minimale ni évaluation pour l’instant). Cette ligne représente la lacune.

  6. Vérifiez que chaque association respecte son contrat :

    Fenêtre de terminal
    python -m estate catalog check
    The catalog is consistent: every mapping keeps its contract.
  7. Exécutez les tests. La dernière ligne indique toujours 91 passed, 1 deselected : les tests de cette leçon viennent avec la prochaine leçon.

catalog check compare chaque contrat à models.yaml. Il détecte trois types de problèmes. Une caractéristique du contrat que le modèle n’a pas. Un prix au-dessus de la fourchette. Une classe de données que le contrat du fournisseur ne permet pas. La vérification affiche chaque problème et se termine avec le code 1. Une compilation ou une révision peut ainsi s’arrêter.

À vous de jouer : promettre des outils avec strong-reasoning

Section intitulée « À vous de jouer : promettre des outils avec strong-reasoning »

Amira voudrait que l’agent du flux de soutien qui appelle des outils utilise strong-reasoning. Faites d’abord une prédiction : que se passe-t-il si Kwame ajoute tools (outils) au contrat de strong-reasoning? Quelles lignes catalog check affichera-t-il?

Travaillez sur une copie pour ne pas modifier le vrai catalogue :

  1. Copiez le catalogue : cp config/catalog.yaml my-catalog.yaml (Windows : Copy-Item config\catalog.yaml my-catalog.yaml).

  2. Dans my-catalog.yaml, sous strong-reasoning: et contract:, remplacez features: [chat, structured_output] par features: [chat, structured_output, tools]. Enregistrez le fichier.

  3. Vérifiez la copie :

    Fenêtre de terminal
    python -m estate catalog check --file my-catalog.yaml
  4. Comparez la sortie avec votre prédiction.

Vérifiez votre prédiction
strong-reasoning -> azure/chat-strong: the contract promises tools, the model does not have it
strong-reasoning -> azure-canada/chat-strong: the contract promises tools, the model does not have it

Deux lignes, une pour chaque destination possible d’un appel : la principale et celle de secours. La vérification a trouvé en une seconde ce que l’agent a découvert avec une erreur 400 dans l’expérience. La bonne réponse à Amira n’est pas de modifier le contrat. Son agent qui appelle des outils demande fast-small, dont le contrat promet des outils. Sinon, l’équipe garde son agent à sortie structurée sur strong-reasoning, car il n’a pas besoin d’outils de fonction. Supprimez la copie quand vous avez terminé : rm my-catalog.yaml (Windows : Remove-Item my-catalog.yaml).

Erreur courante

Une faute de frappe dans un nom de déploiement

Symptôme : après une modification du catalogue, python -m estate catalog check affiche cette ligne et se termine avec le code 1 :

fast-small -> azure/chat-smal: no deployment chat-smal in config/models.yaml

Cause : l’association de fast-small nomme un déploiement, chat-smal, qui ne figure pas dans models.yaml. Sans la vérification, l’erreur apparaîtrait seulement à l’échec du premier appel, pour toutes les applications qui demandent fast-small en même temps.

Diagnostic : la ligne nomme la capacité, le fournisseur et le déploiement. Cherchez ce nom dans le catalogue, par exemple avec grep -n chat-smal config/catalog.yaml (Windows : Select-String chat-smal config\catalog.yaml).

Correction : corrigez le nom ou ajoutez le déploiement à models.yaml avec les caractéristiques observées lors de ses appels réels. Relancez ensuite catalog check jusqu’à ce qu’il affiche The catalog is consistent (le catalogue est cohérent). Exécutez la vérification avant de publier chaque modification; le module 3 l’intègre à l’étape de publication de la configuration.

Utilisez-le quand plusieurs applications ou agents partagent des modèles et des fournisseurs, comme chez Larkfield : six systèmes d’IA, sous la responsabilité de quatre équipes. Le catalogue devient alors l’endroit unique qui indique les usages permis pour chaque modèle.

Ne l’utilisez pas pour une seule application qui appelle un seul modèle. Un catalogue d’une seule capacité donne un nom à un nom. Les recommandations de Microsoft sur une passerelle devant plusieurs déploiements disent la même chose de la passerelle elle-même. Elle aide dans certaines situations, pas dans toutes.

Gardez-le petit. Il est facile de raisonner sur quatre capacités. Une capacité par application transforme à nouveau le catalogue en liste de modèles portant de nouveaux noms. Ajoutez une capacité seulement quand un consommateur réel a besoin d’une promesse différente.

Ce qu’il coûte. Quelqu’un doit en être responsable : Kwame. models.yaml doit rester exact. Les caractéristiques de chaque nouveau modèle doivent donc provenir d’appels réels, comme les erreurs 400 ici. Et un contrat vaut seulement ce que vaut son évaluation. Une capacité sans seuil minimal de qualité, comme embed aujourd’hui, n’a aucune preuve quand son modèle change.

Vérifiez votre compréhension

L'agent d'Amira qui appelle des outils fonctionne sur chat-small avec reasoning_effort none. Kwame veut acheminer tous les appels de clavardage vers chat-strong pour améliorer la qualité. Qu'arrive-t-il à son agent, et comment le catalogue devrait-il l'empêcher?

Afficher la réponse

Son agent s’arrête au premier appel d’outil avec une erreur HTTP 400. chat-strong ne peut pas appeler d’outils de fonction par l’API Chat Completions. Sans paramètre, il refuse les outils. Avec reasoning_effort none, il refuse le paramètre. Chaque billet de soutien est alors confié à une personne. Le catalogue empêche cela, car l’agent demande fast-small, dont le contrat inclut les outils. catalog check refuse toute association de fast-small à un modèle sans outils. La modification échoue donc avant d’atteindre une application.

Vérifiez votre compréhension

Pourquoi le contrat de strong-reasoning précise-t-il les 70 tâches de résolution du cours Agents d'IA et orchestration des flux de travail et un minimum de 0,95, plutôt que de dire « le modèle le plus puissant »?

Afficher la réponse

On ne peut pas vérifier « le modèle le plus puissant », et cette désignation change quand de nouveaux modèles apparaissent. Une évaluation nommée avec un minimum peut être exécutée sur tout modèle candidat. Le résultat est oui ou non : un taux de réussite d’au moins 0,95 sur les mêmes 70 tâches, ou non. Le contrat précise aussi quelles preuves comptent : celles du flux de soutien. Quand le modèle derrière la capacité change, la plateforme exécute de nouveau cette évaluation.

Vérifiez votre compréhension

La capacité vision figure dans le catalogue, mais aucun modèle ne la fournit. Est-ce utile ou déroutant? Donnez une raison pour chaque point de vue.

Afficher la réponse

Utile : elle indique aux équipes que la plateforme prévoit d’offrir la lecture d’images, avec ses catégories de données et sa fourchette de prix. Une équipe n’a donc pas à trouver son propre fournisseur pour les photos. Déroutant : une application qui demande vision aujourd’hui n’obtient aucun modèle, et la fiche n’a pas encore de seuil minimal de qualité. La fiche indique ouvertement « nothing (planned) » (aucun, prévu) et « none yet » (aucun pour l’instant). Le manque est donc visible plutôt que caché.

Récapitulatif

  • Une application demande une capacité (fast-small, strong-reasoning, embed, vision), pas un modèle. Le catalogue de capacités les répertorie.
  • Chaque capacité a un contrat : caractéristiques, seuil minimal de qualité sur une évaluation nommée, latence p95, catégories de données permises et fourchette de prix.
  • Les caractéristiques font partie du contrat : le même agent a reçu une erreur HTTP 400 sur chat-small sans reasoning_effort: none, et sur chat-strong avec ou sans ce paramètre. Seul chat-small avec le paramètre a appelé des outils.
  • python -m estate catalog list | show | check répertorie le catalogue, affiche une fiche et refuse une association qui enfreint son contrat.
  • embed et vision n’ont pas encore de seuil minimal de qualité : le catalogue montre ce manque.

Votre projet contient maintenant config/ et la commande estate catalog; les tests indiquent toujours 91 passed (91 tests réussis). Chaque capacité a maintenant une promesse. Mais une promesse ne précise pas quel modèle la respecte, où, ni ce qui arrive quand ce fournisseur est en panne. Ensuite, vous associez chaque capacité à un modèle et à un fournisseur, avec une solution de secours et des règles de données.

Leçon suivante : Associer les capacités aux modèles