Ir al contenido principal
Español— Elegir un idioma
Menú

Producción: escalado y caché

Lección 22 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. Retos de producción
  3. Caché de embeddings
  4. Gestión de límites de tasa
  5. Procesamiento asíncrono
  6. Optimización del almacenamiento
  7. Arquitectura de producción
  8. Lista de comprobación para producción
  9. Resumen
  10. Pon a prueba tus conocimientos

Objetivos

  • Optimizar el rendimiento de un sistema de embeddings en producción
  • Implementar caché para reducir costes y latencia
  • Gestionar el escalado y la alta disponibilidad

Retos de producción

Durante el desarrollo, llamar a la API de OpenAI en cada solicitud no supone un problema: quizás hagas diez llamadas al día. En producción, ese mismo código choca contra tres muros simultáneamente. Primero, el coste: cada llamada se factura, y una reindexación completa de un corpus se paga íntegramente cada vez que se ejecuta. Segundo, la latencia: un viaje de ida y vuelta por la red de 100 a 300 ms por solicitud se suma al tiempo de búsqueda y al de generación, y el usuario percibe la suma de los tres. Por último, los límites de tasa: OpenAI limita el número de llamadas por minuto, un límite que nunca verás en desarrollo pero que alcanzarás el día del lanzamiento.

Los tres problemas tienen básicamente la misma solución: no llamar a la API cuando no sea necesario.

Caché de embeddings

Un embedding es determinista: el mismo texto con el mismo modelo devuelve siempre el mismo vector. Esto hace que la caché sea muy eficaz aquí, mucho más que para un LLM generativo. Para una aplicación con tráfico moderado, el decorador lru_cache de la biblioteca estándar es suficiente y solo requiere dos líneas. El valor de retorno se convierte en una tupla porque lru_cache exige valores hashables; ese es el único detalle que debes conocer.

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:
    """Caché LRU para embeddings (tupla porque es hashable)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Uso: la segunda llamada es instantánea
emb1 = embedding_cache("Hello world")  # Llamada a la API
emb2 = embedding_cache("Hello world")  # Desde caché

Esta caché desaparece ante cualquier reinicio y no se comparte entre procesos: en cuanto ejecutes dos instancias detrás de un balanceador de carga, cada una reconstruirá la suya. Redis resuelve ambos problemas. La clave es un hash del par modelo-texto, lo que evita que un cambio de modelo sirva vectores antiguos, y un TTL de treinta días limita el crecimiento del almacenamiento.

El método get_embeddings_batch merece especial atención, ya que es lo que marca la diferencia durante la ingesta. No solo comprueba la caché texto a texto: separa los fallos de caché, los envía en una única llamada a la API y luego reinserta cada resultado en su posición original usando indices_a_calculer. En un lote de mil documentos donde novecientos ya son conocidos, pasas de una llamada por documento a una única llamada para los cien restantes.

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 días

    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)

        # Comprobar caché
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Generar y almacenar en caché
        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]]:
        """Lote con caché parcial."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Comprobar caché para cada texto
        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)

        # Calcular los fallos en una única llamada
        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"Caché: {len(texts) - len(to_calculate)}/{len(texts)} aciertos")
        return results

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

Gestión de límites de tasa

La caché reduce el tráfico, pero no lo elimina, y un pico de tráfico acabará desencadenando un RateLimitError. La respuesta correcta no es reintentar de inmediato —lo que agravaría la congestión—, sino esperar, duplicando el retraso cada vez: un segundo, dos, cuatro, ocho, dieciséis. Cinco intentos cubren así unos treinta segundos, lo que absorbe la gran mayoría de picos temporales, y el intento final vuelve a lanzar la excepción para que el incidente se notifique en lugar de silenciarse.

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
    ):
        """Llamada con reintento exponencial."""
        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"Límite de tasa alcanzado, pausando {wait}s...")
                time.sleep(wait)

Procesamiento asíncrono

En las canalizaciones de ingesta, el cuello de botella no es el cómputo, sino la espera de red: tu programa pasa la mayor parte del tiempo sin hacer nada. El procesamiento asíncrono te permite mantener múltiples solicitudes en vuelo. El semáforo limita intencionadamente este paralelismo, porque lanzar cien llamadas simultáneas solo activaría los límites de tasa que acabas de aprender a gestionar: de tres a cinco solicitudes concurrentes es una configuración saludable. Los textos se dividen primero en lotes de cien, y el índice de inicio de cada lote viaja con la tarea para que as_completed, que devuelve resultados fuera de orden, pueda colocarlos correctamente.

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]]:
    """Generar embeddings en paralelo con un semáforo."""
    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)
            ]

    # Dividir en lotes 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

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

Optimización del almacenamiento

