Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Productie: Schalen en Cachen

Les 22 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Uitdagingen in productie
  3. Embeddings cachen
  4. Omgaan met rate limits
  5. Asynchrone verwerking
  6. Opslag optimaliseren
  7. Productie-architectuur
  8. Productie-checklist
  9. Belangrijkste punten
  10. Test uw kennis

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

ElementBeschrijving
Redis CacheAPI-oproepen en latentie verminderen
Exponentiële RetryRate limits elegant afhandelen
MonitoringCache hit rate, latentie en fouten bijhouden
BatchverwerkingGrote volumes verwerken in asynchrone batches
KwantisatieOpslag met factor 4 verkleinen met int8
Dimensiereductie1024 of 512 dimensies gebruiken als kwaliteit het toelaat
BackupRegelmatig back-ups maken van embeddings en metadata
AlertingWaarschuwen 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.