Étude de Cas : Comment une Fintech a Réduit Ses Coûts IA de 50 000 € à 5 000 €/an

Profil au démarrage du projet (octobre 2025)

• 55 collaborateurs, 7M€ d'ARR, Série A
• 42 000 documents/mois traités par des LLMs
• ~1,2M appels API LLM/mois (3 appels par document en moyenne)
• Stack : backend Python FastAPI, PostgreSQL, Redis (existant), GPT-4 Turbo + text-embedding-ada-002
• Budget infrastructure IA : 4 200 €/mois (50 400 €/an) — un des 3 premiers postes de coûts opérationnels

# ai_cost_audit.py — instrumenter les appels OpenAI existants
import json
import functools
from datetime import datetime
from openai import OpenAI

client = OpenAI()
COST_LOG = []

# Tarifs actuels (USD/1M tokens, mai 2026)
PRICING = {
    "gpt-4-turbo":            {"input": 10.00, "output": 30.00},
    "gpt-4o":                 {"input":  2.50, "output": 10.00},
    "gpt-4o-mini":            {"input":  0.15, "output":  0.60},
    "text-embedding-ada-002": {"input":  0.10, "output":  0.00},
    "claude-sonnet-4-5":      {"input":  3.00, "output": 15.00},
    "claude-haiku-4-5":       {"input":  0.80, "output":  4.00},
}

