26/06/2026
Intention : montrer pas à pas comment concevoir et implémenter une gestion de quotas et d’attribution de coûts pour les appels à des modèles LLM (Large Language Models) dans une application SaaS multitenant. Public : CTO / lead dev qui doivent garantir contrôle des coûts, isolation tenant et piste d’audit.
Composants clés :
Client → API Gateway (tenant id) → Quota check (Redis) → Broker LLM → Provider LLM → Response
Exemple PostgreSQL (simplifié) :
CREATE TABLE tenants (
id uuid PRIMARY KEY,
name text,
plan text,
llm_monthly_quota_tokens bigint DEFAULT 0, -- quota en tokens ou en crédits
llm_rate_limit_per_minute int DEFAULT 60
);
CREATE TABLE llm_usage (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
tenant_id uuid REFERENCES tenants(id),
timestamp timestamptz NOT NULL DEFAULT now(),
tokens_used bigint,
cost_cents bigint,
request_id text
);
Remarque : vous pouvez stocker quota en « tokens », en « requêtes » ou en « crédits monétaires » selon votre modèle commercial.
Principe : utiliser un compteur atomique par fenêtre (sliding window ou token bucket). Exemple simplifié avec Redis INCR et TTL pour une fenêtre par minute.
const express = require('express');
const Redis = require('ioredis');
const redis = new Redis();
const app = express();
async function checkQuota(tenantId, tokensNeeded = 1) {
const key = `quota:${tenantId}:${new Date().toISOString().slice(0,16)}`; // YYYY-MM-DDTHH:MM
const current = await redis.incrby(key, tokensNeeded);
// set TTL la première fois
await redis.expire(key, 70); // ~70s pour une fenêtre minute
// récupérer quota du tenant depuis la DB (cache possible)
const tenantQuotaPerMinute = await getTenantRateLimit(tenantId); // implémenter
return current <= tenantQuotaPerMinute;
}
app.post('/api/ai', async (req, res) => {
const tenantId = req.headers['x-tenant-id'];
const tokensEstimate = estimateTokens(req.body.prompt);
const ok = await checkQuota(tenantId, tokensEstimate);
if (!ok) return res.status(429).json({error: 'quota exceeded'});
// forward to broker LLM...
});
Tips :
Le broker est responsable de :
// pseudo : vérifier réponse provider et journaliser usage
const result = await callProviderLLM(payload);
await recordUsage({tenantId, tokensUsed: result.tokens, costCents: computeCost(result.tokens)});
Calculez coût = tokens_used * price_per_token du provider + marge. Stocker une ligne llm_usage par requête permet :
Exemple d’agrégation simple (Postgres)
SELECT tenant_id, sum(tokens_used) as tokens, sum(cost_cents) as cost
FROM llm_usage
WHERE timestamp >= '2026-06-01' AND timestamp < '2026-07-01'
GROUP BY tenant_id;
Remarque : n’inventez pas les prix du provider dans votre UI ; récupérez-les via configuration ou API provider.
Quelques recommandations pratiques :
Pour contrôler les coûts LLM dans un SaaS multitenant, identifiez le tenant en entrée, estimez les tokens, appliquez un token bucket atomique (Redis) pour l’enforcement en temps réel, puis journalisez usage + coût de façon asynchrone pour la facturation.
Pour aller plus loin en architecture SaaS et intégration IA, consultez nos pages sur les services SaaS et l’intelligence artificielle.
Conclusion : implémenter une gestion de quotas LLM solide demande trois choses : identification tenant fiable, enforcement atomique et journalisation asynchrone pour la facturation. Commencez par un prototype (Redis + broker) puis industrialisez (monitoring, plans dynamiques, backoff).
Besoin d’un audit ou d’un prototype pour votre application ? Contactez-nous pour une séance de consulting.
Contactez nous pour recevoir un devis gratuitement, des réponses à vos questions ou une séance de consulting offerte avec l'un de nos experts :
