Parcourir les aide-mémoire · Ingénierie IA pour les données

Technologie: Ingénierie IA pour les donnéesCatégorie: Maîtrise des coûtsNiveau: IntermédiaireMis à jour

Coût LLM et budget de tokens

Estimez et maîtrisez le coût d’une charge de travail LLM avec des formules simples par requête, par jour et par mois, des budgets de tokens, le choix du niveau de modèle, la mise en cache, le batch et la supervision.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Formules de coût
  4. Pourquoi les prix évoluent
  5. Code / commandes
  6. 1. Estimer le coût d’une requête
  7. 2. Projeter le coût quotidien et mensuel
  8. 3. Utiliser des percentiles, pas seulement des moyennes
  9. 4. Inclure nouvelles tentatives, escalades et tokens de raisonnement
  10. 5. Vérifier le débit face aux limites
  11. 6. Fixer un budget de tokens par requête
  12. 7. Plafonner la sortie
  13. 8. Ajouter des budgets par utilisateur et par session
  14. 9. Ajouter des budgets de workflow
  15. 10. Choisir le niveau de modèle selon la tâche
  16. 11. Séparer les charges batch et interactives
  17. 12. Estimer l’effet de la mise en cache
  18. 13. Superviser le coût en continu
  19. Interpréter le résultat
  20. Points à vérifier
  21. Erreurs fréquentes
  22. 1. Coder les prix en dur
  23. 2. Estimer à partir de la seule requête moyenne
  24. 3. Ignorer les tokens de sortie
  25. 4. Oublier nouvelles tentatives et escalades
  26. 5. Budgéter uniquement au mois
  27. 6. Supposer que le cache fait toujours économiser
  28. 7. Prendre le modèle le moins cher sans mesurer la qualité
  29. Notes de production
  30. Liste de contrôle
  31. Étape suivante
  32. Pour aller plus loin

Problème

Vous devez répondre à des questions comme :

  • Combien coûtera cette fonctionnalité LLM par mois ?
  • Que devient le coût si l’usage double ?
  • Quelle fonctionnalité, quel utilisateur ou quel pipeline fait monter la dépense ?
  • Comment empêcher un workflow de consommer tout le budget ?
  • Un modèle moins cher, un cache ou un traitement batch vaut-il la peine ?

Le coût d’un LLM dépend de l’usage : tokens, volume de requêtes, choix du modèle, nouvelles tentatives et mise en cache. Et les prix eux-mêmes évoluent dans le temps.

Réponse rapide

request_cost = (input_tokens  × input_rate)
             + (output_tokens × output_rate)

monthly_cost = average_request_cost × requests_per_month

Les tarifs sont généralement exprimés par million de tokens. Lisez-les dans la configuration, pas dans le code ni dans la documentation, car ils changent.

Pour maîtriser le coût :

  1. Journalisez les tokens et le coût estimé de chaque requête.
  2. Fixez un budget de tokens par requête et un plafond de tokens de sortie.
  3. Ajoutez des budgets par utilisateur, par session et par exécution de workflow.
  4. Routez le travail simple vers des modèles moins chers.
  5. Traitez en batch ce qui n’est pas interactif, quand le fournisseur le propose.
  6. Ne mettez en cache que là où les entrées se répètent.
  7. Alertez sur le rythme de consommation du budget, pas seulement sur la facture mensuelle.

Formules de coût

Grandeur Formule
Tokens par requête input_tokens + output_tokens
Coût par requête input_tokens × input_rate + output_tokens × output_rate
Avec entrée en cache uncached_input × input_rate + cached_input × cached_input_rate + output_tokens × output_rate
Requêtes par jour requests_per_minute × active_minutes_per_day (ou d’après les journaux)
Requêtes effectives requests × (1 + retry_rate)
Coût par jour average_request_cost × effective_requests_per_day
Coût par mois cost_per_day × days_in_month
Tokens par minute requests_per_minute × average_tokens_per_request

