Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Produkce: Škálování a mezipaměť

Lekce 22 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Výzvy produkčního prostředí
  3. Ukládání vnoření do mezipaměti
  4. Zvládání omezení rychlosti (Rate Limits)
  5. Asynchronní zpracování
  6. Optimalizace úložiště
  7. Produkční architektura
  8. Kontrolní seznam pro produkci
  9. Klíčové poznatky
  10. Ověř si své znalosti

Cíle

  • Optimalizovat výkon systému pro vnoření (embedding) v produkci
  • Implementovat mezipaměť pro snížení nákladů a latence
  • Zvládat škálování a vysokou dostupnost

Výzvy produkčního prostředí

Během vývoje není volání OpenAI API pro každý požadavev problém: možná provedeš deset volání denně. V produkci však tentýž kód narazí současně na tři zdi. Zaprvé, náklady: každé volání je zpoplatněno a úplné přeindexování korpusu se pokaždé zaplatí v plné výši. Zadruhé, latence: síťová cesta tam a zpět trvající 100 až 300 ms na požadavek se přičítá k času vyhledávání i generování a uživatel pocítí součet všech tří složek. Nakonec, omezení rychlosti (rate limits): OpenAI omezuje počet volání za minutu – limit, který ve vývoji nikdy neuvidíš, ale na který narazíš v den spuštění.

Všechny tři problémy mají z velké části stejné řešení: nevolej API, když to není nutné.

Ukládání vnoření do mezipaměti

Vnoření je deterministické: stejný text se stejným modelem vždy vrátí stejný vektor. To činí mezipaměť vysoce efektivní, mnohem více než u generativního LLM. Pro aplikaci se středním provozem stačí dekorátor lru_cache ze standardní knihovny a zabere jen dva řádky. Návratová hodnota se převede na n-tici (tuple), protože lru_cache vyžaduje hashovatelné hodnoty; to je jediná věc, na kterou si musíš dát pozor.

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 mezipaměť pro vnoření (n-tice, protože je hashovatelná)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Použití - 2. volání je okamžité
emb1 = embedding_cache("Hello world")  # Volání API
emb2 = embedding_cache("Hello world")  # Z mezipaměti

Tato mezipaměť zmizí při jakémkoli restartu a není sdílena mezi procesy: jakmile spustíš dvě instance za zátěžovou vyvažovačkou (load balancer), každá si znovu vytvoří svou vlastní. Redis řeší oba problémy. Klíčem je hash dvojice model-text, což zabraňuje tomu, aby změna modelu obsluhovala staré vektory, a TTL třiceti dnů omezuje růst úložiště.

Metoda get_embeddings_batch si zaslouží velkou pozornost, protože právě ona dělá rozdíl během ingestace. Nejenže kontroluje mezipaměť text po textu: odděluje chybějící položky (misses), odešle je v jediném volání API a poté pomocí indices_a_calculer znovu vloží každý výsledek na jeho původní pozici. U dávky tisíce dokumentů, kde je devět set již známých, se dostaneš z jednoho volání na dokument k jedinému volání pro zbývajících sto.

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 dní

    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)

        # Kontrola mezipaměti
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Generování a uložení do mezipaměti
        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]]:
        """Dávka s částečným ukládáním do mezipaměti."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Kontrola mezipaměti pro každý 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)

        # Výpočet chybějících v jediném volání
        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"Mezipaměť: {len(texts) - len(to_calculate)}/{len(texts)} zásahů")
        return results

# Použití
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")

Zvládání omezení rychlosti (Rate Limits)

Mezipaměť snižuje provoz, ale neodstraňuje jej úplně a špička v provozu nakonec spustí chybu RateLimitError. Správnou reakcí není okamžitý opakovaný pokus – což by congestion jen zhoršilo – ale čekání s dvojnásobným prodlužováním prodlevy pokaždé: jedna sekunda, dvě, čtyři, osm, šestnáct. Pět pokusů tak pokryje asi třicet sekund, což pohltí drtivou většinu dočasných špiček, a poslední pokus znovu vyvolá výjimku, aby byl incident nahlášen, místo aby byl tiše polykán.

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
    ):
        """Volání s exponenciálním opakovaným pokusem."""
        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"Naraženo na omezení rychlosti, pauza na {wait}s...")
                time.sleep(wait)

Asynchronní zpracování

U ingestčních pipeline není úzkým hrdlem výpočet, ale čekání na síť: tvůj program tráví většinu času tím, že nic nedělá. Asynchronní zpracování ti umožňuje udržet více požadavků ve vzduchu současně. Semafor záměrně omezuje tento paralelismus, protože spuštění sta současných volání pouze spustí omezení rychlosti, která ses právě naučil řešit – tři až pět souběžných požadavků je zdravé nastavení. Texty se nejprve rozdělí do dávek po stu a počáteční index každé dávky cestuje spolu s úkolem, aby as_completed, který vrací výsledky mimo pořadí, mohl stále umístit výsledky správně.

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]]:
    """Generování vnoření paralelně se semaforem."""
    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)
            ]

    # Rozdělení do dávek po 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

# Použití
embeddings = asyncio.run(
    generate_embeddings_async(my_texts, max_concurrent=3)
)

Optimalizace úložiště

Pak je tu faktura za infrastrukturu. Deset tisíc vektorů o 3 072 dimenzích ve formátu float32 zabere asi 122 MB; milion jich zabere dvanáct gigabajtů, které musí být drženy v paměti, aby vyhledávání zůstalo rychlé. Kvantování na int8 mapuje každou souřadnici na 256 celočíselných hodnot, čímž se footprint zmenší čtyřikrát, v níže uvedeném příkladu na zhruba 30 MB. Ztráta přesnosti existuje, ale zůstává marginální ve srovnání s rozdíly v podobnosti, se kterými pracuješ.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Kvantování vnoření na int8 (4x méně paměti)."""
    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):
    """Obnovení vnoření z int8."""
    return quantized.astype(np.float32) * scale + min_val

