Cuando se habla de motores de recomendación para cientos de miles de elementos, a muchos ingenieros se les viene al instante a la cabeza un stack pesado de ML: clústeres con GPU, servicios en Python, bases de datos vectoriales externas como Milvus o pgvector y modelos de lenguaje gigantescos. Parece que, sin redes neuronales, cualquier servicio moderno estaría condenado a devolver un aburrido top de lo más visto. ¿Pero y si te digo que puedes montar un motor de recomendaciones para 895,000 películas —capaz de encontrar títulos similares en 1–3 milisegundos— en un VPS modesto de un par de dólares, usando JavaScript puro y SQLite embebido?
Así es exactamente como funciona el proyecto independiente KINO PARTY. Su catálogo roza el millón de películas y en el servidor corre un monolito sobre Node.js 24. Cero microservicios, cero sobreingeniería y cero facturas astronómicas en la nube.
Vamos a desarmar esta arquitectura: nos asomaremos bajo el capó del módulo nativo node:sqlite, veremos las matemáticas detrás de los vectores dispersos normalizados, comprobaremos cómo un índice invertido supera a la búsqueda aproximada en grafos y descubriremos qué trampas te esperan al limpiar cientos de miles de filas de datos crudos.
Capa 1: La paradoja de la infraestructura y un stack local sin bases ML externas
La gran ilusión de la ingeniería actual es creer que todo problema de ranking exige embeddings de redes neuronales. Muchos equipos toman vectores densos de 1,536 dimensiones, los meten en una base de datos vectorial especializada y luego se sorprenden al ver que la base devora 16 GB de RAM solo para mantener el grafo HNSW, mientras la latencia de red se come decenas de milisegundos.
En KINO PARTY, la base de datos y el motor analítico viven en el mismo espacio de direcciones. El almacenamiento corre a cargo de SQLite embebido, al que el servidor accede mediante el módulo nativo node:sqlite, estabilizado en Node.js 24. Antes, el estándar eran wrappers binarios como better-sqlite3: iban rápido, sí, pero exigían compilar addons en C++ con node-gyp, lo que complicaba la construcción de imágenes Docker. La llegada de la clase DatabaseSync directamente a la biblioteca estándar zanjó ese problema.
Para que la base vuele y no se atasque en disco, al arrancar la aplicación se configuran las pragmas adecuadas:
import { DatabaseSync } from 'node:sqlite';
const db = new DatabaseSync('./data/kinoparty.db');
// Cambiamos el diario a modo WAL y asignamos memoria para la caché de páginas
db.exec(`
PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;
PRAGMA cache_size = -64000; -- 64 MB de RAM para caché
PRAGMA temp_store = MEMORY;
PRAGMA mmap_size = 2147483648; -- 2 GB del archivo de base mapeados en memoria
`);
El modo WAL permite que las lecturas no bloqueen las transacciones de escritura: mientras un proceso en segundo plano enriquece las fichas con puntuaciones de OMDb, las peticiones HTTP de los usuarios obtienen los datos al instante. Todo el archivo de la base, incluyendo índices y tablas virtuales FTS5, ocupa exactamente 9 GB en disco. La búsqueda de texto completo FTS5 resuelve las consultas por títulos y actores, y el núcleo recomendador recommender.js apenas ocupa unas 650 líneas de JavaScript puro.
Capa 2: Limpieza de datos sucios y la batalla contra las colisiones de ID
En teoría, los algoritmos lucen impecables hasta que chocan con datos reales. El catálogo se formó fusionando volcados de TMDB, OMDb y bases históricas de Kinopoisk, donde al desarrollador le esperaban varias sorpresas.
El primer problema fue el conflicto de claves primarias. Los identificadores de películas en los volcados antiguos de Kinopoisk y la API de TMDB se solapaban. Por ejemplo, el ID 603 en TMDB corresponde a Matrix, mientras que en Kinopoisk pertenecía al drama polaco El salón de Verónica. Una unión ingenua por el campo id daba recomendaciones absurdas. Se resolvió separando las claves externas (tmdbId, kinopoiskId, imdbId) y validando la fecha de estreno con una tolerancia máxima de un año.
El segundo problema fueron las localizaciones ficticias. De 762,000 películas con descripción rellena, 669,416 registros en la columna rusa no tenían ni una sola letra cirílica: cuando faltaba traducción, TMDB copiaba en silencio el texto en inglés. Traducir 670,000 sinopsis vía API resultaba carísimo. El autor aisló un «núcleo de oro» de 26,880 películas populares y tradujo solo esas, mientras que para el resto de títulos los rasgos se construyen a partir de marcadores originales.
Además, la traducción automática introdujo en la base caracteres de ancho cero U+200B y espacios duros que rompían el cálculo de sumas de verificación y la tokenización de FTS5. Hubo que añadir una fase obligatoria de saneamiento de texto antes de escribir en SQLite.
Capa 3: Álgebra lineal en memoria: índice invertido y cálculo de similitud
¿Cómo encontrar 50 películas parecidas entre casi un millón en un par de milisegundos? Un recorrido ingenuo de toda la base con heurísticas tumba la CPU en cuanto llegan cinco usuarios a la vez.
Diagrama infográfico del índice invertido disperso de KINO PARTY con vectores de rasgos y la fórmula de similitud del coseno.
La solución se apoya en un modelo vectorial de rasgos. Cada película se representa como un vector disperso donde solo un par de decenas de atributos tienen valores distintos de cero:
- Géneros (
g:): peso máximo de 3.6 por su mínima entropía; - Palabras clave (
k:): pesoTF-IDF × 0.42filtrando palabras vacías (stop words); - Tono emocional (
m:): peso entre 0.7 y 1.2; - Motor narrativo (
n:): peso cercano a 0.9; - Década de estreno (
d:): peso 0.55; - País de producción (
c:): peso 0.5.
Los vectores de rasgos pasan por una normalización L2 justo al guardarse: ||v|| = 1. Gracias a esto, la similitud del coseno entre dos películas se reduce a un simple producto escalar:
Así es como funcionan por dentro el índice invertido y el cálculo de similitud en el código:
export class FastRecommender {
constructor() {
this.invertedIndex = new Map(); // token -> Array<[movieId, weight]>
this.profiles = new Map(); // movieId -> Array<[token, weight]>
}
addMovie(id, rawFeatures) {
let sumSquares = 0;
for (const w of Object.values(rawFeatures)) sumSquares += w * w;
const norm = Math.sqrt(sumSquares) || 1;
const profile = [];
for (const [token, weight] of Object.entries(rawFeatures)) {
const normalized = weight / norm;
profile.push([token, normalized]);
if (!this.invertedIndex.has(token)) this.invertedIndex.set(token, []);
this.invertedIndex.get(token).push([id, normalized]);
}
this.profiles.set(id, profile);
}
findSimilar(targetId, limit = 20) {
const targetProfile = this.profiles.get(targetId);
if (!targetProfile) return [];
const scores = new Map();
for (const [token, targetWeight] of targetProfile) {
const postings = this.invertedIndex.get(token);
if (!postings) continue;
for (let i = 0; i < postings.length; i++) {
const [candId, candWeight] = postings[i];
if (candId === targetId) continue;
scores.set(candId, (scores.get(candId) || 0) + targetWeight * candWeight);
}
}
return Array.from(scores.entries())
.sort((a, b) => b[1] - a[1])
.slice(0, limit)
.map(([id, score]) => ({ id, score: Number(score.toFixed(4)) }));
}
}
El índice invertido recorta al instante el espacio de búsqueda: el algoritmo solo evalúa aquellos títulos que comparten tokens en común.
En el primer intento de cargar 50,000 películas en memoria, el proceso de Node.js sufrió pausas graves del recolector de basura (GC) y empezó a devolver errores 504. Así que el índice en memoria se limitó a 15,000 películas clave, mientras que para las 880,000 restantes el perfil se extrae de SQLite al vuelo en fracciones de milisegundo.
Este enfoque recuerda bastante a cómo se diseñan las herramientas de automatización del entorno de trabajo para Claude, donde aislar el contexto evita que la memoria se sature.
Capa 4: Selección en grupo en tiempo real y supervivencia en producción
Elegir película para un grupo es mucho más difícil que hacerlo para una sola persona. KINO PARTY funciona como un swiper de cine para decidir en conjunto.
Si aplicas un promedio simple, el grupo acaba recibiendo una opción intermedia que no convence a nadie. Por eso el servicio utiliza el modelo psicológico Valence-Arousal con un coeficiente asimétrico:
Valencia del grupo = Media(Valence) + (Mín(Valence) - Media(Valence)) × 1.6
La opinión del participante más cansado o menos satisfecho recibe un peso de penalización de ×1.6, y las listas de veto se combinan mediante un «OR»: un deslizamiento a la izquierda de cualquier persona excluye ese género de la selección común.
En lugar de pesadas conexiones WebSocket, el tiempo real se resuelve con Server-Sent Events (SSE). El servidor difunde el estado de la sala y los clientes votan mediante peticiones POST normales. Esto ofrece reconexión nativa en teléfonos móviles sin el sobrecoste de mantener sesiones WebSocket.
Por último, la protección frente a penalizaciones de buscadores por contenido pobre (SEO Thin Content). De 900,000 páginas, 868,000 tienen poco texto para posicionar de forma autónoma. Para ellas se devuelve la cabecera X-Robots-Tag: noindex, follow, conservando los enlaces sin ensuciar el índice de los buscadores. En el sitemap público solo entran estrictamente las 27,000 páginas del núcleo, que cuentan con sinopsis de al menos 100 caracteres, póster y valoraciones.
La experiencia de KINO PARTY demuestra algo muy claro: criterio de ingeniería, disciplina algorítmica y la biblioteca estándar bastan para construir servicios veloces sin inflar los presupuestos.

![Node.JS [ru]](/api/digests/it_development/daily/20261026/assets/sources/we-use-js.jpg?v=5116af75ef3f6a4049958f0a351a3b6a927b26be38099627548e7524071578b8)
