Production : mise à l'échelle et mise en cache
På denna sida
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ément | Description |
|---|---|
| Cache Redis | Réduit les appels API et la latence |
| Réessai exponentiel | Gère les limites de débit avec souplesse |
| Surveillance | Suit le taux de succès du cache, la latence, les erreurs |
| Traitement par lots | Traite de grands volumes en lots asynchrones |
| Quantification | Réduit le stockage par 4 avec int8 |
| Réduction de dimension | Utilise 1024 ou 512 dims si la qualité le permet |
| Sauvegarde | Sauvegarde régulièrement les embeddings et métadonnées |
| Alertes | Alerte 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.