Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Production : mise à l'échelle et mise en cache

Lektion 22 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Objectifs
  2. Défis de la production
  3. Mise en cache des embeddings
  4. Gestion des limites de débit
  5. Traitement asynchrone
  6. Optimisation du stockage
  7. Architecture de production
  8. Checklist de production
  9. Viktiga punkter
  10. Teste tes connaissances

Objectifs

  • Optimiser les performances d’un système d’embeddings en production
  • Mettre en œuvre la mise en cache pour réduire les coûts et la latence
  • Gérer la mise à l’échelle et la haute disponibilité

Défis de la production

Pendant le développement, appeler l’API OpenAI pour chaque requête ne pose pas de problème : tu fais peut-être dix appels par jour. En production, ce même code se heurte simultanément à trois murs. Premièrement, le coût : chaque appel est facturé, et un ré-indexage complet d’un corpus est payé intégralement à chaque exécution. Deuxièmement, la latence : un aller-retour réseau de 100 à 300 ms par requête s’ajoute au temps de recherche et de génération, et l’utilisateur ressent la somme des trois. Enfin, les limites de débit : OpenAI limite le nombre d’appels par minute, une limite que tu ne verras jamais en développement mais que tu atteindras le jour du lancement.

Ces trois problèmes ont globalement la même solution : n’appelle pas l’API quand ce n’est pas nécessaire.

Mise en cache des embeddings

Un embedding est déterministe : le même texte avec le même modèle renvoie toujours le même vecteur. Cela rend la mise en cache très efficace ici, bien plus que pour un LLM génératif. Pour une application avec un trafic modéré, le décorateur lru_cache de la bibliothèque standard suffit et ne prend que deux lignes. La valeur de retour est convertie en tuple car lru_cache exige des valeurs hachables ; c’est la seule subtilité à connaître.

from functools import lru_cache
from openai import OpenAI
import hashlib
import json

client = OpenAI()

@lru_cache(maxsize=10_000)
def embedding_cache(text: str, model: str = "text-embedding-3-large") -> tuple:
    """Cache LRU pour les embeddings (tuple car hachable)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Utilisation - le 2e appel est instantané
emb1 = embedding_cache("Hello world")  # Appel API
emb2 = embedding_cache("Hello world")  # Depuis le cache

Ce cache disparaît à tout redémarrage et n’est pas partagé entre les processus : dès que tu lances deux instances derrière un équilibreur de charge, chacune reconstruit la sienne. Redis résout ces deux problèmes. La clé est un hachage de la paire modèle-texte, ce qui empêche qu’un changement de modèle ne serve d’anciens vecteurs, et un TTL de trente jours limite la croissance du stockage.

La méthode get_embeddings_batch mérite une attention particulière, car c’est elle qui fait la différence lors de l’ingestion. Elle ne vérifie pas simplement le cache texte par texte : elle sépare les échecs (misses), les envoie en un seul appel API, puis réinsère chaque résultat à sa position d’origine en utilisant indices_a_calculer. Sur un lot de mille documents dont neuf cents sont déjà connus, tu passes d’un appel par document à un seul appel pour les cent restants.

import redis
import numpy as np
import json

class EmbeddingCacheRedis:
    def __init__(self, redis_url: str = "redis://localhost:6379"):
        self.redis = redis.from_url(redis_url)
        self.client = OpenAI()
        self.ttl = 86400 * 30  # 30 jours

    def _cache_key(self, text: str, model: str) -> str:
        h = hashlib.md5(f"{model}:{text}".encode()).hexdigest()
        return f"emb:{h}"

    def get_embedding(
        self, text: str, model: str = "text-embedding-3-large"
    ) -> list[float]:
        key = self._cache_key(text, model)

        # Vérifier le cache
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Générer et mettre en cache
        response = self.client.embeddings.create(
            input=text, model=model
        )
        embedding = response.data[0].embedding

        self.redis.setex(key, self.ttl, json.dumps(embedding))
        return embedding

    def get_embeddings_batch(
        self, texts: list[str], model: str = "text-embedding-3-large"
    ) -> list[list[float]]:
        """Lot avec mise en cache partielle."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Vérifier le cache pour chaque texte
        for i, text in enumerate(texts):
            key = self._cache_key(text, model)
            cached = self.redis.get(key)
            if cached:
                results[i] = json.loads(cached)
            else:
                to_calculate.append(text)
                indices_to_calculate.append(i)

        # Calculer les manquants en un seul appel
        if to_calculate:
            response = self.client.embeddings.create(
                input=to_calculate, model=model
            )
            for resp_item in sorted(response.data, key=lambda x: x.index):
                idx = indices_to_calculate[resp_item.index]
                text = to_calculate[resp_item.index]
                embedding = resp_item.embedding

                results[idx] = embedding
                key = self._cache_key(text, model)
                self.redis.setex(key, self.ttl, json.dumps(embedding))

        print(f"Cache : {len(texts) - len(to_calculate)}/{len(texts)} succès")
        return results

