Productie: Schalen en Cachen
Op deze pagina
Doelstellingen
- De prestaties van een embedding-systeem in productie optimaliseren
- Caching implementeren om kosten en latentie te verlagen
- Schaling en hoge beschikbaarheid beheren
Uitdagingen in productie
Tijdens de ontwikkeling is het geen probleem om voor elk verzoek de OpenAI API aan te roepen: u doet dit misschien tien keer per dag. In productie loopt diezelfde code echter tegen drie muren tegelijk. Ten eerste kosten: elk verzoek wordt gefactureerd, en een volledige herindexering van een corpus wordt elke keer dat deze draait volledig betaald. Ten tweede latentie: een netwerkrondreis van 100 tot 300 ms per verzoek telt op bij de zoektijd en de generatietijd, en de gebruiker voelt de som van alle drie. Tot slot rate limits: OpenAI limiteert het aantal oproepen per minuut—een limiet die u tijdens de ontwikkeling nooit zult zien, maar waar u op de lanceringsdag tegenaan loopt.
Alle drie de problemen hebben grotendeels dezelfde oplossing: roep de API niet aan als dat niet nodig is.
Embeddings cachen
Een embedding is deterministisch: dezelfde tekst met hetzelfde model levert altijd dezelfde vector op. Dit maakt cachen hier uiterst effectief, veel meer dan bij een generatieve LLM. Voor een applicatie met matig verkeer is de lru_cache decorator van de standaardbibliotheek voldoende en kost dit slechts twee regels code. De retourwaarde wordt omgezet naar een tuple omdat lru_cache hashbare waarden vereist; dat is het enige addertje onder het gras.
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:
"""LRU cache voor embeddings (tuple omdat deze hashbaar is)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Gebruik - de 2e oproep is direct
emb1 = embedding_cache("Hello world") # API-oproep
emb2 = embedding_cache("Hello world") # Uit cache
Deze cache verdwijnt bij elke herstart en wordt niet gedeeld tussen processen: zodra u twee instanties achter een load balancer draait, bouwt elk zijn eigen cache opnieuw op. Redis lost beide problemen op. De sleutel is een hash van het model-tekst-paar, wat voorkomt dat een modelwijziging oude vectors serveert, en een TTL van dertig dagen beperkt de opslaggroei.
De methode get_embeddings_batch verdient nauwkeurige aandacht, aangezien dit het verschil maakt tijdens de ingestie. Deze controleert de cache niet tekst voor tekst: deze scheidt de misses, verzendt ze in één enkele API-oproep en voegt vervolgens elk resultaat opnieuw in op zijn oorspronkelijke positie met behulp van indices_a_calculer. Bij een batch van duizend documenten waarvan er negenhonderd al bekend zijn, gaat u van één oproep per document naar één enkele oproep voor de overige honderd.
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 dagen
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)
# Cache controleren
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Genereren en cachen
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]]:
"""Batch met gedeeltelijke caching."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Cache controleren voor elke tekst
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)
# Misses berekenen in één enkele oproep
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)} hits")
return results
# Gebruik
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Omgaan met rate limits
Caching vermindert het verkeer maar elimineert het niet, en een piek in het verkeer zal uiteindelijk een RateLimitError activeren. De juiste reactie is niet om direct opnieuw te proberen—dit verergert de congestie—maar om te wachten en de vertraging elke keer te verdubbelen: één seconde, twee, vier, acht, zestien. Vijf pogingen dekken zo ongeveer dertig seconden, wat de overgrote meerderheid van tijdelijke pieken opvangt, en de laatste poging gooit de uitzondering opnieuw zodat het incident wordt gerapporteerd in plaats van stilzwijgend te worden genegeerd.
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
):
"""Oproep met exponentiële retry."""
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"Rate limit bereikt, pauzeren voor {wait}s...")
time.sleep(wait)
Asynchrone verwerking
Voor ingestie-pipelines is de bottleneck niet de berekening, maar het wachten op het netwerk: uw programma besteedt het grootste deel van zijn tijd aan niets doen. Asynchrone verwerking stelt u in staat om meerdere verzoeken gelijktijdig uit te voeren. De semaphore limiteert dit parallelisme bewust, omdat het lanceren van honderd gelijktijdige oproepen alleen maar de rate limits activeert die u zojuist hebt leren behandelen—drie tot vijf gelijktijdige verzoeken is een gezonde instelling. Teksten worden eerst opgesplitst in batches van honderd, en de startindex van elke batch reist mee met de taak zodat as_completed, dat resultaten in willekeurige volgorde retourneert, ze toch correct kan plaatsen.
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]]:
"""Embeddings parallel genereren met een semaphore."""
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)
]
# Opsplitsen in batches van 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
# Gebruik
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Opslag optimaliseren
Dan is er nog de infrastructuurfactuur. Tienduizend vectors van 3.072 dimensies in float32 nemen ongeveer 122 MB in beslag; een miljoen neemt twaalf gigabyte in beslag, wat in het geheugen moet worden gehouden om snel zoeken mogelijk te maken. Kwantisatie naar int8 brengt elke coördinaat in kaart naar 256 gehele waarden, wat de voetafdruk in het onderstaande voorbeeld met een factor vier verkleint tot ongeveer 30 MB. Het precisieverlies bestaat, maar blijft marginaal in vergelijking met de similariteitsverschillen waarmee u werkt.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Embeddings kwantiseren naar int8 (4x minder geheugen)."""
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):
"""Embeddings herstellen vanuit int8."""
return quantized.astype(np.float32) * scale + min_val
# Groottevergelijking
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
De eenvoudigste hefboom blijft echter de dimensions-parameter van de API, die direct kortere vectors produceert zonder enige nabewerking aan uw kant: 3.072 dimensies wegen ongeveer 24 KB per vector, 1.024 dimensies dalen naar 8 KB, en 256 dimensies naar 2 KB.
# 3072 dim -> ~24 KB per vector
# 1024 dim -> ~8 KB per vector (API-reductie)
# 256 dim -> ~2 KB per vector (API-reductie)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3x minder opslag
)
Productie-architectuur
Samengevoegd geven deze onderdelen een slanke pipeline: Redis-cache vooraan, robuuste client voor oproepen die er toch doorheen komen. Ingestie volgt de batch-route, zoeken cachet zelfs de query-embedding—en dat laatste punt is niet triviaal, omdat gebruikersquery’s zich veel vaker herhalen dan u zou denken.
class ProductionPipeline:
"""RAG-pipeline geoptimaliseerd voor productie."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Ingestie met cache en retry."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Opslaan in vector-database...
def search(self, query: str, k: int = 5):
"""Zoeken met query-caching."""
query_emb = self.cache.get_embedding(query)
# Zoeken in vector-database...
return query_emb
Productie-checklist
| Element | Beschrijving |
|---|---|
| Redis Cache | API-oproepen en latentie verminderen |
| Exponentiële Retry | Rate limits elegant afhandelen |
| Monitoring | Cache hit rate, latentie en fouten bijhouden |
| Batchverwerking | Grote volumes verwerken in asynchrone batches |
| Kwantisatie | Opslag met factor 4 verkleinen met int8 |
| Dimensiereductie | 1024 of 512 dimensies gebruiken als kwaliteit het toelaat |
| Backup | Regelmatig back-ups maken van embeddings en metadata |
| Alerting | Waarschuwen bij API-fouten en prestatieverlies |
Twee regels in deze tabel leveren geen prestatiewinst op, maar zijn wel het belangrijkst. Het monitoren van de cache hit rate is uw economische gezondheidsindicator: als deze instort, verdrievoudigt uw factuur voordat iemand het merkt. En het back-uppen van embeddings bespaart u, op de dag van een incident, de noodzaak om de volledige codering van het corpus opnieuw te betalen en opnieuw te moeten wachten.
Belangrijkste punten
- Redis-cache verlaagt kosten en latentie met meer dan 90%
- Exponentiële retry handelt OpenAI rate limits af
- Asynchrone verwerking versnelt ingestie van grote corpora
- int8-kwantisatie verkleint opslag met factor 4
- Dimensiereductie via de API is de eenvoudigste hefboom
Test uw kennis
Tweeëntwintig lessen over embeddings en RAG: de essentie past in vijf vragen.
1. Wat legt een embedding vast, en hoe vergelijken we twee teksten?
Antwoord: Een vector die betekenis codeert: twee teksten die qua betekenis dicht bij elkaar liggen, hebben dicht bij elkaar liggende vectors—cosinus-similariteit meet deze nabijheid, ongeacht de exacte gebruikte woorden.
2. Waarom semantisch en lexicografisch zoeken combineren?
Antwoord: Semantisch begrijpt herformuleringen maar mist exacte termen (referenties, identifiers); lexicografisch doet het omgekeerde—de hybride aanpak dekt beide blinde vlekken en voegt samen op basis van rangorde.
3. Wat is de rol van chunking in de RAG-kwaliteit?
Antwoord: Doorslaggevend: segmenten die ideegrenzen respecteren, produceren nauwkeurig zoeken; willekeurige sneden genereren onvolledige fragmenten—en de hele pipeline erft dit over.
4. Geïntegreerd File Search of aangepaste RAG: hoe kiezen?
Antwoord: File Search om snel te werken met een beheerde pipeline (geïntegreerde chunking en ranking); aangepaste RAG wanneer u controle nodig heeft over splitsen, indexen, reranking of meerdere bronnen.
5. Noem, naast zoeken, twee toepassingen voor embeddings.
Antwoord: Classificatie en clustering (automatisch groeperen van vergelijkbare teksten), gepersonaliseerde aanbevelingen, of detectie van anomalieën en duplicaten—dezelfde vector, verschillende afstanden.
De rode draad van de cursus: betekenis wordt meetbaar—zoeken, ranking en aanbeveling zijn slechts toepassingen. Productie (schaling, caching) doet de rest.