La façon dont les tokens en cache sont comptés et facturés dépend du fournisseur : certains les incluent dans les tokens d’entrée, d’autres les déclarent à part, et certains facturent l’écriture dans le cache. Vérifiez les champs d’usage de l’API que vous appelez.

Pourquoi les prix évoluent

  • Les fournisseurs publient de nouveaux modèles et changent le prix des anciens.
  • Les prix diffèrent selon la taille du modèle et entre entrée, sortie et entrée en cache.
  • Les offres batch, prioritaires ou régionales peuvent avoir d’autres tarifs.
  • Votre propre usage change : prompts plus longs, nouvelles fonctionnalités, plus d’utilisateurs.

Donc :

  • gardez les tarifs dans une configuration versionnée (une « grille tarifaire »), pas dans le code
  • stockez le coût estimé et la version de la grille avec chaque requête journalisée
  • réestimez à chaque changement de modèle, de prompt ou de trafic

Code / commandes

1. Estimer le coût d’une requête

from dataclasses import dataclass


@dataclass(frozen=True)
class Rates:
    """Prix par million de tokens. À charger depuis la configuration : les prix des fournisseurs changent."""
    input_per_m: float
    output_per_m: float
    cached_input_per_m: float | None = None


def request_cost(rates: Rates, input_tokens: int, output_tokens: int, cached_input_tokens: int = 0) -> float:
    """Coût d'une requête. `input_tokens` inclut `cached_input_tokens`."""
    uncached = input_tokens - cached_input_tokens
    cached_rate = rates.cached_input_per_m if rates.cached_input_per_m is not None else rates.input_per_m
    return (
        uncached * rates.input_per_m
        + cached_input_tokens * cached_rate
        + output_tokens * rates.output_per_m
    ) / 1_000_000

2. Projeter le coût quotidien et mensuel

def monthly_cost(avg_request_cost: float, requests_per_day: float, days: int = 30, retry_rate: float = 0.0) -> float:
    return avg_request_cost * requests_per_day * (1 + retry_rate) * days


example = Rates(input_per_m=1.00, output_per_m=4.00)   # chiffres d'illustration, pas des prix réels
cost = request_cost(example, input_tokens=1_500, output_tokens=400)
print(round(cost, 6))                                      # 0.0031
print(round(monthly_cost(cost, requests_per_day=50_000)))  # 4650

Exemple chiffré avec ces tarifs d’illustration :

Étape Valeur
Entrée 1 500 tokens × 1,00 / 1M = 0,0015
Sortie 400 tokens × 4,00 / 1M = 0,0016
Coût par requête 0,0031
50 000 requêtes/jour 155 par jour
30 jours 4 650 par mois

Notez que 400 tokens de sortie coûtent plus que 1 500 tokens d’entrée quand le tarif de sortie est plus élevé. La longueur de la sortie compte.


3. Utiliser des percentiles, pas seulement des moyennes

Quelques requêtes très longues (gros documents, longues conversations, boucles d’agents) peuvent dominer le coût.

SELECT DISTINCT
    feature,
    PERCENTILE_CONT(0.5)  WITHIN GROUP (ORDER BY input_tokens + output_tokens) OVER (PARTITION BY feature) AS p50_tokens,
    PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY input_tokens + output_tokens) OVER (PARTITION BY feature) AS p95_tokens,
    MAX(input_tokens + output_tokens) OVER (PARTITION BY feature) AS max_tokens
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -7, SYSUTCDATETIME());

Budgétez pour le p95, pas pour la requête moyenne.


4. Inclure nouvelles tentatives, escalades et tokens de raisonnement

Le coût réel par tâche réussie dépasse le coût par appel quand :

  • une sortie invalide est relancée
  • les cas en échec sont escaladés vers un modèle plus grand
  • le modèle facture ses tokens de raisonnement comme sortie
  • un agent fait plusieurs appels par demande utilisateur
cost_per_successful_task = total_cost_of_all_calls / tasks_completed_successfully

5. Vérifier le débit face aux limites

tokens_per_minute   = requests_per_minute × average_tokens_per_request
requests_per_minute = trafic de pointe, pas la moyenne quotidienne

