Producción: escalado y caché
En esta página
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
| Elemento | Descripción |
|---|---|
| Caché Redis | Reducir llamadas a la API y latencia |
| Reintento exponencial | Gestionar límites de tasa con elegancia |
| Monitorización | Seguir tasa de aciertos de caché, latencia y errores |
| Procesamiento por lotes | Procesar grandes volúmenes en lotes asíncronos |
| Cuantización | Reducir almacenamiento 4 veces con int8 |
| Reducción de dimensiones | Usar 1024 o 512 dimensiones si la calidad lo permite |
| Copia de seguridad | Realizar copias de seguridad periódicas de embeddings y metadatos |
| Alertas | Alertar 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.