Accueil / Factory / R Underground / 5 oct. 2026 IA GEN · 5 oct. 2026

Budgétiser ses appels LLM en R : compter les tokens avant de payer

ellmer permet désormais d'estimer le coût d'un appel LLM avant de l'envoyer : de quoi industrialiser la maîtrise budgétaire des apps IA en R.

Budgétiser ses appels LLM en R : compter les tokens avant de payer
À la une

Maîtriser le coût de ses applications IA en R

Une app Shiny avec chatbot intégré, un pipeline de résumé automatique de documents, un agent qui interroge une base de données : toutes ces briques ont un point commun, un coût par appel qui dépend du nombre de tokens envoyés et reçus. Tant qu'on reste en phase de prototype, personne ne regarde la facture. Dès que l'app passe en production avec des dizaines d'utilisateurs, le sujet devient un enjeu de pilotage, et c'est souvent l'équipe data qui doit y répondre sans avoir d'outil pour le faire a priori.

Jusqu'ici, la seule façon de connaître le coût d'un prompt était de l'envoyer et de regarder la réponse de l'API après coup. ellmer introduit token_count(), une fonction qui interroge le fournisseur pour savoir combien de tokens une entrée consommerait, sans déclencher l'appel réel. C'est la différence entre estimer une facture et la découvrir en fin de mois. Pour une équipe qui opère plusieurs apps en production, ça change la manière de concevoir les prompts et de dimensionner les contextes envoyés au modèle.

Concrètement, l'usage le plus utile est en amont de l'envoi : on construit son prompt, on insère le contexte (historique de conversation, extraits de documents via RAG, résultats de requêtes), puis on vérifie la taille avant de valider l'appel. Dans une app shinychat, ça permet d'afficher à l'utilisateur ou à l'administrateur une estimation du coût de sa question, ou de tronquer automatiquement un contexte trop long avant qu'il ne fasse exploser la note. C'est aussi un outil de test : on peut comparer deux formulations de prompt système et choisir la plus économique à qualité de réponse égale.

La limite, c'est que token_count() dépend de l'implémentation du fournisseur et peut légèrement diverger du décompte réel facturé, notamment avec des messages systèmes complexes, des appels d'outils ou des pièces jointes. Ce n'est pas un simulateur de facture au centime près, c'est un ordre de grandeur fiable pour arbitrer. Et ça ne remplace pas un vrai suivi de consommation côté fournisseur (dashboard OpenAI, Anthropic, etc.), qui reste la source de vérité pour la facturation.

Le vrai gain est organisationnel plus que technique : ça permet d'introduire un budget token dans le cycle de développement, au même titre qu'un budget mémoire ou un budget de latence. Une équipe qui construit plusieurs apps IA en R peut désormais écrire des tests qui vérifient qu'un prompt type reste sous un seuil donné, avant même de solliciter l'API.

CODE R
library(ellmer)

chat <- chat_openai(model = "gpt-5")

prompt_systeme <- "Tu es un assistant qui resume des rapports financiers en 3 points."

contexte_utilisateur <- paste(readLines("rapport_long.txt"), collapse = "\n")

message_complet <- paste(prompt_systeme, contexte_utilisateur, sep = "\n\n")

n_tokens <- token_count(chat, message_complet)

seuil_budget <- 4000

if (n_tokens > seuil_budget) {
  cat("Attention : prompt estime a", n_tokens, "tokens, au-dessus du seuil de", seuil_budget, "\n")
  contexte_tronque <- substr(contexte_utilisateur, 1, 3000)
  message_complet <- paste(prompt_systeme, contexte_tronque, sep = "\n\n")
  n_tokens <- token_count(chat, message_complet)
}

cat("Tokens estimes avant envoi :", n_tokens, "\n")

reponse <- chat$chat(message_complet)

Le code vérifie la taille estimée du prompt avant l'appel réel, et tronque le contexte si un seuil budgétaire est dépassé.

Notre avis

C'est une brique modeste mais qui manquait clairement : sans estimation a priori, personne ne peut budgétiser sérieusement une app IA en entreprise. On recommande de l'intégrer systématiquement dans les tests de non-régression des prompts, au même titre qu'on teste une fonction métier.

→ Pour qui : Data scientists et développeurs Shiny qui opèrent des applications IA en production et doivent en justifier le coût.

LES BRÈVES

OUTILS

knitr apprend le SQL et se teste mieux

La communauté R dispose désormais d'un Zulip Chat dédié, et knitr continue d'étoffer son moteur SQL ainsi que ses outils de débogage pour les chunks complexes. Une technique de snapshot des messages d'erreur en test facilite aussi la détection de régressions silencieuses dans les packages.

Source : rweekly.org ↗
OUTILS

Positron scanne la sécurité de vos packages

Le panneau Packages de Positron affiche désormais un score de vulnérabilité par dépendance, directement visible sans sortir de l'IDE. Combiné au nouveau pilote ODBC générique pour explorer n'importe quelle base installée, c'est un pas de plus vers un IDE pensé pour des environnements d'entreprise contraints.

Source : positron.posit.co ↗
DATA

duckdb-r revoit le stockage de ses extensions

La version 1.5.5 du package R pour DuckDB simplifie la gestion des extensions et des secrets en unifiant leur emplacement sur disque, après plusieurs tâtonnements dans les versions précédentes. Des corrections touchent aussi le passage de prédicats aux tables Arrow enregistrées, utile pour les pipelines qui mêlent DuckDB et Arrow.

Source : github.com ↗

LE TIP R DU JOUR

Repérer les doublons sans construire de table de fréquences

duplicated() signale directement les éléments déjà vus plus tôt dans un vecteur, sans passer par table() ni comparaison manuelle. Combiné à un indice logique inversé, c'est la manière la plus directe de filtrer les doublons tout en gardant la première occurrence.

CODE R
x <- c(3, 1, 4, 1, 5, 3, 9)

est_doublon <- duplicated(x)

x_sans_doublons <- x[!est_doublon]

print(x_sans_doublons)

SOURCES

VOUS CODEZ EN R ?

Nous formons vos équipes à R, Shiny et l'IA, et industrialisons vos apps et modèles.

Parlons-en →
← Tout R Underground