Comparez les deux avec les limites de requêtes et de tokens de votre fournisseur. Un rattrapage batch peut atteindre la limite de tokens par minute bien avant le budget de coût.


6. Fixer un budget de tokens par requête

Estimez l’entrée avant l’appel et réservez la place pour la sortie maximale :

class BudgetExceeded(Exception):
    pass


def check_request_budget(estimated_input: int, max_output: int, request_budget: int) -> None:
    worst_case = estimated_input + max_output
    if worst_case > request_budget:
        raise BudgetExceeded(f"la requête peut utiliser {worst_case} tokens ; le budget est de {request_budget}")

Quand la vérification échoue, réduisez le contexte (historique, récupération) avant l’appel, ou refusez avec une erreur claire.


7. Plafonner la sortie

  • Fixez un plafond de tokens de sortie pour chaque appel.
  • Dimensionnez-le d’après les longueurs observées plus une marge, pas d’après le maximum du modèle.
  • Traitez une réponse tronquée comme un échec (JSON invalide, texte coupé) et journalisez-la.

8. Ajouter des budgets par utilisateur et par session

def remaining_tokens(daily_limit: int, used_today: int) -> int:
    return max(daily_limit - used_today, 0)

Stockez l’usage par utilisateur et par session (par exemple dans une table indexée par utilisateur et date), vérifiez-le avant chaque appel et renvoyez un message clair quand le budget est épuisé. Cela limite aussi les abus sur les points d’accès publics.


9. Ajouter des budgets de workflow

Pour les pipelines et les agents, budgétez l’exécution, pas seulement l’appel :

  • nombre maximal d’appels par exécution
  • nombre maximal de tokens par exécution
  • coût maximal par exécution
  • condition d’arrêt quand le budget est atteint, avec sauvegarde des résultats partiels
class RunBudget:
    def __init__(self, max_tokens: int, max_calls: int):
        self.max_tokens, self.max_calls = max_tokens, max_calls
        self.tokens = self.calls = 0

    def charge(self, input_tokens: int, output_tokens: int) -> None:
        self.calls += 1
        self.tokens += input_tokens + output_tokens
        if self.tokens > self.max_tokens or self.calls > self.max_calls:
            raise BudgetExceeded(f"exécution arrêtée après {self.calls} appels et {self.tokens} tokens")

10. Choisir le niveau de modèle selon la tâche

Tâche Niveau habituel
Classification, étiquetage, extraction courte Modèle plus petit et moins cher
Résumés de contenus à structure connue Modèle petit ou intermédiaire
Raisonnement en plusieurs étapes, analyse ambiguë Modèle plus grand ou modèle de raisonnement
Analyse déterministe, mise en forme, calcul Pas de modèle : code, SQL ou règles

Mesurez la qualité à chaque niveau : un modèle moins cher qui échoue souvent peut coûter plus par tâche réussie.


11. Séparer les charges batch et interactives

Interactif Batch
Latence Les secondes comptent Minutes ou heures acceptables
Volume Par pics Important, planifiable
Leviers de coût Prompts plus courts, modèles plus petits, cache API batch quand elles existent, exécution hors pointe, lots plus gros par appel
Budget Par utilisateur / session Par exécution / par jour

Exécutez les rattrapages et les jobs d’enrichissement comme des charges batch, avec leur propre budget.


12. Estimer l’effet de la mise en cache

expected_input_cost = (1 - hit_rate) × uncached_cost + hit_rate × cached_cost
  • Le cache de résultats économise toute la requête en cas de succès, mais seulement si des entrées identiques se répètent.
  • La mise en cache de prompt/préfixe, quand elle existe, réduit le coût des préfixes répétés ; règles et prix varient.
  • Mesurez le taux de succès réel avant de compter les économies.

13. Superviser le coût en continu

Stockez le coût estimé avec chaque requête :