def tracked_completion(use_case: str):
    """Décorateur : entoure toute fonction appelant client.chat.completions.create"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            usage = result.usage
            model = result.model
            pricing = PRICING.get(model, {"input": 0, "output": 0})
            cost_usd = (
                usage.prompt_tokens * pricing["input"] / 1_000_000 +
                usage.completion_tokens * pricing["output"] / 1_000_000
            )
            COST_LOG.append({
                "use_case": use_case,
                "model": model,
                "timestamp": datetime.utcnow().isoformat(),
                "prompt_tokens": usage.prompt_tokens,
                "completion_tokens": usage.completion_tokens,
                "cost_usd": round(cost_usd, 6),
            })
            return result
        return wrapper
    return decorator

# Utilisation : décorer vos fonctions existantes
@tracked_completion("analyse_contrat")
def analyser_contrat(texte: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "system", "content": "Extrais les termes clés d'assurance..."},
            {"role": "user", "content": texte},
        ],
        max_tokens=600,
    )
    return response.choices[0].message.content

# Après 48h de trafic production instrumenté :
def generer_rapport():
    from collections import defaultdict
    par_cas = defaultdict(lambda: {"appels": 0, "cost_usd": 0})
    for entry in COST_LOG:
        par_cas[entry["use_case"]]["appels"] += 1
        par_cas[entry["use_case"]]["cost_usd"] += entry["cost_usd"]

    print(f"{'Cas d\'usage':<30} {'Appels':>10} {'Coût/jour':>12} {'Proj/mois':>12}")
    print("-" * 68)
    total = 0
    for cas, data in sorted(par_cas.items(), key=lambda x: -x[1]["cost_usd"]):
        mensuel = data["cost_usd"] * 30
        total += mensuel
        print(f"{cas:<30} {data['appels']:>10,} {data['cost_usd']:>11.2f}$ {mensuel:>11.2f}$")
    print(f"\n{'TOTAL PROJETÉ/MOIS':<30} {'':>10} {'':>12} {total:>11.2f}$")

Résultat de l'audit chez Nexus Finance

Après 72h de trafic production instrumenté : dépenses mensuelles projetées à 4 287 € — à 2% près du tableau de facturation. L'audit a également révélé que 18% des appels d'analyse_contrat concernaient des documents dupliqués retraités après des modifications mineures. Soit 380 €/mois de dépenses évitables.

# semantic_cache.py — cache sémantique prêt pour la production
import hashlib
import numpy as np
from redis import Redis
from redis.commands.search.field import VectorField, TextField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType
from redis.commands.search.query import Query
from openai import OpenAI

client = OpenAI()
redis_client = Redis(host="localhost", port=6379, decode_responses=False)

CACHE_INDEX = "cache_semantique"
VECTOR_DIM = 1536  # dimension ada-002
SEUIL_SIMILARITE = 0.92  # ajuster selon le cas d'usage ; 0,90-0,95 est idéal
TTL_SECONDES = 86400 * 7  # cache 7 jours

def obtenir_embedding(texte: str) -> list[float]:
    """Embedder avec ada-002 (ou swapper pour nomic-embed en local, coût zéro)."""
    response = client.embeddings.create(
        model="text-embedding-ada-002", input=texte[:8000]
    )
    return response.data[0].embedding

def cache_lookup(requete: str, cas_usage: str) -> str | None:
    """Retourne la réponse en cache si similarité >= seuil, sinon None."""
    embedding = obtenir_embedding(requete)
    q = (
        Query("*=>[KNN 1 @embedding $vec AS score]")
        .sort_by("score")
        .return_fields("reponse", "score", "cas_usage")
        .dialect(2)
    )
    results = redis_client.ft(CACHE_INDEX).search(
        q,
        query_params={"vec": np.array(embedding, dtype=np.float32).tobytes()}
    )
    if results.docs:
        doc = results.docs[0]
        # Redis COSINE retourne une distance (plus bas = plus similaire)
        similarite = 1 - float(doc.score)
        if similarite >= SEUIL_SIMILARITE and doc.cas_usage == cas_usage:
            return doc.reponse
    return None

def cache_store(requete: str, cas_usage: str, reponse: str) -> None:
    """Stocker une paire requête-réponse dans le cache."""
    embedding = obtenir_embedding(requete)
    key = f"cache:{hashlib.sha256(requete.encode()).hexdigest()}"
    redis_client.hset(key, mapping={
        "requete": requete,
        "cas_usage": cas_usage,
        "reponse": reponse,
        "embedding": np.array(embedding, dtype=np.float32).tobytes(),
    })
    redis_client.expire(key, TTL_SECONDES)

# Utilisation dans votre pipeline existant :
def analyser_contrat_cache(texte: str) -> str:
    cached = cache_lookup(texte, "analyse_contrat")
    if cached:
        return cached  # 0 coût API, ~2ms

    response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "system", "content": "Extrais les termes clés d'assurance..."},
            {"role": "user", "content": texte},
        ],
        max_tokens=600,
    ).choices[0].message.content

    cache_store(texte, "analyse_contrat", response)
    return response

# litellm_router.py — routage intelligent par complexité
# pip install litellm
import litellm

MODELES = {
    "rapide":   "ollama/mistral:7b-instruct-q4_K_M",  # auto-hébergé
    "standard": "anthropic/claude-haiku-4-5-20251001",
    "premium":  "anthropic/claude-sonnet-4-5",
}

MOTS_RAISONNEMENT = {"comparer", "analyser", "pourquoi", "arbitrage", "recommander", "risque"}

def scorer_complexite(prompt: str, max_output_tokens: int, pages_doc: int = 1) -> float:
    score = 0.0
    if max_output_tokens > 400:
        score += 2.0
    if pages_doc > 5:
        score += 1.5
    if any(kw in prompt.lower() for kw in MOTS_RAISONNEMENT):
        score += 3.0
    if "json" in prompt.lower() or "extraire" in prompt.lower():
        score -= 0.5  # tâche plus simple
    return score

def router(prompt: str, max_tokens: int = 200, pages_doc: int = 1) -> str:
    score = scorer_complexite(prompt, max_tokens, pages_doc)
    if score < 1.5:
        return MODELES["rapide"]
    elif score < 4.0:
        return MODELES["standard"]
    return MODELES["premium"]

def appeler_llm(systeme: str, utilisateur: str, max_tokens: int = 200, pages: int = 1) -> str:
    modele = router(utilisateur, max_tokens, pages)
    response = litellm.completion(
        model=modele,
        messages=[
            {"role": "system", "content": systeme},
            {"role": "user", "content": utilisateur},
        ],
        max_tokens=max_tokens,
    )
    return response.choices[0].message.content

# Exemple : la classification route vers Mistral (rapide), l'analyse vers Sonnet (premium)
type_contrat = appeler_llm(
    systeme="Classifie ce document. Réponds uniquement : auto, santé, RC, habitation, autre.",
    utilisateur=texte_contrat,
    max_tokens=10,
    pages=1,
)  # → Mistral 7B, ~0 €

lacunes = appeler_llm(
    systeme="Analyse ce contrat multi-polices. Identifie les lacunes de couverture.",
    utilisateur=texte_contrat_complet,
    max_tokens=800,
    pages=42,
)  # → Claude Sonnet (premium)

Guide de dimensionnement matériel

• <50 000 requêtes/mois : VPS CPU (4 vCPU, 16 Go RAM) — Mistral 7B Q4, 20-35 €/mois, ~8 tok/s
• 50 000–500 000 requêtes/mois : RTX 4090 unique (Hetzner AX61) — 45-65 €/mois, ~80 tok/s
• >500 000 requêtes/mois : 2× RTX 4090 (Hetzner AX102) — 89-109 €/mois, ~160 tok/s
• Seuil de rentabilité vs GPT-4o mini : 100 000+ requêtes/mois avec 500 tokens de sortie en moyenne

# batch_processor.py — API Batch OpenAI (50% moins cher, délai 24h)
import json
import time
from pathlib import Path
from openai import OpenAI

client = OpenAI()

def creer_job_batch(documents: list[dict]) -> str:
    """
    documents: [{"id": "doc_001", "texte": "...", "cas": "resume_email"}]
    Retourne l'ID du job batch.
    """
    requests = []
    for doc in documents:
        requests.append({
            "custom_id": doc["id"],
            "method": "POST",
            "url": "/v1/chat/completions",
            "body": {
                "model": "gpt-4o-mini",  # 50% du tarif mini déjà économique
                "messages": [
                    {"role": "system", "content": "Résume cet email en 2 phrases."},
                    {"role": "user", "content": doc["texte"][:4000]},
                ],
                "max_tokens": 150,
            }
        })

    jsonl_path = Path("/tmp/requetes_batch.jsonl")
    with open(jsonl_path, "w") as f:
        for req in requests:
            f.write(json.dumps(req, ensure_ascii=False) + "\n")

    with open(jsonl_path, "rb") as f:
        fichier_batch = client.files.create(file=f, purpose="batch")

    job = client.batches.create(
        input_file_id=fichier_batch.id,
        endpoint="/v1/chat/completions",
        completion_window="24h",
    )
    print(f"Job batch créé : {job.id}")
    return job.id

# Cron nocturne pour les documents non urgents de la veille
# Économies Nexus Finance : 310 €/mois → 155 €/mois

Appliquer ces techniques à votre infrastructure

Notre formation Optimisation Infrastructure IA couvre la configuration LiteLLM, le déploiement Ollama, le cache sémantique et la modélisation des coûts — avec vos données de charge réelles.

🇬🇧 Read in English