# Porovnání velikosti
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

Nejjednodušší pákou však zůstává parametr dimensions API, který produkuje kratší vektory přímo bez jakéhokoli následného zpracování z tvé strany: 3 072 dimenzí váží asi 24 KB na vektor, 1 024 dimenzí klesne na 8 KB a 256 dimenzí na 2 KB.

# 3072 dim -> ~24 KB na vektor
# 1024 dim -> ~8 KB na vektor  (redukce API)
# 256 dim  -> ~2 KB na vektor  (redukce API)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3x méně úložiště
)

Produkční architektura

Tyto díly dohromady dávají štíhlou pipeline: mezipaměť Redis vpředu, robustní klient pro volání, která se přesto dostanou skrz. Ingestace využívá cestu dávek, vyhledávání ukládá do mezipaměti i vnoření dotazu – a tento poslední bod není triviální, protože uživatelské dotazy se opakují mnohem častěji, než bys čekal.

class ProductionPipeline:
    """RAG pipeline optimalizovaná pro produkci."""

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

    def ingest(self, documents: list[dict]):
        """Ingestace s mezipamětí a opakovanými pokusy."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Uložení do vektorové databáze...

    def search(self, query: str, k: int = 5):
        """Vyhledávání s ukládáním dotazů do mezipaměti."""
        query_emb = self.cache.get_embedding(query)
        # Vyhledávání ve vektorové databázi...
        return query_emb

Kontrolní seznam pro produkci

PrvekPopis
Mezipaměť RedisSnížení volání API a latence
Exponenciální opakováníGraceful handling omezení rychlosti
MonitorováníSledování míry zásahu mezipaměti, latence, chyb
Dávkové zpracováníZpracování velkých objemů v asynchronních dávkách
KvantováníSnížení úložiště 4x pomocí int8
Redukce dimenzíPoužití 1024 nebo 512 dimenzí, pokud to kvalita dovolí
ZálohováníPravidelné zálohování vnoření a metadat
AlertingUpozornění na chyby API a zhoršení výkonu

Dva řádky v této tabulce nepřinášejí žádný výkonový zisk, přesto jsou nejdůležitější. Monitorování míry zásahu mezipaměti (cache hit rate) je tvým ukazatelem ekonomického zdraví: pokud se zhroutí, tvůj účet se ztrojnásobí, než si toho někdo všimne. A zálohování vnoření tě zachrání v den incidentu před tím, abys musel znovu platit a čekat na úplné zakódování celého korpusu.

Klíčové poznatky

  • Mezipaměť Redis snižuje náklady a latenci o více než 90 %
  • Exponenciální opakování zvládá omezení rychlosti OpenAI
  • Asynchronní zpracování zrychluje ingestaci velkých korpusů
  • Kvantování int8 snižuje úložiště 4x
  • Redukce dimenzí přímo v API je nejjednodušší pákou

Ověř si své znalosti

Dvacet dvě lekcí o vnoření a RAG: to podstatné se vejde do pěti otázek.

1. Co zachycuje vnoření a jak porovnáváme dva texty?

Odpověď: Vektor, který kóduje význam: dva texty blízké významem mají blízké vektory – kosinová podobnost měří tuto blízkost bez ohledu na přesně použitá slova.

2. Proč kombinovat sémantické a lexikální vyhledávání?

Odpověď: Sémantické rozumí přeformulováním, ale míjí přesné termíny (reference, identifikátory); lexikální dělá pravý opak – hybrid pokrývá obě slepá místa a slučuje podle pořadí.

3. Jaká je role chunkingu (rozdělování) pro kvalitu RAG?

Odpověď: Rozhodující: segmenty, které respektují hranice myšlenek, produkují přesné vyhledávání; libovolné řezy generují neúplné fragmenty – a celá pipeline toto dědí.

4. Integrované File Search nebo vlastní RAG: jak si vybrat?

Odpověď: File Search pro rychlý start se spravovanou pipeline (integrované chunking a ranking); vlastní RAG, když potřebuješ kontrolovat rozdělování, indexy, přerazování (reranking) nebo více zdrojů.

5. Jmenuj dvě využití vnoření kromě vyhledávání.

Odpověď: Klasifikace a shlukování (automatické seskupování podobných textů), personalizovaná doporučení nebo detekce anomálií a duplicit – stejný vektor, různé vzdálenosti.

Vlákno kurzu: význam se stává měřitelným – vyhledávání, ranking, doporučení jsou jen aplikace. Produkce (škálování, mezipaměť) dělá zbytek.