Audit & optimisation

Décomposition d'un appel de support en postes de tokens

Un éditeur de logiciel de gestion fait tourner un assistant de support en production. La facture mensuelle monte, personne ne sait ce que coûte une réponse, et le budget de l'année prochaine se décide bientôt.

Cas inventéCe cas n'est pas une mission. Il est inventé de bout en bout, et le code plus bas est le vrai code qui le ferait tourner.

1. Humain·La facture monte

   L'assistant de support répond bien depuis sa mise en production. La facture mensuelle monte et personne ne sait d'où ça vient. Combien coûte une réponse ?

2. L'agent·Inspecter un tour réel

   Une facture agrégée ne dit pas d'où vient le volume. L'inspection porte donc sur un tour réel, le septième d'une conversation en cours. Elle sépare ce qui change à chaque tour de ce qui ne change pas d'un tour au suivant, et ce second bloc est le contexte rejoué.

3. Appel d'outil·Appel d'inspection

   {
     "outil": "inspecter_appel",
     "conversation": "conv-8412",
     "tour": 7,
     "decomposer": true,
     "postes": [
       "consigne_systeme",
       "catalogue_produit",
       "exemples_de_reponses",
       "historique_conversation",
       "question_du_client"
     ],
     "comparer_au_tour": 6
   }

   L'inspection porte sur un appel de production, pas sur un appel fabriqué pour la démonstration.

4. Retour de l'outil·Le relevé du tour

   {
     "conversation": "conv-8412",
     "tour": 7,
     "tokens_envoyes": 17740,
     "postes": {
       "consigne_systeme": 1180,
       "catalogue_produit": 9400,
       "exemples_de_reponses": 2600,
       "historique_conversation": 4350,
       "question_du_client": 210
     },
     "empreintes_identiques_au_tour_6": [
       "consigne_systeme",
       "catalogue_produit",
       "exemples_de_reponses"
     ],
     "contexte_rejoue": 13180,
     "tokens_lus_en_cache": 0,
     "cache_control_present": false,
     "appels_observes": 1,
     "appels_exiges": 200,
     "chiffrage_facture": "refusé, échantillon d'un seul appel"
   }

   Le relevé refuse de chiffrer une facture sur un seul appel, la garde du code exige la série.

5. Appel d'outil·La requête rejouée

   {
     "outil": "rejouer_appel",
     "conversation": "conv-8412",
     "tour": 7,
     "blocs": [
       {
         "poste": "consigne_systeme",
         "cache_control": "ephemere"
       },
       {
         "poste": "exemples_de_reponses",
         "cache_control": "ephemere"
       },
       {
         "poste": "catalogue_produit",
         "mode": "extraits_recherches",
         "fiches": 3
       },
       {
         "poste": "historique_conversation",
         "tours_conserves": 3
       },
       {
         "poste": "question_du_client"
       }
     ],
     "mesurer": [
       "tokens_envoyes",
       "tokens_lus_en_cache",
       "similarite_avec_la_reponse_initiale"
     ]
   }

   Le préfixe mis en cache doit rester identique octet pour octet, sinon la lecture de cache ne se déclenche pas.

6. Réponse rendue·Le volume par poste

   Le tour inspecté envoie 17 740 tokens : 1 180 de consigne, 9 400 de catalogue, 2 600 d'exemples, 4 350 d'historique, 210 de question. Trois postes ont la même empreinte qu'au tour précédent et pèsent 13 180 tokens, renvoyés en entier, sans cache. La requête rejouée part avec ces blocs marqués pour le cache, un catalogue réduit à trois fiches et un historique de trois tours. Sa mesure arrive avec la série, et aucun montant n'est produit avant : le prix du token reste celui de votre contrat.

"""Relevé des postes de tokens d'un assistant de support en production."""

from collections import Counter

APPELS_MINIMUM = 200
POSTES_STABLES = ("consigne_systeme", "catalogue_produit", "exemples_de_reponses")


class EchantillonInsuffisant(Exception):
    """Un relevé tiré de quelques appels se fait démentir au premier pic."""

def decomposer(appel):
    postes, empreintes = Counter(), {}
    for bloc in appel["blocs"]:
        postes[bloc["poste"]] += bloc["tokens"]
        empreintes[bloc["poste"]] = bloc["empreinte"]
    return postes, empreintes

def contexte_rejoue(postes, empreintes, precedentes):
    stables = [poste for poste in postes if poste in POSTES_STABLES]
    return sum(postes[p] for p in stables if precedentes.get(p) == empreintes[p])

def relever(appels, minimum=APPELS_MINIMUM):
    if len(appels) < minimum:
        raise EchantillonInsuffisant(
            "échantillon insuffisant : {} sur {} appels exigés".format(len(appels), minimum)
        )
    total, rejoue, lu_en_cache = Counter(), 0, 0
    conversation, precedentes = None, {}
    for appel in sorted(appels, key=lambda a: (a["conversation"], a["tour"])):
        # Le contexte rejoué se compte dans une conversation, jamais entre deux.
        if appel["conversation"] != conversation:
            conversation, precedentes = appel["conversation"], {}
        postes, empreintes = decomposer(appel)
        total.update(postes)
        rejoue += contexte_rejoue(postes, empreintes, precedentes)
        lu_en_cache += appel.get("tokens_lus_en_cache", 0)
        precedentes = empreintes
    envoyes = sum(total.values())
    return {
        "appels": len(appels),
        "tokens_envoyes": envoyes,
        "tokens_par_reponse": envoyes // len(appels),
        "contexte_rejoue": rejoue,
        "tokens_lus_en_cache": lu_en_cache,
        "postes": dict(total.most_common()),
    }

def facturer(releve, prix_entree, prix_lecture_cache):
    # Les tarifs viennent du contrat en cours, jamais du code.
    plein = releve["tokens_envoyes"] - releve["tokens_lus_en_cache"]
    return plein * prix_entree + releve["tokens_lus_en_cache"] * prix_lecture_cache

Tant que personne n'a décomposé un appel réel, un budget IA n'est pas piloté, il est subi.