TechniquePratique6 min de lecture
Taxonomie des métriques LLM et instrumentation Python
Quelles métriques LLM collecter, comment les nommer et choisir leurs labels sans faire exploser le nombre de séries, puis comment instrumenter une application Python avec prometheus_client ou le SDK OpenTelemetry.
Pour : ingénieurs et SREPrérequis : Avoir lu la leçon 2 du parcours et savoir lire du Python.
Module 5 : taxonomie des métriques LLM
Section intitulée « Module 5 : taxonomie des métriques LLM »Imaginons qu’un responsable produit pose trois questions en comité : combien nous coûte l’assistant ce mois-ci, est-il plus lent depuis le changement de modèle, ses réponses s’appuient-elles toujours sur les bons documents ? Le scénario est illustratif. Si l’application n’émet pas les bonnes métriques, personne ne peut répondre, quelle que soit la qualité du stockage.
La taxonomie de ce module, c’est-à-dire le classement des métriques à collecter, couvre quatre familles : la qualité des réponses, la performance et la latence, les coûts et les tokens (les morceaux de texte que le modèle lit et produit, sur lesquels se fait la facturation), l’infrastructure GPU et CPU.
5.1 Conventions de nommage recommandées
Section intitulée « 5.1 Conventions de nommage recommandées »Un nom de métrique se lit comme une étiquette de rayon : le préfixe dit dans quel rayon chercher, le suffixe dit ce qu’on y trouve. Ce guide préfixe par llm_ toutes les métriques propres aux LLM et par rag_ celles de la recherche documentaire (retrieval). Les métriques GPU gardent les noms DCGM standard (DCGM_FI_*).
Pour les suffixes, _total désigne un compteur, _seconds ou _ms un histogramme de latence, _bytes une jauge. _ratio désigne une valeur sans unité entre 0 et 1, quel que soit le type (jauge ou histogramme), comme rag_context_pressure_ratio.
Les trois types Prometheus reviennent dans tout le guide. Un compteur ne fait que monter, comme un compteur kilométrique : nombre de requêtes, de tokens, de dollars dépensés. Une jauge monte et descend, comme un thermomètre : utilisation d’un GPU, score moyen. Un histogramme range chaque mesure dans des intervalles pour qu’on puisse calculer ensuite des centiles, par exemple la durée sous laquelle passent 95 % des requêtes.
| Métrique | Type Prometheus | Cardinalité | Labels essentiels |
|---|---|---|---|
llm_requests_total | Compteur | Moyenne | model, provider, pipeline_id, status |
llm_request_duration_ms | Histogramme | Moyenne | model, provider, pipeline_id |
llm_tokens_total{type} | Compteur | Faible | model, provider, type=input ou output |
llm_cost_usd_total | Compteur | Faible | model, provider, tenant_id, use_case |
llm_errors_total | Compteur | Moyenne | model, provider, error_type |
llm_ttft_ms | Histogramme | Moyenne | model, provider |
rag_retrieval_score_avg | Jauge | Faible | index_id, pipeline_id, strategy |
rag_context_pressure_ratio | Histogramme | Faible | pipeline_id, model |
rag_chunks_dropped_total | Compteur | Faible | pipeline_id, reason |
DCGM_FI_DEV_GPU_UTIL | Jauge | Faible | gpu, UUID, pod, namespace, node |
vllm:num_requests_running | Jauge | Faible | model_name, instance |
Le mécanisme est celui d’un tableau de suivi : chaque valeur nouvelle d’un label ouvre de nouvelles lignes, pour chaque modèle, chaque fournisseur et chaque intervalle d’histogramme. La page La cardinalité expliquée le montre pas à pas.
Module 6 : instrumentation Python, émettre les métriques
Section intitulée « Module 6 : instrumentation Python, émettre les métriques »Instrumenter une application, c’est lui faire tenir son propre carnet de bord : à chaque appel au modèle, elle note la durée, les tokens, le coût et le résultat.
6.1 Deux approches complémentaires
Section intitulée « 6.1 Deux approches complémentaires »La première passe par la bibliothèque cliente Prometheus. L’application affiche ses compteurs sur un point /metrics et vmagent vient les relever. C’est simple et très répandu.
La seconde passe par le SDK OpenTelemetry, qui pousse les données en OTLP. Métriques et traces suivent alors le même pipeline. Je la recommande pour les nouvelles applications.
# Option 1 : prometheus_clientpip install prometheus-client
# Option 2 : SDK OTel (métriques et traces unifiées)pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-grpc6.2 Client Prometheus : les métriques LLM de base
Section intitulée « 6.2 Client Prometheus : les métriques LLM de base »from prometheus_client import Counter, Histogram, Gauge, start_http_serverimport time
LLM_REQUESTS = Counter( 'llm_requests_total', 'Total LLM requests', ['model', 'provider', 'pipeline_id', 'status'])LLM_ERRORS = Counter( 'llm_errors_total', 'Total failed LLM requests', ['model', 'provider', 'error_type'])LLM_DURATION = Histogram( 'llm_request_duration_ms', 'LLM request duration in ms', ['model', 'provider', 'pipeline_id'], buckets=[50, 100, 200, 500, 1000, 2000, 5000, 10000, 30000])LLM_TOKENS = Counter( 'llm_tokens_total', 'Total tokens processed', ['model', 'provider', 'type'] # type : input ou output)LLM_COST = Counter( 'llm_cost_usd_total', 'Total cost in USD', ['model', 'provider', 'tenant_id', 'use_case'])LLM_TTFT = Histogram( 'llm_ttft_ms', 'Time to first token in ms', ['model', 'provider'], buckets=[50, 100, 200, 500, 1000, 2000, 5000])RAG_RETRIEVAL_SCORE = Gauge( 'rag_retrieval_score_avg', 'Average retrieval similarity score', ['index_id', 'pipeline_id', 'strategy'])RAG_CONTEXT_PRESSURE = Histogram( 'rag_context_pressure_ratio', 'Context window pressure ratio (0-1)', ['pipeline_id', 'model'], buckets=[0.1, 0.3, 0.5, 0.7, 0.8, 0.85, 0.9, 0.95, 1.0])RAG_CHUNKS_DROPPED = Counter( 'rag_chunks_dropped_total', 'Chunks dropped from the context', ['pipeline_id', 'reason'])
# Expose /metrics sur le port 8000 (9090 est le port habituel de Prometheus)start_http_server(8000)6.3 Décorateur d’instrumentation : suivi automatique des coûts
Section intitulée « 6.3 Décorateur d’instrumentation : suivi automatique des coûts »En Python, un décorateur est une fonction qui en enveloppe une autre : on l’écrit une fois, on le pose au-dessus de chaque fonction qui appelle le modèle et il mesure tout sans qu’on modifie le corps de ces fonctions. Celui-ci compte les tokens, calcule le coût à partir d’une grille de prix, chronomètre l’appel et compte les erreurs.
import functoolsimport jsonimport os
# Grille de prix en USD par token, lue depuis un fichier JSON versionné que vous# fournissez ; aucune valeur ici. À renseigner depuis la grille datée de votre fournisseur :# {"effective_date": "AAAA-MM-JJ", "currency": "USD",# "models": {"grand-modele": {"input": null, "output": null}}}# Sans fichier, TOKEN_PRICES reste vide : le décorateur compte les tokens et n'émet# pas llm_cost_usd_total.PRICE_GRID_FILE = os.getenv('LLM_PRICE_GRID_FILE')PRICE_GRID_EFFECTIVE_DATE = NoneTOKEN_PRICES = {}if PRICE_GRID_FILE: with open(PRICE_GRID_FILE, encoding='utf-8') as fh: _grid = json.load(fh) PRICE_GRID_EFFECTIVE_DATE = _grid['effective_date'] TOKEN_PRICES = {m: p for m, p in _grid['models'].items() if p.get('input') is not None and p.get('output') is not None}
def track_llm_call(model, provider, pipeline_id, tenant_id='default', use_case='chat'): def decorator(func): @functools.wraps(func) async def wrapper(*args, **kwargs): labels = {'model': model, 'provider': provider, 'pipeline_id': pipeline_id} t0 = time.monotonic() status = 'success' try: result = await func(*args, **kwargs) if hasattr(result, 'usage'): in_tok = result.usage.prompt_tokens out_tok = result.usage.completion_tokens LLM_TOKENS.labels(model=model, provider=provider, type='input').inc(in_tok) LLM_TOKENS.labels(model=model, provider=provider, type='output').inc(out_tok) if model in TOKEN_PRICES: p = TOKEN_PRICES[model] cost = in_tok * p['input'] + out_tok * p['output'] LLM_COST.labels(model=model, provider=provider, tenant_id=tenant_id, use_case=use_case).inc(cost) return result except Exception as e: status = type(e).__name__ LLM_ERRORS.labels(model=model, provider=provider, error_type=status).inc() raise finally: LLM_DURATION.labels(**labels).observe((time.monotonic() - t0) * 1000) LLM_REQUESTS.labels(**labels, status=status).inc() return wrapper return decorator
@track_llm_call(model='grand-modele', provider='fournisseur-a', pipeline_id='support-rag', tenant_id='acme')async def call_llm(messages: list) -> dict: # client : le client SDK de votre fournisseur ; utilisez l'identifiant exact du modèle return await client.chat.completions.create(model='identifiant-du-modele', messages=messages)Le label status prend le nom de la classe d’exception : limitez le nombre de types d’exception distincts, ou ramenez-les à une courte liste de catégories, pour borner la cardinalité.
Révisé le 2 octobre 2026 : prix retirés ; la grille de prix du décorateur est lue depuis un fichier que vous fournissez, sans valeur dans le guide et le coût n’est émis que pour les modèles dont le prix est renseigné.