Répartition des Coûts (RAG Typique)

Pour 1M de requêtes :

• Embeddings : 100 $
• Base de données vectorielle : 200 $
• Appels LLM : 5 000 $
• Total : 5 300 $

1. Réduire les Coûts d'Embeddings

Utilisez des modèles plus petits :

DEVELOPERpython
# Avant : text-embedding-3-large
# Coût : 0,13 $ / 1M tokens
# Dimensions : 3072

# Après : text-embedding-3-small
# Coût : 0,02 $ / 1M tokens (6,5x moins cher)
# Dimensions : 1536
# Performance : -5% de précision pour la plupart des cas d'usage

import openai

embeddings = openai.Embedding.create(
    input=texts,
    model="text-embedding-3-small"  # 6.5x moins cher
)

Ou utilisez des modèles open source :

DEVELOPERpython
# Embeddings gratuits (auto-hébergés)
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('BAAI/bge-small-en-v1.5')
embeddings = model.encode(texts)  # Coût 0 $

2. Découpage Intelligent

Moins de chunks = coûts plus faibles :

DEVELOPERpython
# Avant : chunks de 500 tokens → 10 000 chunks
chunk_size = 500
# Coût embedding : 100 $
# Coût stockage : 50 $

# Après : chunks de 800 tokens → 6 250 chunks (37,5% de moins)
chunk_size = 800
# Coût embedding : 65 $ (-35%)
# Coût stockage : 32 $ (-36%)

# Compromis : Légèrement moins précis, mais économies énormes

3. Mise en Cache Agressive

Mettez tout en cache :

DEVELOPERpython
import redis
import hashlib

redis_client = redis.Redis(host='localhost', port=6379)

def cached_rag(query):
    # Vérifier le cache (90% de taux de succès → 90% d'économies)
    cache_key = f"rag:{hashlib.md5(query.encode()).hexdigest()}"
    cached = redis_client.get(cache_key)

    if cached:
        return cached.decode()  # Coût 0 $

    # Cache miss - faire le RAG complet
    response = expensive_rag_pipeline(query)

    # Stocker pendant 24 heures
    redis_client.setex(cache_key, 86400, response)

    return response

# Avec 90% de taux de succès du cache :
# Avant : 5 300 $/mois
# Après : 530 $/mois (-90%)

4. Utiliser des LLM Plus Petits

DEVELOPERpython
# Avant : GPT-4 Turbo
# Coût : 10 $/1M tokens d'entrée, 30 $/1M tokens de sortie

# Après : GPT-4o-mini
# Coût : 0,15 $/1M entrée, 0,60 $/1M sortie (60x moins cher)
# Performance : 80-90% aussi bon pour la plupart des tâches RAG

import openai

response = openai.ChatCompletion.create(
    model="gpt-4o-mini",  # 60x moins cher
    messages=[...]
)

# Ou encore moins cher : GPT-3.5 Turbo
# Coût : 0,50 $/1M entrée, 1,50 $/1M sortie

5. Réduire la Taille du Contexte

Moins de tokens au LLM = coût plus faible :

DEVELOPERpython
# Avant : Envoyer les 10 premiers docs (5000 tokens)
context = "\n\n".join(retrieve(query, k=10))
# Coût : 5000 tokens * 10 $/1M = 0,05 $ par requête

# Après : Envoyer les 3 premiers docs (1500 tokens)
context = "\n\n".join(retrieve(query, k=3))
# Coût : 1500 tokens * 10 $/1M = 0,015 $ par requête (-70%)

# Ou résumer le contexte d'abord
def compress_context(docs):
    summaries = []
    for doc in docs:
        summary = openai.ChatCompletion.create(
            model="gpt-4o-mini",  # Modèle bon marché pour la résumation
            messages=[{
                "role": "user",
                "content": f"Résume en 50 mots : {doc}"
            }]
        )
        summaries.append(summary.choices[0].message.content)

    return "\n\n".join(summaries)

6. Traitement par Lots

