Aller au contenu

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.

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.

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étriqueType PrometheusCardinalitéLabels essentiels
llm_requests_totalCompteurMoyennemodel, provider, pipeline_id, status
llm_request_duration_msHistogrammeMoyennemodel, provider, pipeline_id
llm_tokens_total{type}CompteurFaiblemodel, provider, type=input ou output
llm_cost_usd_totalCompteurFaiblemodel, provider, tenant_id, use_case
llm_errors_totalCompteurMoyennemodel, provider, error_type
llm_ttft_msHistogrammeMoyennemodel, provider
rag_retrieval_score_avgJaugeFaibleindex_id, pipeline_id, strategy
rag_context_pressure_ratioHistogrammeFaiblepipeline_id, model
rag_chunks_dropped_totalCompteurFaiblepipeline_id, reason
DCGM_FI_DEV_GPU_UTILJaugeFaiblegpu, UUID, pod, namespace, node
vllm:num_requests_runningJaugeFaiblemodel_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.

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.

Fenêtre de terminal
# Option 1 : prometheus_client
pip install prometheus-client
# Option 2 : SDK OTel (métriques et traces unifiées)
pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-grpc

6.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_server
import 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 functools
import json
import 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 = None
TOKEN_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é.