Salt la conținutul principal
Română— Alege o limbă
Meniu

Production: Scalabilitate și Cache

Lecția 22 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Provocări în mediul de producție
  3. Cache pentru Embedding-uri
  4. Gestionarea limitelor de rată (Rate Limits)
  5. Procesare Asincronă
  6. Optimizarea Stocării
  7. Arhitectură de Producție
  8. Lista de verificare pentru producție
  9. Puncte cheie
  10. Testați-vă cunoștințele

Obiective

  • Optimizarea performanței unui sistem de embedding în producție
  • Implementarea mecanismelor de cache pentru reducerea costurilor și a latenței
  • Gestionarea scalabilității și a disponibilității ridicate

Provocări în mediul de producție

În timpul dezvoltării, apelarea API-ului OpenAI pentru fiecare cerere nu reprezintă o problemă: este posibil să efectuați zece apeluri pe zi. În producție, același cod se lovește simultan de trei obstacole. În primul rând, costul: fiecare apel este facturat, iar o re-indexare completă a unui corpus este plătită integral de fiecare dată când rulează. În al doilea rând, latența: o dus-întors prin rețea de 100 până la 300 ms per cerere se adaugă timpului de căutare și celui de generare, iar utilizatorul simte suma tuturor acestora. În final, limitele de rată (rate limits): OpenAI limitează numărul de apeluri pe minut—o limită pe care nu o veți întâlni niciodată în dezvoltare, dar pe care o veți atinge în ziua lansării.

Toate cele trei probleme au, în mare parte, aceeași soluție: nu apelați API-ul atunci când nu este necesar.

Cache pentru Embedding-uri

Un embedding este determinist: același text cu același model returnează întotdeauna același vector. Acest lucru face ca mecanismul de cache să fie extrem de eficient aici, mult mai mult decât în cazul unui LLM generativ. Pentru o aplicație cu trafic moderat, decoratorul lru_cache din biblioteca standard este suficient și necesită doar două linii de cod. Valoarea returnată este convertită într-un tuplu deoarece lru_cache necesită valori hashabile; aceasta este singura particularitate de reținut.

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 pentru embedding-uri (tuplu deoarece este hashabil)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Utilizare - al 2-lea apel este instantaneu
emb1 = embedding_cache("Hello world")  # Apel API
emb2 = embedding_cache("Hello world")  # Din cache

Acest cache dispare la orice repornire și nu este partajat între procese: imediat ce rulați două instanțe în spatele unui load balancer, fiecare își reconstruiește propriul cache. Redis rezolvă ambele probleme. Cheia este un hash al perechii model-text, ceea ce previne servirea unor vectori vechi în cazul unei schimbări de model, iar un TTL (Time To Live) de treizeci de zile limitează creșterea stocării.

Metoda get_embeddings_batch merită o atenție deosebită, deoarece ea face diferența în timpul ingestiei. Aceasta nu verifică cache-ul text cu text: separă elementele lipsă (misses), le trimite într-un singur apel API, apoi reinseră fiecare rezultat în poziția sa originală folosind indices_a_calculer. La un lot de o mie de documente dintre care nouă sute sunt deja cunoscute, treceți de la un apel per document la un singur apel pentru cele o sută rămase.

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 de zile

    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)

        # Verificare cache
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Generare și 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 cu cache parțial."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Verificare cache pentru fiecare text
        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)

        # Calcularea elementelor lipsă într-un singur apel
        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

# Utilizare
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")

Gestionarea limitelor de rată (Rate Limits)

Cache-ul reduce traficul, dar nu îl elimină, iar un vârf de trafic va declanșa în cele din urmă o eroare RateLimitError. Răspunsul corect nu este să reîncercați imediat—ceea ce agravează congestia—ci să așteptați, dublând întârzierea de fiecare dată: o secundă, două, patru, opt, șaisprezece. Cinci încercări acoperă astfel aproximativ treizeci de secunde, ceea ce absoarbe marea majoritate a vârfurilor temporare, iar ultima încercare re-aruncă excepția pentru ca incidentul să fie raportat în loc să fie înghițit în tăcere.

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
    ):
        """Apel cu reîncercare exponențială."""
        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"Limită de rată atinsă, pauză de {wait}s...")
                time.sleep(wait)

Procesare Asincronă

Pentru pipeline-urile de ingestie, gâtul de sticlă nu este calculul, ci așteptarea rețelei: programul dumneavoastră își petrece majoritatea timpului fără a face nimic. Procesarea asincronă vă permite să mențineți multiple cereri în curs de execuție. Semaforul limitează intenționat acest paralelism, deoarece lansarea a o sută de apeluri simultane declanșează doar limitele de rată pe care tocmai ați învățat să le gestionați—trei până la cinci cereri concurente reprezintă o configurare sănătoasă. Textele sunt mai întâi împărțite în loturi de o sută, iar indexul de start al fiecărui lot călătorește împreună cu sarcina, astfel încât as_completed, care returnează rezultatele în afara ordinii, să le poată plasa totuși corect.

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]]:
    """Generare embedding-uri în paralel cu un semafor."""
    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)
            ]

    # Împărțire în loturi 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

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

Optimizarea Stocării

