Vertex AI Exclusivo, Resiliencia y la Última Milla: Paginación
Este artículo describe la migración de un motor RAG desde una arquitectura multi-proveedor (SBERT, Ollama y Vertex AI) a una solución exclusiva con Vertex AI, explicando las razones detrás de esta decisión y el refactor resultante. Además, aborda un problema intermitente de carga de datos en la página de inicio debido a cold starts de Cloud Run. La solución implementada involucra un mecanismo de retry con exponential backoff en el cliente API (JavaScript/Axios). Aprenderás sobre las ventajas de simplificar la arquitectura, el manejo de cold starts y la implementación de retries.

La Gran Decisión: Un Solo Proveedor de IA
Durante meses, mi motor RAG mantuvo soporte para dos proveedores de IA:
- SBERT + Ollama — Modelos locales, gratuitos, sin dependencia de internet
- Vertex AI — API de Google Cloud, embeddings de 768 dimensiones, Gemini 2.0 Flash
El código estaba lleno de condicionales:
# ANTES: Lógica bifurcada en todas partes
if settings.AI_PROVIDER == 'vertex':
embedding = self._vertex_embed(text)
elif settings.AI_PROVIDER == 'ollama':
embedding = self._ollama_embed(text)
elif settings.AI_PROVIDER == 'sbert':
embedding = self._sbert_embed(text)
else:
raise ValueError(f"Unknown provider: {settings.AI_PROVIDER}")
Cada vez que agregaba una feature al motor, tenía que implementarla tres veces. Cada vez que algo fallaba, tenía que diagnosticar en qué proveedor ocurría. Las tres implementaciones divergían sutilmente: SBERT producía vectores de 384 dimensiones, Vertex AI de 768. Ollama usaba requests.post a localhost, Vertex AI usaba ADC con tokens de OAuth2.
Por Qué Eliminé Ollama y SBERT
1. Producción solo usa Vertex AI. Cloud Run no tiene GPU ni suficiente RAM para correr SBERT (90 MB) u Ollama (~4 GB). En producción, siempre se usaba Vertex AI. El código de Ollama/SBERT solo servía para desarrollo local.
2. Las credenciales de ADC funcionan en desarrollo. Con gcloud auth application-default login, Vertex AI funciona perfectamente en local. No necesito un modelo offline.
3. Complejidad accidental. Mantener tres proveedores triplicaba la superficie de bugs. Cada proveedor tenía sus propios timeouts, formatos de respuesta y modos de fallo. Solo en manejo de errores, tenía ~60 líneas de código para cubrir los tres casos.
4. Los embeddings son incompatibles. Si indexo posts con SBERT (384-dim) y luego busco con Vertex AI (768-dim), los vectores no son comparables. Tendría que reindexar todo cada vez que cambio de proveedor.
El Refactor
El commit 2c9a51f eliminó ~200 líneas de código:
# DESPUÉS: Vertex AI exclusivo
class RAGEngine:
@classmethod
def get_embedding(cls, text):
"""Genera embedding usando Vertex AI text-embedding-005."""
project = os.getenv('GOOGLE_CLOUD_PROJECT')
region = os.getenv('GOOGLE_CLOUD_REGION', 'us-central1')
url = (
f"https://{region}-aiplatform.googleapis.com/v1/"
f"projects/{project}/locations/{region}/"
f"publishers/google/models/text-embedding-005:predict"
)
credentials, _ = google.auth.default()
credentials.refresh(google.auth.transport.requests.Request())
response = requests.post(url,
headers={'Authorization': f'Bearer {credentials.token}'},
json={'instances': [{'content': text}]}
)
return np.array(response.json()['predictions'][0]['embeddings']['values'])
Un método. Un proveedor. Sin condicionales. Sin abstracciones innecesarias.
Preservando el Código Deprecado
No eliminé el código viejo del repositorio. Lo moví a blog_backend/deprecated/:
deprecated/
├── engine_ollama.py # Motor RAG con Ollama/SBERT
└── README.md # Explicación de por qué se deprecó
¿Por qué conservarlo? Por dos razones:
-
Referencia histórica. Si algún día quiero volver a un modelo local (por ejemplo, si Google sube los precios de Vertex AI), tengo el código como punto de partida.
-
Documentación de decisiones. El código deprecado cuenta una historia. Alguien que lea el repositorio puede entender la evolución arquitectónica: "Ah, primero usaba SBERT, luego migraron a Vertex AI. Tiene sentido."
El Bug Intermitente: Cold Starts y Carga de Datos
El Síntoma
Usuarios reportaban que la página de inicio a veces cargaba sin datos. Recargaban la página y todo aparecía. El problema era intermitente y no reproducible de manera consistente.
La Causa: Cold Starts de Cloud Run
Cloud Run escala a cero. Cuando nadie visita el blog por 15 minutos, todas las instancias se destruyen. Cuando llega la siguiente request:
1. Cloud Run crea una nueva instancia → ~2 segundos
2. Docker container arranca → ~1 segundo
3. Gunicorn inicia y carga la app Django → ~3 segundos
4. Django conecta a Cloud SQL (que también puede estar dormido) → ~5 segundos
5. Tu request finalmente se procesa → ~100ms
Esos ~11 segundos de cold start significaban que el frontend hacía fetch('/api/blog/posts/'), esperaba 10 segundos, y el timeout del fetch expiraba antes de que el backend respondiera.
La Solución: Retry con Exponential Backoff
El commit 2c9a51f modificó el cliente API del frontend:
// api/client.js
const client = axios.create({
baseURL: process.env.REACT_APP_API_URL,
timeout: 30000, // 30 segundos (antes era 10)
});
// Interceptor de retry
client.interceptors.response.use(
response => response,
async error => {
const config = error.config;
if (!config || config._retryCount >= 3) {
return Promise.reject(error);
}
config._retryCount = (config._retryCount || 0) + 1;
// Backoff exponencial: 1s, 2s, 4s
const delay = Math.pow(2, config._retryCount - 1) * 1000;
await new Promise(resolve => setTimeout(resolve, delay));
return client(config);
}
);
Exponential backoff es un patrón estándar en sistemas distribuidos: si la primera request falla, esperas 1 segundo y reintentas. Si falla de nuevo, esperas 2 segundos. Luego 4.
¿Por qué exponencial y no lineal? Si el backend está sobrecargado, enviar reintentos constantes cada segundo solo empeora la situación. Con backoff exponencial, le das tiempo al sistema para recuperarse. Además, si hay múltiples clientes reintentando, el espaciado exponencial reduce la probabilidad de que todos reintentan al mismo tiempo (thundering herd problem).
Mejoras en la Página de Inicio
La Home hacía 4 llamadas a la API en paralelo:
// Home.js - ANTES: Sin manejo de errores
useEffect(() => {
fetchPosts();
fetchTags();
fetchStats();
fetchVideos();
}, []);
El problema: si una fallaba, las otras 3 podían tener datos parciales o estados inconsistentes. La mejora:
// Home.js - DESPUÉS: Promise.all con estados de carga individuales
useEffect(() => {
const loadData = async () => {
try {
const [postsRes, tagsRes] = await Promise.all([
client.get('/blog/posts/?page_size=6'),
client.get('/blog/tags/'),
]);
setPosts(postsRes.data.results);
setTags(tagsRes.data.results);
} catch (err) {
console.error('Error loading home data:', err);
// Auto-retry después de 3 segundos
setTimeout(loadData, 3000);
} finally {
setLoading(false);
}
};
loadData();
}, []);
Promise.all asegura que ambas requests se disparan en paralelo (no secuencialmente) y que si una falla, el catch maneja el error de forma unificada. El auto-retry a nivel de componente complementa el retry del interceptor de Axios.
Paginación: El Problema de los 20 Posts
El Síntoma (De Nuevo)
Mi blog tenía 24 posts, pero el listado solo mostraba 20. Los otros 4 simplemente no existían para el usuario. No había "Página 2", no había "Ver más", nada.
La Causa
El backend tiene paginación configurada:
# settings.py
REST_FRAMEWORK = {
'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
'PAGE_SIZE': 20,
}
DRF retorna:
{
"count": 24,
"next": "http://api/blog/posts/?page=2",
"previous": null,
"results": [/* 20 posts */]
}
Pero el frontend ignoraba count, next y previous. Solo usaba results:
// PostList.js - ANTES
const response = await client.get('/blog/posts/');
setPosts(response.data.results); // Solo toma los 20 primeros
La Implementación
El commit 825e6fa agregó paginación completa con MUI Pagination:
import { Pagination } from '@mui/material';
function PostList() {
const [posts, setPosts] = useState([]);
const [page, setPage] = useState(1);
const [totalPages, setTotalPages] = useState(1);
const [searchParams, setSearchParams] = useSearchParams();
const PAGE_SIZE = 20;
useEffect(() => {
// Leer página de la URL
const urlPage = parseInt(searchParams.get('page')) || 1;
setPage(urlPage);
}, [searchParams]);
useEffect(() => {
const fetchPosts = async () => {
const response = await client.get('/blog/posts/', {
params: { page, page_size: PAGE_SIZE }
});
setPosts(response.data.results);
setTotalPages(Math.ceil(response.data.count / PAGE_SIZE));
};
fetchPosts();
}, [page]);
const handlePageChange = (event, value) => {
setPage(value);
setSearchParams({ page: value });
window.scrollTo({ top: 0, behavior: 'smooth' });
};
return (
<>
{/* Grid de posts */}
<Grid container spacing={3}>
{posts.map(post => <PostCard key={post.slug} post={post} />)}
</Grid>
{/* Paginación */}
{totalPages > 1 && (
<Pagination
count={totalPages}
page={page}
onChange={handlePageChange}
color="primary"
showFirstButton
showLastButton
sx={{ mt: 4, display: 'flex', justifyContent: 'center' }}
/>
)}
</>
);
}
Sincronización con la URL
Un detalle de UX que puede pasar desapercibido pero es fundamental: la página actual se refleja en la URL como ?page=N. Esto permite:
- Compartir links: Si le envío a alguien
hectorgarrido.cl/blog?page=2, ve la página 2 directamente. - Navegación del browser: El botón "Atrás" del navegador regresa a la página anterior del listado, no solo a la página anterior del historial.
- Bookmarks: Puedes guardar una página específica del blog.
// Leer la página de la URL al montar el componente
const urlPage = parseInt(searchParams.get('page')) || 1;
// Actualizar la URL al cambiar de página
setSearchParams({ page: value });
useSearchParams es un hook de React Router v6 que lee y escribe los query params de la URL sin causar una navegación completa (no recarga la página).
Reset al Filtrar
Cuando el usuario aplica un filtro por tag o busca texto, la paginación debe resetear a la página 1:
// Al cambiar tag o búsqueda, volver a página 1
useEffect(() => {
setPage(1);
setSearchParams({});
}, [selectedTag, searchQuery]);
Si el usuario está en la página 3 y filtra por "Python", los resultados filtrados probablemente tengan menos de 3 páginas. Mostrar la página 3 de 1 sería confuso. Siempre reseteamos a la página 1.
Actualización de Documentación
Ambos commits incluyeron actualizaciones extensas de documentación:
copilot-instructions.md: Actualizado para reflejar Vertex AI como proveedor exclusivo, la deprecación de Ollama/SBERT, y la existencia de la carpetadeprecated/.- Root README y Backend README: Eliminadas referencias a Ollama, actualizadas instrucciones de setup.
docs/04-frontend-react.md: Documentada la paginación con MUI Pagination.- Frontend README: Actualizado con la lista de dependencias actuales.
¿Por Qué Documentar Tan Obsesivamente?
Porque yo-del-futuro es mi principal usuario. Cada vez que vuelvo a este código después de 2 semanas de no tocarlo, lo primero que hago es leer la documentación. Si está desactualizada, pierdo 30 minutos reconstruyendo el contexto.
Mis reglas para documentación: 1. Actualizar la documentación es parte del PR. Si el código cambia, la documentación cambia. 2. Documentar decisiones, no solo implementación. "Usamos Vertex AI" es menos útil que "Usamos Vertex AI porque Ollama no corre en Cloud Run y SBERT consume 90 MB de RAM". 3. Documentar lo que va a confundir. Si me tomó más de 5 minutos entender algo, lo documento para que no me tome otros 5 minutos la próxima vez.
El Estado Final del Sistema
Después de estos últimos commits, el blog tiene una arquitectura limpia y coherente:
┌─────────────────────────────────────────────────┐
│ FRONTEND │
│ React 18 + MUI v5 │
│ ┌─────────┐ ┌──────────┐ ┌───────────────┐ │
│ │ Home │ │ PostList │ │ RagSearch │ │
│ │ (stats) │ │ (pagin.) │ │ (typewriter) │ │
│ └────┬────┘ └────┬─────┘ └──────┬────────┘ │
│ │ │ │ │
│ └────────────┼───────────────┘ │
│ │ Axios + retry/backoff │
└────────────────────┼────────────────────────────┘
│ HTTPS
┌────────────────────┼────────────────────────────┐
│ BACKEND │
│ Django 5 + DRF + Gunicorn │
│ ┌──────────────┐ ┌──────────────────────────┐ │
│ │ Blog API │ │ RAG Engine │ │
│ │ (CRUD + │ │ ┌────────────────────┐ │ │
│ │ paginate) │ │ │ EmbeddingIndex │ │ │
│ └──────────────┘ │ │ (in-memory numpy) │ │ │
│ │ └────────────────────┘ │ │
│ ┌──────────────┐ │ ┌────────────────────┐ │ │
│ │ Signals │ │ │ RAGQueryCache │ │ │
│ │ (auto-index │ │ │ (hash+semántico) │ │ │
│ │ + invalidar│ │ └────────────────────┘ │ │
│ │ caché) │ │ │ │ │
│ └──────────────┘ │ Vertex AI API │ │
│ │ ┌────────────────────┐ │ │
│ │ │ text-embedding-005 │ │ │
│ │ │ gemini-2.5-flash │ │ │
│ │ └────────────────────┘ │ │
│ └──────────────────────────┘ │
└─────────────────────────────────────────────────┘
Métricas Finales
| Métrica | Valor |
|---|---|
| Posts | 24 artículos sobre series de tiempo y econometría |
| Tiempo de respuesta API (warm) | ~100ms |
| Tiempo de respuesta API (cold start) | ~11s (con retry automático) |
| Tiempo de respuesta RAG (cache hit) | <50ms |
| Tiempo de respuesta RAG (cache miss) | 3-8 segundos |
| Tamaño del embedding index | ~74 KB (24 posts × 768 dims × 4 bytes) |
| Costo mensual GCP | ~0, Cloud Run: ~0.23, Vertex AI: ~$0.05) |
| Commits totales | 65+ |
| Pull Requests | 14 |
| Artículos sobre el proceso | Este (5 de 5 de la serie original; la serie continuó hasta el Post 16) |
Reflexión Final: Lo Que Aprendí Construyendo Todo Esto
Sobre Arquitectura
Empieza simple, complejiza cuando hay dolor. Mi primera búsqueda era icontains en SQL. Funcionaba. Agregué búsqueda semántica cuando los keywords dejaron de ser suficientes. Agregué caché cuando la latencia del RAG se volvió un problema. Cada capa de complejidad fue una respuesta a un problema real, no a una anticipación especulativa.
Sobre IA en Producción
Un LLM en local es un juguete. Un LLM en producción es un servicio. La diferencia entre Ollama en mi laptop y Vertex AI en Cloud Run no es solo técnica — es operacional. En producción necesitas monitoreo, timeouts, reintentos, control de costos, y un plan para cuando el servicio esté caído.
Sobre Despliegue
El 80% del tiempo de despliegue se gasta en el 20% más aburrido. Configurar puertos, URLs, CORS, certificados SSL, variables de entorno, permisos de IAM. Nada de esto es glamoroso, pero cada uno puede bloquear tu deploy por horas.
Sobre Documentación
Escribe la documentación que te gustaría leer. No la documentación "correcta" según algún estándar. La que te va a salvar a ti (o a alguien) un viernes a las 11 pm cuando algo se rompe y necesitas entender por qué el caché no se invalida.
Sobre Proyectos Personales
Un proyecto personal es el mejor profesor. En estos 3 meses aprendí más sobre Cloud Run, WebSockets, embeddings vectoriales y React que en cualquier curso o tutorial. Porque cuando algo falla en tu proyecto, no puedes saltarte el capítulo. Tienes que resolverlo.
Anterior: Caché Semántico, Signals y las Mil Batallas de las Imágenes en GCS
Siguiente: La Verdad Incómoda de Cloud SQL: Por Qué Tu Base de Datos Vacía Cuesta Más que Todo tu Stack
Este fue el último artículo de la serie original "Construyendo un Blog con IA". La serie continuó con 11 posts adicionales (Posts 07–17) cubriendo CI/CD, optimización frontend, portafolio profesional, dominio propio, contacto, tests, analytics y debugging en producción. El código fuente completo está en GitHub. Si tienes preguntas, puedes usar el chatbot del blog — después de todo, para eso lo construí.