# Utilisation
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("test de cache")

Gestion des limites de débit

La mise en cache réduit le trafic mais ne l’élimine pas, et un pic de trafic finira par déclencher une RateLimitError. La bonne réponse n’est pas de réessayer immédiatement, ce qui aggrave la congestion, mais d’attendre en doublant le délai à chaque fois : une seconde, deux, quatre, huit, seize. Cinq tentatives couvrent ainsi environ trente secondes, ce qui absorbe la grande majorité des pics temporaires, et la dernière tentative relance l’exception afin que l’incident soit signalé au lieu d’être silencieusement ignoré.

import time
from openai import RateLimitError

class RobustEmbeddingClient:
    def __init__(self, max_retries: int = 5):
        self.client = OpenAI()
        self.max_retries = max_retries

    def create(
        self, input: str | list[str], model: str = "text-embedding-3-large",
        **kwargs
    ):
        """Appel avec réessai exponentiel."""
        for attempt in range(self.max_retries):
            try:
                return self.client.embeddings.create(
                    input=input, model=model, **kwargs
                )
            except RateLimitError as e:
                if attempt == self.max_retries - 1:
                    raise
                wait = 2 ** attempt
                print(f"Limite de débit atteinte, pause de {wait}s...")
                time.sleep(wait)

Traitement asynchrone

Pour les pipelines d’ingestion, le goulot d’étranglement n’est pas le calcul mais l’attente réseau : ton programme passe la majeure partie de son temps à ne rien faire. Le traitement asynchrone te permet de maintenir plusieurs requêtes en cours. Le sémaphore limite intentionnellement ce parallélisme, car lancer cent appels simultanés ne fait que déclencher les limites de débit que tu viens d’apprendre à gérer ; trois à cinq requêtes concurrentes constituent un réglage sain. Les textes sont d’abord divisés en lots de cent, et l’index de départ de chaque lot voyage avec la tâche afin que as_completed, qui renvoie les résultats dans le désordre, puisse toujours les placer correctement.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def generate_embeddings_async(
    texts: list[str],
    model: str = "text-embedding-3-large",
    max_concurrent: int = 5
) -> list[list[float]]:
    """Générer des embeddings en parallèle avec un sémaphore."""
    semaphore = asyncio.Semaphore(max_concurrent)
    results = [None] * len(texts)

    async def process_batch(batch_idx, batch):
        async with semaphore:
            response = await async_client.embeddings.create(
                input=batch, model=model
            )
            return batch_idx, [
                d.embedding
                for d in sorted(response.data, key=lambda x: x.index)
            ]

    # Diviser en lots de 100
    tasks = []
    batch_size = 100
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        tasks.append(process_batch(i, batch))

    for coro in asyncio.as_completed(tasks):
        batch_idx, embeddings = await coro
        for j, emb in enumerate(embeddings):
            results[batch_idx + j] = emb

    return results

# Utilisation
embeddings = asyncio.run(
    generate_embeddings_async(my_texts, max_concurrent=3)
)

Optimisation du stockage