Apoi există factura de infrastructură. Zece mii de vectori cu 3.072 de dimensiuni în float32 ocupă aproximativ 122 MB; un milion ocupă doisprezece gigabytes, care trebuie menținuți în memorie pentru ca căutarea să rămână rapidă. Cuantificarea la int8 mapează fiecare coordonată la 256 de valori întregi, împărțind amprenta la patru, la aproximativ 30 MB în exemplul de mai jos. Pierderea de precizie există, dar rămâne marginală comparativ cu decalajele de similaritate cu care lucrați.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Cuantificare embedding-uri la int8 (de 4 ori mai puțină memorie)."""
    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):
    """Restaurare embedding-uri din int8."""
    return quantized.astype(np.float32) * scale + min_val

# Comparație dimensiune
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

Cu toate acestea, pârghia cea mai simplă rămâne parametrul dimensions al API-ului, care produce vectori mai scurți direct, fără niciun post-procesare din partea dumneavoastră: 3.072 de dimensiuni cântăresc aproximativ 24 KB per vector, 1.024 de dimensiuni scad la 8 KB, iar 256 de dimensiuni la 2 KB.

# 3072 dim -> ~24 KB per vector
# 1024 dim -> ~8 KB per vector  (reducere API)
# 256 dim  -> ~2 KB per vector  (reducere API)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # stocare de 3 ori mai mică
)

Arhitectură de Producție

Asamblate, aceste piese oferă un pipeline eficient: cache Redis în față, client robust pentru apelurile care trec totuși. Ingestia folosește ruta pe loturi, căutarea face cache chiar și pentru embedding-ul interogării—iar acest ultim punct nu este trivial, deoarece interogările utilizatorilor se repetă mult mai des decât v-ați imagina.

class ProductionPipeline:
    """Pipeline RAG optimizat pentru producție."""

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

    def ingest(self, documents: list[dict]):
        """Ingestie cu cache și reîncercare."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Stocare în baza de date vectorială...

    def search(self, query: str, k: int = 5):
        """Căutare cu cache pentru interogare."""
        query_emb = self.cache.get_embedding(query)
        # Căutare în baza de date vectorială...
        return query_emb

Lista de verificare pentru producție

ElementDescriere
Cache RedisReduce apelurile API și latența
Reîncercare ExponențialăGestionează limitele de rată cu grație
MonitorizareUrmăriți rata de hit-uri cache, latența, erorile
Procesare pe LoturiProcesați volume mari în loturi asincrone
CuantificareReduce stocarea de 4 ori cu int8
Reducerea DimensiuniiUtilizați 1024 sau 512 dimensiuni dacă calitatea permite
BackupFaceți backup regulat la embedding-uri și metadate
AlertareAlertați în cazul erorilor API și degradării performanței

Două linii în acest tabel nu produc niciun câștig de performanță, dar sunt cele mai importante. Monitorizarea ratei de hit-uri cache este indicatorul dumneavoastră de sănătate economică: dacă se prăbușește, factura se triplează înainte ca cineva să observe. Iar realizarea de backup-uri pentru embedding-uri vă scutește, în ziua unui incident, de a trebui să plătiți din nou și să așteptați re-encodarea întregului corpus.

Puncte cheie

  • Cache-ul Redis reduce costurile și latența cu peste 90%
  • Reîncercarea exponențială gestionează limitele de rată OpenAI
  • Procesarea asincronă accelerează ingestia corpusurilor mari
  • Cuantificarea int8 reduce stocarea de 4 ori
  • Reducerea dimensiunii la nivelul API-ului este pârghia cea mai simplă

Testați-vă cunoștințele

Douăzeci și două de lecții despre embedding-uri și RAG: esențialul se încadrează în cinci întrebări.

1. Ce captează un embedding și cum comparăm două texte?

Răspuns: Un vector care codifică sensul: două texte apropiate ca sens au vectori apropiați—similaritatea cosinus măsoară această proximitate, indiferent de cuvintele exacte folosite.

2. De ce combinăm căutarea semantică cu cea lexicală?

Răspuns: Semantica înțelege reformulările, dar ratează termenii exacți (referințe, identificatori); lexicala face opusul—hibridul acoperă ambele puncte oarbe și fuzionează prin rang.

3. Care este rolul fragmentării (chunking) în calitatea RAG?

Răspuns: Decisiv: segmentele care respectă limitele ideilor produc o căutare precisă; tăierile arbitrare generează fragmente incomplete—iar întregul pipeline moștenește acest lucru.

4. Căutare integrată de fișiere sau RAG personalizat: cum alegem?

Răspuns: Căutare de fișiere pentru a avansa rapid cu un pipeline gestionat (fragmentare și clasament integrate); RAG personalizat când trebuie să controlați divizarea, indexurile, re-clasamentul sau sursele multiple.

5. Dincolo de căutare, numiți două utilizări pentru embedding-uri.

Răspuns: Clasificare și clustering (gruparea automată a textelor similare), recomandări personalizate sau detectarea anomaliilor și a duplicatelor—același vector, distanțe diferite.

Firul conductor al cursului: sensul devine măsurabil—căutarea, clasamentul, recomandarea sunt doar aplicații. Producția (scalabilitate, cache) face restul.