Appels de modèle et jetons
- Leçon 7
- 35 min
- Module 3 : Instrumenter le flux de travail
Où nous en sommes
Au module 2, nous avons construit les éléments : spans, noms GenAI figés et Collector qui masque et achemine les données. Mais notre trace d'un billet ne contient encore qu'un span de 0,00 seconde, sans le temps du modèle. Dans cette leçon, nous donnons à chaque appel de modèle son propre span. Il contient le modèle, les jetons, la raison d'arrêt, la latence et la version de requête, mais jamais le texte. Nous commençons par une facture de téléphone.
Leçon 7 sur 28 · Observabilité des agents d'IA : traces, coûts et pistes d'auditAppels de modèle et jetons
1. Pourquoi les agents ont besoin de leur propre observabilité
2. OpenTelemetry pour les agents
3. Instrumenter le flux de travail
4. Trouver les défaillances des agents dans Grafana
5. Le coût
6. Pistes d'audit
7. Alertes, niveaux de service et qualité
8. Outils : Langfuse, les autres et l'inspecteur d'exécutions
Ce que vous saurez faire
Donnez à chaque appel de modèle du flux de travail son propre span. Enregistrez le modèle qui répond, les jetons d’entrée et de sortie, la raison d’arrêt, la durée et la version de requête. Une trace explique alors où passent le temps et les jetons d’une exécution. N’enregistrez aucun texte.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Ce que sont un span, une trace et les attributs d’un span, selon Spans, traces et contexte.
- Les noms GenAI figés, comme
chat {model}etgen_ai.usage.input_tokens, selon Les conventions GenAI pour les exécutions d’agents. - Ce qu’est un jeton (token). Le flux de travail rejoue les appels de modèle enregistrés du cours Agents d’IA et orchestration des flux de travail.
Ce qu’il vous faut sur votre ordinateur
- Le projet à la fin du module 2, dans
observable-workflow. Il correspond à l’instantanéend-of-m02, avec 81 tests qui réussissent. - Un terminal dans
observable-workflow, avec l’environnement virtuel actif. Le dépôt des laboratoires,nextia-learning-labs, se trouve dans le même dossier parent.
Testé sur macOS (Apple silicon) avec Python 3.12.13. Les commandes Windows et Linux sont écrites, mais n’ont pas été exécutées.
Une facture de téléphone
Section intitulée « Une facture de téléphone »Une facture de téléphone indique chaque appel : le numéro, l’heure, la durée et le coût. Elle ne contient jamais ce que vous avez dit. Pourtant, elle répond à des questions utiles. Pourquoi ce mois a-t-il coûté cher? Quel appel a duré longtemps? Un nouveau forfait a-t-il changé quelque chose?
La facture peut y répondre parce qu’elle enregistre les mêmes quelques faits pour chaque appel, sous la même forme. Une ligne par appel, sans la conversation. Voilà l’idée de cette leçon.
Le problème : une exécution qui n’a pris aucun temps
Section intitulée « Le problème : une exécution qui n’a pris aucun temps »À la fin du module 2, exécutez un billet et lisez sa trace :
python -m resolver run T-80008python -m obs trace T-80008Le flux de travail affiche que l’exécution a fait deux appels de modèle et utilisé 4 580 jetons :
Run T-80008-agent-chat-small-1 | single agent with tool calling: the model chooses every step | chat-smallOutcome: reply_only (rule W1) | 2 model call(s), 1 tool call(s) | 4580 tokens in, 117 out | US$0.00052Reply draft: Your garden shed order LK-581106 shipped on Monday, October 5. Its expected delivery date is Tuesday, October 13. It is currently in transit, and there is no delivery date showing yet.Reply sent. Ticket: resolved.Mais la trace dit autre chose :
Run T-80008-agent-chat-small-1 | ticket T-80008 | chat-small (agent) | release 2.0.0 | language en0 model call(s), 0 read(s), 0 write call(s), 0 tokens in, 0 out, US$0.00000
Trace 1 88ec5e0f1603e609be2414b7caee63ee … 0.0 s 0.0 s | | 0.00 s invoke_agent support-resolver reply_only rule W1
Outcome: resolvedLa trace contient un span, qui dure 0,00 seconde. Elle connaît le résultat, mais pas les deux appels de modèle, leurs jetons ou leur durée. Si Omar demande « pourquoi la facture a-t-elle doublé cette semaine? », cette trace ne peut pas l’aider. Les nombres existent dans le programme, mais rien ne les enregistre par appel.
Pourquoi 0,00 seconde? Le flux de travail rejoue des réponses de modèle enregistrées, et une répétition répond en quelques microsecondes. Depuis le module 2, les spans utilisent l’horloge d’exécution. L’horloge de chaque exécution avance selon la latence enregistrée de chaque appel de modèle. Mais seul un span de modèle la fait avancer, et il n’y en a pas encore.
L’idée : un span chat par appel de modèle
Section intitulée « L’idée : un span chat par appel de modèle »Donnez à chaque appel de modèle son propre span, enfant du span d’exécution. Les conventions GenAI le nomment chat {model}, par exemple chat chat-small, avec le nom d’opération chat. Son type est CLIENT, car le flux de travail appelle un autre service. Chaque span chat enregistre les mêmes faits, comme une ligne de la facture de téléphone :
Description textuelle du diagramme
Un appel de modèle comprend une requête : le modèle, une limite de jetons, la requête et le billet. Il comprend aussi une réponse : du texte ou un appel d’outil, des jetons et une raison d’arrêt. Le span conserve le modèle demandé, le modèle qui répond, les jetons d’entrée et de sortie et la raison d’arrêt. Il conserve aussi la latence comme durée, le nom et la version de la requête, et le numéro d’étape. Il garde également les noms des étapes demandées par le modèle. Il exclut tout le texte : la requête, le billet, la réponse et les valeurs des arguments d’outil.
Cinq attributs demandent une courte explication :
- Les jetons d’entrée et de sortie (
gen_ai.usage.input_tokens,gen_ai.usage.output_tokens). Le fournisseur les compte et les renvoie avec la réponse. Les prix sont par jeton; le module 5 s’en sert donc pour calculer le coût. - La raison d’arrêt (
gen_ai.response.finish_reasons) : pourquoi le modèle s’est arrêté.stop(arrêt) indique une fin normale, ettool_calls(appels d’outils) indique une demande d’outil.length(longueur) indique que la limite de jetons est atteinte, etcontent_filter(filtre de contenu), un refus du fournisseur. Les conventions en font une liste, car une requête peut demander plusieurs réponses. - Le modèle qui répond (
gen_ai.response.model). Le flux de travail demandechat-small, un nom de déploiement. Le fournisseur répond avec le modèle derrière ce nom,gpt-6-luna-2026-09-22. Quand le déploiement passe à un nouveau modèle, seul cet attribut le montre. - La version de requête (
gen_ai.prompt.version) : les 8 premiers caractères d’une empreinte du fichier de requête et de la politique. C’est le mécanisme décrit dans Les conventions GenAI pour les exécutions d’agents. Une trace peut ainsi indiquer quelle requête un appel utilise, sans son texte. - La latence correspond à la durée du span. Lors d’une répétition, le span dure aussi longtemps que l’appel enregistré :
larkfield.recorded_latency_sconserve la valeur enregistrée.
Le projet enregistre aussi trois métriques par appel : sa durée (gen_ai.client.inference.duration, un histogramme) et deux compteurs de jetons d’entrée et de sortie. Leurs étiquettes sont l’opération, le fournisseur et les deux noms de modèle, jamais un billet. Le module 5 explique pourquoi les étiquettes doivent rester peu nombreuses.
Exemple détaillé : deux appels, une exécution
Section intitulée « Exemple détaillé : deux appels, une exécution »Voici ce qu’indiquent les deux spans chat de T-80008, dans l’exécution de l’équipe du cours :
| Appel | Raison d’arrêt | Jetons d’entrée | Jetons de sortie | Latence enregistrée |
|---|---|---|---|---|
| 1 | tool_calls : le modèle demande get_order(order_id) |
2169 | 21 | 0.96 s |
| 2 | tool_calls : le modèle appelle finish avec sa proposition |
2411 | 96 | 1.18 s |
| Exécution | 4 580 | 117 | 2,14 s |
Les sommes correspondent aux nombres affichés par le flux de travail : 4 580 jetons d’entrée et 117 de sortie. Le span d’exécution dure maintenant 0,96 + 1,18 = 2,14 secondes. L’horloge d’exécution a avancé selon la latence enregistrée de chaque appel.
Regardez les jetons d’entrée. Le deuxième appel envoie 242 jetons de plus que le premier. Un modèle n’a aucune mémoire entre les appels; le flux de travail renvoie donc toute la conversation. Cela comprend la requête, le billet, la première réponse et la commande renvoyée par get_order. Les jetons d’entrée augmentent donc à chaque étape et représentent la majeure partie du total :
Description textuelle du graphique
Quatre barres. Appel 1 : 2169 jetons d’entrée et 21 jetons de sortie. Appel 2 : 2411 jetons d’entrée et 96 jetons de sortie. Les barres d’entrée sont plus de vingt fois plus hautes que les barres de sortie. La deuxième barre d’entrée est plus haute que la première, car le deuxième appel renvoie toute la conversation.
Sur les 4 697 jetons de cette exécution, 97 % sont des jetons d’entrée. Une exécution avec plus d’étapes envoie la conversation plus souvent. Elle coûte donc plus cher que son nombre de réponses le laisse croire. Seul un span par appel le montre.
Ajouter les spans de modèle à votre projet
Section intitulée « Ajouter les spans de modèle à votre projet »La modification touche deux fichiers. resolver/observe.py reçoit une fonction d’enveloppe, observed(), autour de la fonction complete() du fournisseur. resolver/runner.py enveloppe le fournisseur une seule fois, pour chaque conception du flux de travail. La copie de observe.py contient aussi les spans d’outil et d’écriture des prochaines leçons, mais rien ne les appelle encore.
-
Copiez les deux fichiers depuis l’instantané
end-of-m03:Fenêtre de terminal S=../nextia-learning-labs/C31/snapshots/end-of-m03cp $S/resolver/observe.py $S/resolver/runner.py resolver/Fenêtre de terminal $S = "..\nextia-learning-labs\C31\snapshots\end-of-m03"Copy-Item $S\resolver\observe.py, $S\resolver\runner.py resolver\Fenêtre de terminal S=../nextia-learning-labs/C31/snapshots/end-of-m03cp $S/resolver/observe.py $S/resolver/runner.py resolver/ -
Ouvrez
resolver/runner.py. L’exécution passe maintenantobserve.observed(complete)au lieu decomplete. Une ligne du flux de travail a changé : chaque conception reçoit les mêmes spans de modèle. -
Ouvrez
resolver/observe.pyet trouvezdef observed(complete). Lisez les deux groupes d’attributs. Le premier groupe est défini avant l’appel : le modèle demandé, la requête et l’étape. Le deuxième groupe est défini après la réponse : le modèle qui répond, les jetons et la raison d’arrêt. -
Exécutez de nouveau le billet et lisez sa trace :
Fenêtre de terminal python -m resolver run T-80008python -m obs trace T-80008Run T-80008-agent-chat-small-2 | ticket T-80008 | chat-small (agent) | release 2.0.0 | language en2 model call(s), 0 read(s), 0 write call(s), 4580 tokens in, 117 out, US$0.00000Trace 1 488d2ec9ffa2868b9e43ebd9ea937fdc … 2.1 s0.0 s |========================| 2.14 s invoke_agent support-resolver reply_only rule W10.0 s |=========== | 0.96 s chat chat-small 2169 in / 21 out - tool_calls1.0 s | ==============| 1.18 s chat chat-small 2411 in / 96 out - tool_callsVotre identifiant de trace et votre heure diffèrent. Le numéro d’exécution se termine par
-2si vous avez déjà exécuté ce billet une fois. La colonne de coût affiche-: les spans n’ont pas encore de coût; le module 5 l’ajoute.
Les deux traces du même billet, avant et après :
Description textuelle du diagramme
Avant, la trace contient un span sans durée. Après, le span d’exécution dure 2,14 secondes et possède deux enfants, les deux appels à chat-small. Le premier dure 0,96 seconde et se termine par tool_calls. Le deuxième commence à la fin du premier et dure 1,18 seconde. Le temps d’exécution est maintenant la somme de ses appels de modèle. L’appel d’outil entre les deux n’est pas encore dans la trace.
La lecture, get_order, a eu lieu entre les deux appels, mais elle n’a pas encore de span. La prochaine leçon l’ajoute.
Lire les attributs d’un span
Section intitulée « Lire les attributs d’un span »obs trace affiche un résumé. Pour voir chaque attribut, lisez le fichier de télémétrie lui-même. Le fichier work/telemetry/traces.jsonl contient du JSON OTLP : une requête d’exportation par ligne, avec les spans à l’intérieur.
-
Créez un fichier
show_spans.pydans le dossier du projet, avec ce contenu :"""Print the spans in work/telemetry/traces.jsonl whose name contains a word, with every attribute."""import jsonimport sysfrom pathlib import Pathword = sys.argv[1] if len(sys.argv) > 1 else ""for line in Path("work/telemetry/traces.jsonl").read_text().splitlines():for resource in json.loads(line)["resourceSpans"]:for scope in resource["scopeSpans"]:for span in scope["spans"]:if word not in span["name"]:continueparent = span.get("parentSpanId", "")[:8] or "none"print(f'{span["name"]} trace {span["traceId"][:8]} span {span["spanId"][:8]} parent {parent}')for a in span.get("attributes", []):value = next(iter(a["value"].values()))if isinstance(value, dict): # a list, such as the finish reasonsvalue = [next(iter(v.values())) for v in value.get("values", [])]print(f' {a["key"]} = {value}')for link in span.get("links", []):print(f' link to trace {link["traceId"][:8]}, span {link["spanId"][:8]}')Cet utilitaire vous appartient : il n’est pas dans l’instantané, et les prochaines leçons l’utilisent.
-
Affichez les spans de modèle :
python show_spans.py chat. Le premier indique :chat chat-small trace 488d2ec9 span 0ec2f8ab parent 34b1f358gen_ai.operation.name = chatgen_ai.provider.name = azure.ai.openaigen_ai.request.model = chat-smallgen_ai.request.max_tokens = 2000larkfield.step = 1gen_ai.prompt.name = agentgen_ai.prompt.version = d6c784d1gen_ai.output.type = textgen_ai.conversation.id = T-80008-agent-chat-small-2gen_ai.response.model = gpt-6-luna-2026-09-22gen_ai.usage.input_tokens = 2169gen_ai.usage.output_tokens = 21gen_ai.response.finish_reasons = ['tool_calls']larkfield.replay = exactlarkfield.recorded_latency_s = 0.956larkfield.model.requested = ['get_order(order_id)'] -
Trouvez les trois types de noms. Les noms
gen_ai.*viennent des conventions figées. Les nomslarkfield.*sont les nôtres : notre préfixe l’indique.gen_ai.conversation.idest l’identifiant d’exécution. Un outil qui connaît les conventions peut donc regrouper les appels d’une exécution. -
Trouvez
larkfield.replay = exact. Il indique que la réponse enregistrée a été rejouée pour une requête identique, octet par octet. Un appel en production indiqueraitlive(en direct).
larkfield.model.requested conserve ce que le modèle demande ensuite, sous forme de nom d’outil et de noms d’arguments : get_order(order_id). Il ne conserve jamais le numéro de commande écrit par le modèle. Le module 4 s’en sert pour trouver les boucles : un modèle qui redemande sans cesse la même étape.
Les tests qui figeaient l’ancienne structure
Section intitulée « Les tests qui figeaient l’ancienne structure »-
Lancez les tests :
python -m pytest -q.FAILED tests/test_telemetry.py::test_no_text_leaves_the_application_by_default1 failed, 80 passed, 1 deselected -
Lisez la cause au-dessus du résumé :
> assert counted["spans"] == 1 and problems == []E assert (3 == 1)Le test exécute un billet et vérifie qu’aucun texte n’a quitté l’application. Il attendait aussi un span par exécution, la structure du module 2. Maintenant, une exécution contient trois spans : l’exécution et deux appels de modèle.
-
Dans
tests/test_telemetry.py, remplacezcounted["spans"] == 1parcounted["spans"] > 1. Gardezproblems == []: cette moitié du test est la plus importante. -
Relancez les tests. La dernière ligne indique
81 passed, 1 deselected(81 tests réussis, 1 non sélectionné).
Un test qui vérifie la structure exacte de la télémétrie échoue chaque fois que vous ajoutez un span. La prochaine leçon remplace ce fichier par la version de l’instantané, qui vérifie les spans importants.
Vérifier qu’aucun texte n’est sorti
Section intitulée « Vérifier qu’aucun texte n’est sorti »Les spans de modèle sont l’endroit où du texte pourrait fuir : la requête transporte le texte de requête et le billet. Exécutez la vérification du Le Collector sur votre propre télémétrie :
python -m obs check-redaction work/telemetryChecked 4 span(s), 0 event(s), 4 metric line(s) in work/telemetry.No text attribute, no e-mail address and no card number found.Vos comptes dépendent du nombre d’exécutions effectuées. La vérification réussit parce que observed() copie des comptes, des noms et des identifiants dans le span, sans texte.
À vous de jouer : l’autre conception
Section intitulée « À vous de jouer : l’autre conception »La conception structurée du cours sur les agents, agent_structured, demande au modèle une étape JSON par appel, sans appel d’outil. Elle utilise chat-strong. Avant de l’exécuter, notez vos prédictions pour ses deux spans de modèle :
- Quelle raison d’arrêt ont-ils,
stopoutool_calls? - La version de requête est-elle la même que celle de
agent,d6c784d1? - Les jetons d’entrée sont-ils proches de ceux de chat-small?
Exécutez-la ensuite et vérifiez vos réponses avec obs trace T-80008 et python show_spans.py chat :
python -m resolver run T-80008 --variant agent_structured --model chat-strongLe résultat de l’équipe du cours
0.0 s |========================| 5.48 s invoke_agent support-resolver reply_only rule W1 0.0 s |========== | 2.28 s chat chat-strong 2166 in / 48 out - stop 2.3 s | ===============| 3.20 s chat chat-strong 2436 in / 125 out - stopLes deux appels se terminent par stop : le modèle écrit une étape JSON sous forme de texte brut. Pour le fournisseur, chaque réponse correspond donc à une fin normale. Le flux de travail lit l’étape dans le texte. La requête vient d’un autre fichier; sa version est donc une autre empreinte, 39329efa. Les jetons d’entrée sont presque identiques, 2 166 et 2 436 : les deux requêtes ont environ la même taille. Mais les appels prennent 2,4 et 2,7 fois plus de temps. Le module 5 montre aussi que chaque jeton de chat-strong coûte 20 fois plus cher.
Une raison d’arrêt signifie donc différentes choses selon la conception. tool_calls indique une demande d’outil seulement dans la conception qui utilise les appels d’outils. C’est pourquoi le span enregistre aussi la conception et le nom de la requête.
Erreur courante
Le texte de requête se trouve dans les spans
Symptôme : Tomás veut déboguer une réponse étrange. Il exécute un billet avec OBS_CAPTURE_CONTENT=on et oublie de désactiver cette option. La vérification du masquage échoue alors :
OBS_CAPTURE_CONTENT=on python -m resolver run T-80008python -m obs check-redaction work/telemetryChecked 7 span(s), 0 event(s), 6 metric line(s) in work/telemetry.2 problem(s): text that must not leave the application: span chat chat-small: attribute gen_ai.input.messages (text) span chat chat-small: attribute gen_ai.input.messages (text)Dans PowerShell, définissez d’abord la variable : $env:OBS_CAPTURE_CONTENT = "on", puis exécutez le billet.
Cause : quand la capture de contenu est activée, observed() ajoute gen_ai.input.messages à chaque span de modèle. Cet attribut contient toute la conversation, y compris les mots du client. Les conventions permettent cette option pour le débogage, sur activation explicite. Le cours en a mesuré le coût : la télémétrie d’une exécution passe de 9,3 Ko à 26,7 Ko, soit environ 2,9 fois plus. Dans la semaine rejouée avec la capture activée, 718 spans de modèle contenaient du texte de requête.
Diagnostic : python show_spans.py chat affiche une longue valeur pour gen_ai.input.messages.
Correction : désactivez la variable (unset OBS_CAPTURE_CONTENT; dans PowerShell, Remove-Item Env:OBS_CAPTURE_CONTENT). Supprimez work/telemetry et relancez l’exécution. Dans l’exécution du Collector du cours, le processeur de masquage a retiré le texte des 718 spans avant toute exportation. Résultat : 0 problème après le Collector. Le Collector est la deuxième ligne de défense, pas la première. Gardez la capture de contenu désactivée dans l’application.
Quand enregistrer quoi, et à quel coût
Section intitulée « Quand enregistrer quoi, et à quel coût »Enregistrez le span de modèle à chaque appel, dans chaque environnement. Cela coûte peu : selon les mesures du cours, toute l’instrumentation ajoute 1,9 milliseconde par exécution, contre des secondes pour le modèle. Elle répond aux questions les plus fréquentes : quelle étape était lente, quel modèle a répondu et où les jetons sont passés.
Limitez les attributs aux comptes, aux noms, aux identifiants et aux codes. Voici la règle de Kwame pour un nouvel attribut : « Deux exécutions pourraient-elles avoir des valeurs différentes? Est-ce que je regrouperais un jour les données selon cet attribut? » La conception, l’étape et la version de requête conviennent. L’adresse courriel d’un client ne convient pas, et c’est une donnée personnelle.
N’enregistrez pas le texte par défaut. Un attribut textuel augmente la taille de chaque trace. Il place des données personnelles dans un stockage accessible à d’autres lecteurs, pendant toute la durée de conservation. Pour déboguer une réponse avec son texte, utilisez les enregistrements du flux de travail lui-même. C’est ce que le cours sur les agents a fait avec ses enregistrements.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Une exécution de T-80008 a fait deux appels de modèle : 2 169 jetons en entrée et 21 en sortie, puis 2 411 et 96. Pourquoi le deuxième appel envoie-t-il plus de jetons en entrée? Que signifie cela pour une exécution de dix étapes?
Afficher la réponse
Un modèle ne garde aucun souvenir entre les appels. Chaque appel renvoie donc toute la conversation : la requête, le billet, les réponses précédentes et les résultats des outils. Le deuxième appel ajoute la première réponse et la commande retournée par get_order : 242 jetons de plus. Dans une exécution de dix étapes, chaque appel est plus volumineux que le précédent. Le nombre de jetons en entrée augmente donc plus vite que le nombre d’étapes. Ces jetons représentent la majorité des jetons de l’exécution : 97 % pour T-80008.
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
Tomás dit : « On devrait mettre la requête et la réponse dans chaque span de modèle. Comme ça, on pourrait tout expliquer. » Donnez deux raisons de ne pas le faire. Dites aussi ce que le span enregistre à la place.
Afficher la réponse
Premièrement, le texte contient les propos du client et des données personnelles. Il serait alors envoyé à chaque système de stockage de télémétrie. Toute personne pouvant lire les traces y aurait accès pendant toute la période de conservation. Deuxièmement, cela rend la télémétrie environ trois fois plus volumineuse : 26,7 Ko par exécution au lieu de 9,3 Ko, selon les mesures du cours. Le span (une portion de trace représentant une opération) enregistre plutôt la requête utilisée : son nom et sa version, un hachage. Il enregistre aussi le modèle qui a répondu. Il conserve également les jetons, la raison de fin, la latence et les noms des étapes demandées par le modèle. Cela suffit pour regrouper, comparer et trouver des exécutions. Le texte reste dans les enregistrements du flux de travail.
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 T-90103 avec --variant agent --model chat-small et utilisez votre propre télémétrie. Combien d'appels de modèle l'exécution a-t-elle faits? Quelle était la raison de fin du dernier appel? Quelle version de la requête a-t-elle utilisée?
Afficher la réponse
Exécutez python -m resolver run T-90103 –variant agent –model chat-small, puis python -m obs trace T-90103 et python show_spans.py chat. Dans l’exécution de l’équipe du cours, la trace contient deux spans chat chat-small. Le premier compte 2 185 jetons en entrée et 21 en sortie, puis le deuxième, 2 433 et 199. Cela donne 4 618 et 220 au total, comme l’a affiché le flux de travail. Les deux se terminent avec tool_calls : le dernier appelle finish avec la proposition, puis l’exécution attend une approbation. Les deux affichent gen_ai.prompt.version = d6c784d1, comme pour T-80008, car la requête de l’agent n’a pas changé. Votre identifiant de trace et votre heure diffèrent, mais les jetons et la version doivent être 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.
Récapitulatif
- Un span
chat {model}par appel de modèle, enfant du span de l’exécution. Il enregistre le modèle demandé et le modèle qui a répondu, ainsi que les jetons en entrée et en sortie. Il enregistre aussi la raison de fin, la latence, le nom et la version de la requête. - Lors d’une réexécution, un span de modèle dure aussi longtemps que l’appel enregistré. La durée de l’exécution est donc la somme des durées de ses appels.
- Les jetons en entrée augmentent à chaque étape, car chaque appel renvoie toute la conversation : 97 % des jetons de T-80008.
- Aucun texte : des noms, des nombres, des identifiants et un hachage de la requête.
obs check-redactionle prouve avec votre propre télémétrie.
Votre projet maintenant : observe.py et runner.py de l’instantané end-of-m03, 81 tests réussis et votre propre show_spans.py. Chaque appel de modèle apparaît dans la trace. Mais le modèle ne fait que proposer : les outils lisent les commandes et enregistrent les remboursements. Aucun d’eux n’apparaît encore dans la trace. Ensuite, vous enregistrerez chaque appel d’outil, ses erreurs et ses nouvelles tentatives.
Leçon suivante : Appels d'outils, erreurs et nouvelles tentatives