Cinq techniques pour réduire tes coûts d’IA de 70–80 %

Les lignes de coût des fonctionnalités d’IA sur les tableaux de bord financiers ont une propriété amusante : elles croissent de façon non linéaire avec le trafic et empirent à mesure que ton produit gagne en popularité. Voici les cinq techniques au plus fort levier que nous avons vues réellement faire bouger l’aiguille, avec du code exécutable pour chacune.

Exemple chiffré : un produit de chat qui fait 100K appels/jour à une moyenne de 3K tokens d’entrée / 500 de sortie sur Claude Sonnet 4.6 dépense environ 4 500 $/mois en direct. La même charge avec les cinq techniques ci-dessous se stabilise généralement autour de 900–1 200 $/mois — une coupe de 70–80 % sans dégrader sensiblement la qualité de sortie.

1. Cache de prompt — le levier le plus puissant à lui seul

Si ton prompt système ou ton bloc de contexte dépasse les ~2K tokens et qu’il est réutilisé d’un appel à l’autre, tu paies trop cher. Anthropic et Google facturent tous deux l’entrée cachée à environ 0,1×–0,2× de l’entrée normale — une économie de 5–10× sur chaque appel une fois le cache chaud. Brievio répercute l’intégralité de l’économie et fait tourner un routeur à affinité qui maintient les prompts répétés sur le même nœud amont, pour que le cache reste vivant même à faible concurrence.

Consulte /docs/caching pour le guide complet.

import anthropic

client = anthropic.Anthropic(
    api_key="sk-brievio-...",
    base_url="https://api.brievio.com",
)

# Marque les parties longues et statiques du prompt comme cachables. Le prochain
# appel avec le même préfixe touche le cache d'Anthropic — 10 % du coût.
resp = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "<<ton prompt système de 20K tokens — schéma, règles, exemples>>",
            "cache_control": {"type": "ephemeral"},   # marque comme cachable
        },
    ],
    messages=[{"role": "user", "content": "Dernière question…"}],
)

Économie attendue : 40–70 % sur le coût d’entrée pour les charges à long prompt système. Souvent la plus grosse amélioration à elle seule.

2. Étagement des modèles — ne paie pas une capacité que tu n’utilises pas

Le modèle raisonnable le moins cher qui produit encore une sortie acceptable l’emporte. La plupart des charges LLM ont une distribution de difficulté à longue traîne — la tâche moyenne de classification ou de résumé n’a pas besoin d’Opus.

Construis une estimation de difficulté simple (heuristique, classifieur, ou Haiku lui-même qui fait le tri) et route en conséquence. Sur plus de 50 comptes Brievio, nous avons vu cela à lui seul réduire les coûts de chat de 40–60 %.

def pick_model(task_difficulty: int) -> str:
    """
    Le modèle le moins cher qui reste assez bon l'emporte.
    Choisis selon la difficulté perçue, puis valide par la qualité de sortie.
    """
    if task_difficulty <= 2:
        return "claude-haiku-4-5"     # ~10x moins cher qu'Opus
    if task_difficulty <= 4:
        return "gemini-2.5-flash"       # très solide, encore moins cher en sortie
    if task_difficulty <= 7:
        return "claude-sonnet-4-6"
    return "claude-opus-4-7"          # uniquement quand c'est vraiment nécessaire

Économie attendue : 40–60 % sur les charges de type chat dès qu’une part significative est routée vers Haiku / Gemini Flash.

3. Plafonds de sortie et limites de dépense

Les tokens de sortie coûtent à peu près 5× plus cher que ceux d’entrée. Un bug qui laisse un prompt demander une réponse de 16K tokens dans une boucle serrée, c’est comme ça qu’on dépense 400 $ par accident en une après-midi. Défends les deux couches — le max_tokens par appel, et la limite de dépense au niveau du portefeuille dans le tableau de bord.

# Double plafond : max_tokens par appel, plus un plafond de portefeuille ferme sur la clé.
resp = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[...],
    max_tokens=800,       # plafonne la sortie par appel
    stop=["</answer>"],   # coupe à un terminateur connu
)

# Dans le tableau de bord Brievio : /app/keys → règle la « Limite de dépense » sur chaque clé.
# Clé de production : 50 $/jour. Clé d'expérimentation : 5 $/jour. Clé de CI : 1 $/jour.

Sur Brievio : /app/keys te laisse fixer un plafond par clé et par jour. Les clés de CI/test à 1 $/jour empêchent les scripts qui s’emballent ; les clés de production peuvent rester généreuses.

4. Parallélisme — concurrent ≠ plus cher

Les appels séquentiels n’économisent pas d’argent par rapport aux appels parallèles — mais ils gaspillent du temps réel, ce qui se « résout » souvent en donnant au LLM plus de contexte ou un modèle plus gros. Lance les appels indépendants en parallèle ; termine plus vite ; descends d’un étage.

# Ne paie pas un raisonnement séquentiel quand N tâches sont indépendantes.
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key=os.environ["BRIEVIO_API_KEY"],
    base_url="https://api.brievio.com/v1",
)

async def classify_one(text: str) -> str:
    resp = await client.chat.completions.create(
        model="claude-haiku-4-5",     # parallèle + bon marché = gagnant
        messages=[{"role": "user", "content": f"Classify: {text}"}],
        max_tokens=20,
    )
    return resp.choices[0].message.content

results = await asyncio.gather(*(classify_one(t) for t in batch))

Économie attendue : indirecte — généralement 10–20 % en évitant le piège du « on passe à un modèle plus gros pour aller plus vite ».

5. Des retries qui ne facturent pas deux fois

Sur Brievio, les requêtes échouées (4xx, 5xx) ne sont jamais facturées — mais seul l’appel qui échoue est gratuit. Si ta logique de retry se déclenche à chaque accroc passager sans backoff, tu peux multiplier le coût par 2–3× lors d’une mauvaise journée côté amont. Respecte Retry-After, distingue les 4xx (ton bug) des 5xx (passager), plafonne les tentatives.

from openai import APIError, RateLimitError
import time, random

def call_with_backoff(client, **kwargs):
    for attempt in range(5):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError as e:
            # Respecte Retry-After quand il est présent.
            ra = getattr(e, "retry_after", None) or (2 ** attempt + random.random())
            time.sleep(min(ra, 30))
        except APIError as e:
            if 500 <= e.status_code < 600:
                time.sleep(2 ** attempt + random.random())
                continue
            raise           # 4xx — ton bug, pas un souci passager
    raise RuntimeError("exhausted retries")

Consulte /docs/errors pour les règles de retry complètes.

L’effet cumulé

Chaque technique appliquée seule donne une coupe modeste. Empilées, elles se composent : 50 % de moins grâce au cache × 50 % de moins grâce à l’étagement × 10 % de moins grâce au plafonnement = 22 % du coût initial = 78 % d’économie. C’est la différence entre une IA qui est un poste de budget et une IA qui contribue à la marge en production.

La tarification de Brievio elle-même — chaque modèle ~15 % sous le tarif catalogue officiel, facturé sur les vrais décomptes de tokens — est un multiplicateur uniforme par-dessus les cinq techniques. La façon la plus intelligente de faire tourner de l’IA de pointe en 2026, c’est : choisir des modèles authentiques sur une infrastructure qui tient debout, puis en extraire les bonnes techniques. Les deux couches comptent.

Tu veux une lecture gratuite de ton usage actuel pour voir où se trouve le levier ? Écris à contact@brievio.com avec une description sommaire et nous ferons l’analyse.