Traiter plusieurs requêtes ensemble :

DEVELOPERpython
# Au lieu de 1000 appels API individuels
for query in queries:
    embed(query)  # 1000 appels

# Embedding par lots
batch_embeddings = openai.Embedding.create(
    input=queries,  # Un seul appel
    model="text-embedding-3-small"
)

# Économies : Réduction de la latence overhead

7. Base de Données Vectorielle Auto-Hébergée

DEVELOPERpython
# Avant : Pinecone
# Coût : 70 $/mois pour 1M de vecteurs

# Après : Qdrant (auto-hébergé)
# Coût : 20 $/mois (droplet DigitalOcean)
# Économies : 50 $/mois (-71%)

docker run -p 6333:6333 qdrant/qdrant

8. Reranking Paresseux

Reranker uniquement quand nécessaire :

DEVELOPERpython
def smart_rerank(query, candidates):
    # Si le premier résultat a un score élevé, sauter le reranking
    if candidates[0].score > 0.9:
        return candidates[:5]  # Sauter le reranking coûteux

    # Sinon, reranker
    return rerank(query, candidates)

# Économies : 50% moins d'appels de reranking

9. Quotas Utilisateur

Prévenir les abus :

DEVELOPERpython
import time

user_quotas = {}  # {user_id: [timestamp, timestamp, ...]}

def rate_limit(user_id, max_queries=100, window=3600):
    now = time.time()

    # Supprimer les anciennes requêtes hors de la fenêtre
    if user_id in user_quotas:
        user_quotas[user_id] = [
            ts for ts in user_quotas[user_id]
            if now - ts < window
        ]
    else:
        user_quotas[user_id] = []

    # Vérifier la limite
    if len(user_quotas[user_id]) >= max_queries:
        raise Exception("Rate limit exceeded")

    # Ajouter la requête actuelle
    user_quotas[user_id].append(now)

10. Monitoring et Alertes

Suivre les coûts en temps réel :

DEVELOPERpython
import prometheus_client

# Suivre les coûts
embedding_cost = prometheus_client.Counter(
    'rag_embedding_cost_usd',
    'Total embedding API costs'
)

llm_cost = prometheus_client.Counter(
    'rag_llm_cost_usd',
    'Total LLM API costs'
)

def track_embedding_cost(tokens):
    cost = tokens / 1_000_000 * 0.02  # 0,02 $/1M tokens
    embedding_cost.inc(cost)

def track_llm_cost(input_tokens, output_tokens):
    cost = (input_tokens / 1_000_000 * 0.15) + (output_tokens / 1_000_000 * 0.60)
    llm_cost.inc(cost)

# Définir des alertes quand coût > 1000 $/jour

Optimisation Complète des Coûts

DEVELOPERpython
@cached  # 90% de succès de cache
def optimized_rag(query):
    # 1. Embeddings bon marché
    query_emb = open_source_embed(query)  # Gratuit

    # 2. Récupération efficace (moins de docs)
    docs = vector_db.search(query_emb, limit=3)  # Pas 10

    # 3. Reranking intelligent (seulement si nécessaire)
    if docs[0].score < 0.9:
        docs = fast_rerank(query, docs)  # TinyBERT, pas GPT-4

    # 4. Compresser le contexte
    context = compress_context(docs)  # 500 tokens, pas 5000

    # 5. LLM bon marché
    response = openai.ChatCompletion.create(
        model="gpt-4o-mini",  # 60x moins cher
        messages=[{
            "role": "user",
            "content": f"Context: {context}\n\nQ: {query}"
        }]
    )

    return response.choices[0].message.content

# Réduction de coût :
# - Embeddings : -100% (auto-hébergé)
# - Base vectorielle : -71% (auto-hébergé)
# - LLM : -60% (modèle plus petit)
# - Cache : -90% (moins d'appels)
# Total : ~95% de réduction de coût

Des optimisations intelligentes peuvent réduire les coûts RAG de plus de 90% sans sacrifier la qualité.