Luego está la factura de infraestructura. Diez mil vectores de 3.072 dimensiones en float32 ocupan unos 122 MB; un millón ocupa doce gigabytes, que deben mantenerse en memoria para que la búsqueda siga siendo rápida. La cuantización a int8 mapea cada coordenada a 256 valores enteros, dividiendo la huella por cuatro hasta unos 30 MB en el ejemplo siguiente. La pérdida de precisión existe, pero sigue siendo marginal comparada con las brechas de similitud con las que trabajas.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Cuantizar embeddings a int8 (4 veces menos memoria)."""
    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):
    """Restaurar embeddings desde int8."""
    return quantized.astype(np.float32) * scale + min_val

# Comparación de tamaño
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

Sin embargo, la palanca más sencilla sigue siendo el parámetro dimensions de la API, que produce vectores más cortos directamente sin ningún posprocesamiento por tu parte: 3.072 dimensiones pesan unos 24 KB por vector, 1.024 dimensiones bajan a 8 KB y 256 dimensiones a 2 KB.

# 3072 dim -> ~24 KB por vector
# 1024 dim -> ~8 KB por vector  (reducción en la API)
# 256 dim  -> ~2 KB por vector  (reducción en la API)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3 veces menos almacenamiento
)

Arquitectura de producción

Ensambladas, estas piezas dan una canalización ligera: caché Redis delante, cliente robusto para las llamadas que logran pasar de todos modos. La ingesta toma la ruta por lotes, la búsqueda pone en caché incluso el embedding de la consulta —y este último punto no es trivial, porque las consultas de usuario se repiten mucho más de lo que imaginas—.

class ProductionPipeline:
    """Canalización RAG optimizada para producción."""

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

    def ingest(self, documents: list[dict]):
        """Ingesta con caché y reintento."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Almacenar en base de datos vectorial...

    def search(self, query: str, k: int = 5):
        """Búsqueda con caché de consultas."""
        query_emb = self.cache.get_embedding(query)
        # Buscar en base de datos vectorial...
        return query_emb

Lista de comprobación para producción

ElementoDescripción
Caché RedisReducir llamadas a la API y latencia
Reintento exponencialGestionar límites de tasa con elegancia
MonitorizaciónSeguir tasa de aciertos de caché, latencia y errores
Procesamiento por lotesProcesar grandes volúmenes en lotes asíncronos
CuantizaciónReducir almacenamiento 4 veces con int8
Reducción de dimensionesUsar 1024 o 512 dimensiones si la calidad lo permite
Copia de seguridadRealizar copias de seguridad periódicas de embeddings y metadatos
AlertasAlertar sobre errores de API y degradación del rendimiento

Dos líneas de esta tabla no producen ganancia de rendimiento, pero son las más importantes. Monitorizar la tasa de aciertos de la caché es tu indicador de salud económica: si se desploma, tu factura se triplica antes de que nadie se dé cuenta. Y hacer copias de seguridad de los embeddings te evita, el día de un incidente, tener que volver a pagar y esperar de nuevo la codificación completa del corpus.

Resumen

  • La caché Redis reduce costes y latencia en más de un 90 %
  • El reintento exponencial gestiona los límites de tasa de OpenAI
  • El procesamiento asíncrono acelera la ingesta de corpus grandes
  • La cuantización int8 reduce el almacenamiento 4 veces
  • La reducción de dimensiones en la API es la palanca más sencilla

Pon a prueba tus conocimientos

Veintidós lecciones sobre embeddings y RAG: lo esencial cabe en cinco preguntas.

1. ¿Qué captura un embedding y cómo comparamos dos textos?

Respuesta: Un vector que codifica significado: dos textos cercanos en significado tienen vectores cercanos; la similitud del coseno mide esta proximidad, independientemente de las palabras exactas usadas.

2. ¿Por qué combinar búsqueda semántica y léxica?

Respuesta: La semántica entiende reformulaciones pero pierde términos exactos (referencias, identificadores); la léxica hace lo contrario: la híbrida cubre ambos puntos ciegos y fusiona por rango.

3. ¿Cuál es el papel del troceado en la calidad de RAG?

Respuesta: Decisivo: los segmentos que respetan los límites de las ideas producen búsquedas precisas; los cortes arbitrarios generan fragmentos incompletos, y toda la canalización hereda esto.

4. Búsqueda de archivos integrada o RAG personalizado: ¿cómo elegir?

Respuesta: Búsqueda de archivos para avanzar rápido con una canalización gestionada (troceado y clasificación integrados); RAG personalizado cuando necesitas controlar la división, los índices, la reclasificación o múltiples fuentes.

5. Más allá de la búsqueda, nombra dos usos de los embeddings.

Respuesta: Clasificación y agrupamiento (agrupar automáticamente textos similares), recomendaciones personalizadas, o detección de anomalías y duplicados: mismo vector, distintas distancias.

El hilo del curso: el significado se vuelve medible; búsqueda, clasificación y recomendación son solo aplicaciones. La producción (escalado, caché) hace el resto.