Observabilite : tracer les appels LLM

En production, tu as besoin de savoir exactement ce qui se passe a chaque appel LLM. Combien de temps ca prend ? Combien de tokens consommes ? Quel modele a repondu ? Est-ce que ca a echoue ? Sans observabilite, tu navigues a l'aveugle et tu decouvres les problemes quand les utilisateurs se plaignent (ou quand la facture arrive).

Les outils comme LangSmith, Helicone ou Weights & Biases font exactement ca : ils interceptent chaque appel, enregistrent les metriques, et te donnent un tableau de bord.

Tu vas creer une classe LLMTracer qui intercepte les appels a une fonction LLM simulee et enregistre toutes les metriques.

__init__(self, cout_par_token=0.00001) : initialise la liste de traces et le cout par token.

tracer(self, fonction_llm, question, modele="gpt-4") : appelle la fonction, mesure la duree (simule avec un compteur), compte les tokens (approximation : nombre de mots dans la question + nombre de mots dans la reponse), calcule le cout, et enregistre une trace. La fonction renvoie un dictionnaire avec "reponse", "modele", "tokens", "cout", "succes". Si la fonction leve une exception, la trace enregistre l'erreur et "succes" est False.

Pour simuler les tokens, on comptera simplement le nombre de mots (split par espaces) dans la question et la reponse.

resume(self) : renvoie un dictionnaire avec "total_appels", "appels_reussis", "appels_echoues", "total_tokens", "cout_total" (arrondi a 6 decimales), "traces" (la liste de toutes les traces).

Exemple :

t = LLMTracer(cout_par_token=0.001)
def fake_llm(q): return "Voici la reponse"
r = t.tracer(fake_llm, "Bonjour comment ca va")
r["reponse"] contient "Voici la reponse"
r["tokens"] vaut 7 (4 mots question + 3 mots reponse)

Tests (4/5)

Trace un appel reussi

t = LLMTracer()
def llm(q): return 'Reponse simple'
r = t.tracer(llm, 'Bonjour')
assert r['succes'] == True
assert r['reponse'] == 'Reponse simple'
assert r['tokens'] == 3

Trace un appel echoue

t = LLMTracer()
def llm(q): raise Exception('Timeout')
r = t.tracer(llm, 'Test question')
assert r['succes'] == False
assert 'erreur' in r
assert r['reponse'] is None

Tokens calcules correctement

t = LLMTracer(cout_par_token=0.01)
def llm(q): return 'un deux trois'
r = t.tracer(llm, 'a b')
assert r['tokens'] == 5
assert r['cout'] == 0.05

Resume correct apres plusieurs appels

t = LLMTracer()
def ok(q): return 'OK'
def fail(q): raise Exception('E')
t.tracer(ok, 'A B')
t.tracer(ok, 'C')
t.tracer(fail, 'D')
s = t.resume()
assert s['total_appels'] == 3
assert s['appels_reussis'] == 2
assert s['appels_echoues'] == 1

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

class LLMTracer:
    def __init__(self, cout_par_token=0.00001):
        self.cout_par_token = cout_par_token
        self.traces = []

    def tracer(self, fonction_llm, question, modele="gpt-4"):
        tokens_entree = len(question.split())
        try:
            reponse = fonction_llm(question)
            tokens_sortie = len(reponse.split())
            total_tokens = tokens_entree + tokens_sortie
            cout = total_tokens * self.cout_par_token
            trace = {
                "modele": modele,
                "question": question,
                "reponse": reponse,
                "tokens": total_tokens,
                "cout": cout,
                "succes": True,
            }
        except Exception as e:
            trace = {
                "modele": modele,
                "question": question,
                "reponse": None,
                "tokens": tokens_entree,
                "cout": tokens_entree * self.cout_par_token,
                "succes": False,
                "erreur": str(e),
            }
        self.traces.append(trace)
        return trace

    def resume(self):
        reussis = sum(1 for t in self.traces if t["succes"])
        echoues = sum(1 for t in self.traces if not t["succes"])
        total_tokens = sum(t["tokens"] for t in self.traces)
        cout_total = round(sum(t["cout"] for t in self.traces), 6)
        return {
            "total_appels": len(self.traces),
            "appels_reussis": reussis,
            "appels_echoues": echoues,
            "total_tokens": total_tokens,
            "cout_total": cout_total,
            "traces": list(self.traces),
        }

← Guardrails : filtrer entrees et … Agent avec boucle de decision →

solution.py

Bravo!

Observabilite : tracer les appels LLM

Tests (4/5)

Indices (3 disponibles)

Solution officielle