SELECT
    CAST(requested_at AS date) AS usage_date,
    feature,
    SUM(input_tokens)   AS input_tokens,
    SUM(output_tokens)  AS output_tokens,
    SUM(estimated_cost) AS estimated_cost
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -30, SYSUTCDATETIME())
GROUP BY CAST(requested_at AS date), feature
ORDER BY usage_date, estimated_cost DESC;

Rapprochez régulièrement ces chiffres des données de facturation du fournisseur : votre estimation ne vaut que ce que vaut votre grille tarifaire.

Interpréter le résultat

Signal Signification probable
Le coût augmente plus vite que les requêtes Les prompts, l’historique ou les sorties s’allongent
Le coût de sortie domine Réponses verbeuses ou sans plafond
Une fonctionnalité domine Optimisez ou budgétez-la en premier
p95 très au-dessus du p50 Quelques requêtes longues pilotent le coût : plafonnez-les
Coût par tâche réussie très supérieur au coût par appel Nouvelles tentatives ou escalades
L’estimation diffère de la facture Grille tarifaire obsolète, appels non journalisés ou comptage des tokens en cache

Points à vérifier

  • Des requêtes sans plafond de tokens de sortie.
  • Des fonctionnalités sans responsable ni budget.
  • Des appels non journalisés (scripts, notebooks, expérimentations).
  • Des rattrapages qui consomment les limites de l’interactif.
  • Des rafales de nouvelles tentatives après un déploiement.
  • Une grille tarifaire plus ancienne que la version actuelle du modèle.

Erreurs fréquentes

1. Coder les prix en dur

Les prix changent. Gardez-les dans la configuration, avec une version et une date d’effet.

2. Estimer à partir de la seule requête moyenne

Les requêtes de longue traîne et les boucles d’agents dominent la dépense réelle.

3. Ignorer les tokens de sortie

La sortie est souvent plus chère par token que l’entrée.

4. Oublier nouvelles tentatives et escalades

Le coût par appel n’est pas le coût par tâche réussie.

5. Budgéter uniquement au mois

Un job qui s’emballe peut dépenser le budget d’un mois en quelques heures. Utilisez des limites par exécution, par utilisateur et par jour.

6. Supposer que le cache fait toujours économiser

Il ne fait économiser que si les entrées ou préfixes se répètent, et certains fournisseurs facturent l’écriture en cache.

7. Prendre le modèle le moins cher sans mesurer la qualité

Les mauvaises réponses ont aussi un coût : reprises, escalades et perte de confiance.

Notes de production

  • Tenez une grille tarifaire versionnée par modèle ; journalisez sa version avec chaque requête.
  • Appliquez les budgets dans le code avant d’appeler le modèle, pas après la facture.
  • Alertez sur le rythme de consommation quotidien et sur les pics inhabituels par fonctionnalité.
  • Donnez à chaque fonctionnalité LLM un responsable et un budget.
  • Séparez expérimentations et production (clés ou projets distincts) pour voir leurs coûts séparément.
  • Revoyez le coût après chaque changement de prompt, de modèle ou de trafic.
  • Journalisez les comptes de tokens et les coûts, pas les prompts bruts, quand ils contiennent des données sensibles.

Liste de contrôle

  • Les tarifs viennent d’une configuration versionnée.
  • Chaque requête journalise tokens d’entrée, de sortie et en cache, modèle et coût estimé.
  • Chaque appel a un plafond de tokens de sortie.
  • Des budgets existent par requête, par utilisateur/session et par exécution.
  • Les tokens par minute en pointe respectent les limites du fournisseur.
  • Le niveau de modèle est choisi par tâche et mesuré.
  • Le batch est séparé de l’interactif.
  • Le taux de succès du cache est mesuré avant d’annoncer des économies.
  • Les estimations sont rapprochées de la facturation.

Étape suivante

  • Les prompts sont trop gros → Optimiser les tokens d’un LLM.
  • Vous hésitez sur le niveau de modèle → Choisir le bon modèle d’IA.
  • Le contexte grossit à chaque requête → Ingénierie du contexte pour les LLM.

← Tous les aide-mémoire