Il y a ensuite la facture d’infrastructure. Dix mille vecteurs de 3 072 dimensions en float32 occupent environ 122 Mo ; un million en occupe douze gigaoctets, qui doivent être maintenus en mémoire pour que la recherche reste rapide. La quantification en int8 mappe chaque coordonnée sur 256 valeurs entières, divisant l’empreinte par quatre pour atteindre environ 30 Mo dans l’exemple ci-dessous. La perte de précision existe mais reste marginale par rapport aux écarts de similarité avec lesquels tu travailles.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Quantifier les embeddings en int8 (4x moins de mémoire)."""
    min_val = embeddings.min(axis=1, keepdims=True)
    max_val = embeddings.max(axis=1, keepdims=True)
    scale = (max_val - min_val) / 255.0

    quantized = ((embeddings - min_val) / scale).astype(np.int8)
    return quantized, min_val, scale

def dequantize_int8(quantized, min_val, scale):
    """Restaurer les embeddings depuis int8."""
    return quantized.astype(np.float32) * scale + min_val

# Comparaison de taille
embeddings = np.random.randn(10000, 3072).astype(np.float32)
print(f"float32 : {embeddings.nbytes / 1e6:.1f} MB")  # ~122 MB

quantized, min_val, scale = quantize_int8(embeddings)
print(f"int8 :    {quantized.nbytes / 1e6:.1f} MB")    # ~30 MB

Cependant, le levier le plus simple reste le paramètre dimensions de l’API, qui produit directement des vecteurs plus courts sans aucun post-traitement de ta part : 3 072 dimensions pèsent environ 24 Ko par vecteur, 1 024 dimensions descendent à 8 Ko, et 256 dimensions à 2 Ko.

# 3072 dim -> ~24 Ko par vecteur
# 1024 dim -> ~8 Ko par vecteur  (réduction API)
# 256 dim  -> ~2 Ko par vecteur  (réduction API)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3x moins de stockage
)

Architecture de production

Assemblés, ces éléments donnent un pipeline léger : cache Redis devant, client robuste pour les appels qui passent quand même. L’ingestion emprunte la voie par lots, la recherche met en cache même l’embedding de la requête, et ce dernier point n’est pas trivial, car les requêtes utilisateurs se répètent bien plus que tu ne l’imagines.

class ProductionPipeline:
    """Pipeline RAG optimisé pour la production."""

    def __init__(self):
        self.cache = EmbeddingCacheRedis()
        self.robust_client = RobustEmbeddingClient()

    def ingest(self, documents: list[dict]):
        """Ingestion avec cache et réessai."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Stocker dans la base de données vectorielle...

    def search(self, query: str, k: int = 5):
        """Recherche avec mise en cache de la requête."""
        query_emb = self.cache.get_embedding(query)
        # Recherche dans la base de données vectorielle...
        return query_emb

Checklist de production

ÉlémentDescription
Cache RedisRéduit les appels API et la latence
Réessai exponentielGère les limites de débit avec souplesse
SurveillanceSuit le taux de succès du cache, la latence, les erreurs
Traitement par lotsTraite de grands volumes en lots asynchrones
QuantificationRéduit le stockage par 4 avec int8
Réduction de dimensionUtilise 1024 ou 512 dims si la qualité le permet
SauvegardeSauvegarde régulièrement les embeddings et métadonnées
AlertesAlerte en cas d’erreurs API et de dégradation des performances

Deux lignes de ce tableau n’apportent aucun gain de performance mais sont les plus importantes. Surveiller le taux de succès du cache est ton indicateur de santé économique : s’il s’effondre, ta facture triple avant que quiconque ne s’en aperçoive. Et sauvegarder les embeddings t’évite, le jour d’un incident, de devoir repayer et attendre à nouveau l’encodage complet du corpus.

Viktiga punkter

  • Le cache Redis réduit les coûts et la latence de plus de 90 %
  • Le réessai exponentiel gère les limites de débit d’OpenAI
  • Le traitement asynchrone accélère l’ingestion de grands corpus
  • La quantification int8 réduit le stockage par 4
  • La réduction de dimension au niveau de l’API est le levier le plus simple

Teste tes connaissances

Vingt-deux leçons sur les embeddings et le RAG : l’essentiel tient en cinq questions.

1. Que capture un embedding et comment comparons-nous deux textes ?

Réponse : Un vecteur qui encode le sens : deux textes proches en sens ont des vecteurs proches ; la similarité cosinus mesure cette proximité, quels que soient les mots exacts utilisés.

2. Pourquoi combiner recherche sémantique et lexicale ?

Réponse : Le sémantique comprend les reformulations mais rate les termes exacts (références, identifiants) ; le lexical fait l’inverse ; l’hybride couvre les deux angles morts et fusionne par rang.

3. Quel est le rôle du découpage (chunking) dans la qualité du RAG ?

Réponse : Décisif : des segments qui respectent les frontières des idées produisent une recherche précise ; des coupures arbitraires génèrent des fragments incomplets, et tout le pipeline hérite de ce défaut.

4. Recherche de fichiers intégrée ou RAG personnalisé : comment choisir ?

Réponse : La recherche de fichiers pour avancer vite avec un pipeline géré (découpage et classement intégrés) ; le RAG personnalisé quand tu dois contrôler le fractionnement, les index, le reclassement ou plusieurs sources.

5. Au-delà de la recherche, nomme deux utilisations des embeddings.

Réponse : Classification et clustering (regroupement automatique de textes similaires), recommandations personnalisées, ou détection d’anomalies et de doublons ; même vecteur, différentes distances.

Le fil conducteur du cours : le sens devient mesurable ; recherche, classement, recommandation ne sont que des applications. La production (mise à l’échelle, mise en cache) fait le reste.