Refactorizacion, scripts limpieza, mock e cargar datos

backend/app_factory.py

@@ -85,7 +85,7 @@ def create_app() -> Flask:
         )
 
         # Se añade el evento emocional al historial del usuario para seguimiento futuro.
-        añadir_evento_emocional(user_id = user_id, text = texto, emotion = dominant_es, momento_analisis = momento_analisis)
+        añadir_evento_emocional(user_id = user_id, text = texto, emotion = dominant_es, analyzed_at = momento_analisis)
 
         # Si existe evento anterior, se busca pelicula puente entre ambos estados.
         pelicula_de_transicion = None
@@ -98,11 +98,11 @@ def create_app() -> Flask:
 
         # Se genera el texto del chatbot explicando 
         chatbot_text, chatbot_source = generar_texto_chatbot(
-            dominant_emotion=dominant_es,
-            recommendation_mode = recommendation_mode,
-            recommendations = recomendaciones,
+            emocion_dominante = dominant_es,
+            modo_recomendacion = recommendation_mode,
+            recomendaciones = recomendaciones,
             emocion_previa = emocion_previa,
-            pelicula_de_transicion = pelicula_de_transicion,
+            pelicula_transicion = pelicula_de_transicion,
         )
 
         # Se devuelve toda la informacion relevante al frontend en un JSON para mostrar al usuario.
@@ -132,7 +132,7 @@ def create_app() -> Flask:
         # Se obtienen del payload los campos necesarios
         user_id = str(payload.get("user_id", "")).strip() 
         texto_posterior = str(payload.get("texto_post", "")).strip()
-        id_pelicula = str(payload.get("id_pelicula", "")).strip()
+        id_pelicula = str(payload.get("id_pelicula") or payload.get("movie_id") or "").strip()
         titulo_pelicula = str(payload.get("title", "")).strip()
 
         # Se valida que el ciclo de recomendacion exista
@@ -155,17 +155,17 @@ def create_app() -> Flask:
         result_post, emocion_posterior, valencia_posterior = analizar_texto(modelo, texto_posterior)
 
         # Se registra la emocion posterior al visionado en el historial
-        añadir_evento_emocional(user_id = user_id, text = texto_posterior, emotion = emocion_posterior, momento_analisis = momento_analisis)
+        añadir_evento_emocional(user_id = user_id, text = texto_posterior, emotion = emocion_posterior, analyzed_at = momento_analisis)
         # Se modifica el ciclo de recomendacion anterior con la informacion posterior
         guardar_estado_posterior(
             cycle_id=cycle_id,
             user_id = user_id,
-            texto_posterior = texto_posterior,
-            emocion_posterior = emocion_posterior,
-            valencia_posterior = valencia_posterior,
-            post_momento_analisis = momento_analisis,
-            id_pelicula = id_pelicula,
-            titulo_pelicula = titulo_pelicula,
+            post_text = texto_posterior,
+            post_emotion = emocion_posterior,
+            post_valence = valencia_posterior,
+            post_analyzed_at = momento_analisis,
+            movie_id = id_pelicula,
+            movie_title = titulo_pelicula,
         )
 
         return jsonify(
@@ -175,8 +175,8 @@ def create_app() -> Flask:
                 "title": titulo_pelicula,
                 "pre_emotion": cycle.get("pre_emotion"),
                 "pre_valence": cycle.get("pre_valence"),
-                "emocion_posterior": emocion_posterior,
-                "valencia_posterior": valencia_posterior,
+                "post_emotion": emocion_posterior,
+                "post_valence": valencia_posterior,
                 "cambio_emocional": cycle.get("pre_emotion") != emocion_posterior,
                 "cambio_valencia": cycle.get("pre_valence") != valencia_posterior,
                 "emociones_post": result_post,
@@ -191,7 +191,7 @@ def create_app() -> Flask:
         # Guarda una pelicula vista junto a su valoracion del usuario.
         payload = request.json or {}
         user_id = str(payload.get("user_id", "")).strip()
-        id_pelicula = str(payload.get("id_pelicula", "")).strip()
+        id_pelicula = str(payload.get("id_pelicula") or payload.get("movie_id") or "").strip()
 
         # Si no existen usuario o pelicula se devuelve un error
         if not user_id or not id_pelicula:
@@ -215,23 +215,24 @@ def create_app() -> Flask:
 
         id_pelicula_anadida = añadir_pelicula_a_historial(
             user_id = user_id,
-            id_pelicula = id_pelicula,
+            movie_id = id_pelicula,
             title = titulo_pelicula,
             emotion = emocion,
             user_rating = rating_usuario,
             session_text = texto,
-            momento_visionado = momento_visionado,
+            viewed_at = momento_visionado,
         )
 
         return jsonify(
             {
                 "id": id_pelicula_anadida,
                 "user_id": user_id,
-                "id_pelicula": id_pelicula,
+                "movie_id": id_pelicula,
                 "title": titulo_pelicula,
                 "emotion": emocion,
                 "user_rating": rating_usuario,
                 "session_text": texto,
+                "viewed_at": momento_visionado,
                 "momento_visionado": momento_visionado,
             }
         ), 201

backend/scripts/limpiar_bdm.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Limpia todos los datos de la base de datos SQLite del backend."""
+
+from __future__ import annotations
+
+import argparse
+import sqlite3
+from pathlib import Path
+import sys
+
+CURRENT_DIR = Path(__file__).resolve().parent
+BACKEND_DIR = CURRENT_DIR.parent
+if str(BACKEND_DIR) not in sys.path:
+    sys.path.insert(0, str(BACKEND_DIR))
+
+from config import HISTORY_DB_PATH
+from db import iniciar_historial_usuario
+
+
+def _obtener_tablas_usuario(conn: sqlite3.Connection) -> list[str]:
+    rows = conn.execute(
+        """
+        SELECT name
+        FROM sqlite_master
+        WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+        """
+    ).fetchall()
+    return [str(r[0]) for r in rows]
+
+
+def limpiar_datos(db_path: Path) -> dict[str, int]:
+    if not db_path.exists():
+        iniciar_historial_usuario()
+
+    deleted_by_table: dict[str, int] = {}
+    with sqlite3.connect(db_path) as conn:
+        conn.execute("PRAGMA foreign_keys = OFF")
+        tables = _obtener_tablas_usuario(conn)
+
+        for table_name in tables:
+            cur = conn.execute(f"DELETE FROM {table_name}")
+            deleted_by_table[table_name] = int(cur.rowcount or 0)
+
+        if "sqlite_sequence" in [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]:
+            conn.execute("DELETE FROM sqlite_sequence")
+
+        conn.commit()
+
+    return deleted_by_table
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Elimina todos los datos de la BDM (SQLite) del proyecto.")
+    parser.add_argument(
+        "--db-path",
+        type=Path,
+        default=HISTORY_DB_PATH,
+        help=f"Ruta de la base de datos (por defecto: {HISTORY_DB_PATH})",
+    )
+    args = parser.parse_args()
+
+    db_path = args.db_path.resolve()
+    deleted_by_table = limpiar_datos(db_path)
+
+    total = sum(deleted_by_table.values())
+    print(f"BD limpiada: {db_path}")
+    for table_name, count in deleted_by_table.items():
+        print(f"- {table_name}: {count} filas eliminadas")
+    print(f"Total eliminado: {total} filas")
+
+    iniciar_historial_usuario()
+    print("Esquema verificado (tablas e indices creados si no existian).")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

backend/scripts/verificar_recomendador.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Comprueba de forma automatica que el recomendador se comporta correctamente."""
+
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+import sqlite3
+import sys
+
+CURRENT_DIR = Path(__file__).resolve().parent
+BACKEND_DIR = CURRENT_DIR.parent
+if str(BACKEND_DIR) not in sys.path:
+    sys.path.insert(0, str(BACKEND_DIR))
+
+from config import HISTORY_DB_PATH
+from db import iniciar_historial_usuario
+from services.recommender_service import cargar_dataset_movies, recomendar_peliculas
+
+
+TEST_USER = "__test_algo__"
+EMPTY_USER = "__test_algo_sin_historial__"
+
+
+def _genres_of(row: dict) -> set[str]:
+    genres = str(row.get("genres", "")).split("|")
+    return {g.strip() for g in genres if g.strip() and g.strip() != "(no genres listed)"}
+
+
+def _limpiar_usuario(conn: sqlite3.Connection, user_id: str) -> None:
+    conn.execute("DELETE FROM historial_peliculas WHERE user_id = ?", (user_id,))
+    conn.execute("DELETE FROM eventos_emociones WHERE user_id = ?", (user_id,))
+    conn.execute("DELETE FROM ciclos_recomendaciones WHERE user_id = ?", (user_id,))
+
+
+def _insertar_historial_sintetico(conn: sqlite3.Connection, movies: list[dict], g1: str, g2: str) -> set[str]:
+    favoritas = []
+    for row in movies:
+        row_genres = _genres_of(row)
+        if g1 in row_genres or g2 in row_genres:
+            favoritas.append(row)
+        if len(favoritas) >= 10:
+            break
+
+    if len(favoritas) < 6:
+        raise RuntimeError("No hay suficientes peliculas para crear historial sintetico")
+
+    now = datetime.now(timezone.utc)
+    watched_ids: set[str] = set()
+    for idx, row in enumerate(favoritas):
+        movie_id = str(row.get("movieId", "")).strip()
+        if not movie_id:
+            continue
+        watched_ids.add(movie_id)
+        viewed_at = (now - timedelta(days=idx + 1)).isoformat()
+        conn.execute(
+            """
+            INSERT INTO historial_peliculas (user_id, movie_id, title, emotion, user_rating, session_text, viewed_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                TEST_USER,
+                movie_id,
+                str(row.get("title", "")),
+                "tristeza",
+                4.5,
+                "historial sintetico",
+                viewed_at,
+            ),
+        )
+
+    return watched_ids
+
+
+def _seleccionar_generos(movies: list[dict], min_pool: int = 30) -> tuple[str, str]:
+    counts: dict[str, int] = {}
+    for row in movies:
+        for g in _genres_of(row):
+            counts[g] = counts.get(g, 0) + 1
+
+    ranked = sorted(counts.items(), key=lambda x: x[1], reverse=True)
+    filtered = [g for g, n in ranked if n >= min_pool]
+    if len(filtered) < 2:
+        raise RuntimeError("No hay suficientes generos con masa critica en el dataset")
+    return filtered[0], filtered[1]
+
+
+def _ratio_inside(recs: list[dict], zona_confort: set[str]) -> float:
+    if not recs:
+        return 0.0
+    inside = 0
+    for row in recs:
+        if _genres_of(row) & zona_confort:
+            inside += 1
+    return inside / len(recs)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Valida el algoritmo de recomendacion con datos de prueba.")
+    parser.add_argument("--limit", type=int, default=5, help="Numero de recomendaciones por escenario")
+    parser.add_argument(
+        "--db-path",
+        type=Path,
+        default=HISTORY_DB_PATH,
+        help=f"Ruta de base de datos (por defecto: {HISTORY_DB_PATH})",
+    )
+    args = parser.parse_args()
+
+    iniciar_historial_usuario()
+    movies_df, media_global = cargar_dataset_movies()
+    if not movies_df:
+        print("ERROR: no se pudo cargar movies.csv para validar el recomendador")
+        return 1
+
+    db_path = args.db_path.resolve()
+    with sqlite3.connect(db_path) as conn:
+        _limpiar_usuario(conn, TEST_USER)
+        _limpiar_usuario(conn, EMPTY_USER)
+
+        g1, g2 = _seleccionar_generos(movies_df)
+        zona_confort = {g1, g2}
+        watched_ids = _insertar_historial_sintetico(conn, movies_df, g1, g2)
+        conn.commit()
+
+    recs_empty = recomendar_peliculas(
+        emotion_es="alegria",
+        user_id=EMPTY_USER,
+        limit=args.limit,
+        movies_df=movies_df,
+        media_global_ratings=media_global,
+    )
+    recs_pos = recomendar_peliculas(
+        emotion_es="alegria",
+        user_id=TEST_USER,
+        limit=args.limit,
+        movies_df=movies_df,
+        media_global_ratings=media_global,
+    )
+    recs_neg = recomendar_peliculas(
+        emotion_es="tristeza",
+        user_id=TEST_USER,
+        limit=args.limit,
+        movies_df=movies_df,
+        media_global_ratings=media_global,
+    )
+
+    empty_ok = len(recs_empty) == args.limit
+    pos_ok_len = len(recs_pos) == args.limit
+    neg_ok_len = len(recs_neg) == args.limit
+
+    pos_inside_ratio = _ratio_inside(recs_pos, zona_confort)
+    neg_inside_ratio = _ratio_inside(recs_neg, zona_confort)
+
+    recs_pos_ids = {str(r.get("movieId", "")).strip() for r in recs_pos}
+    seen_leak = bool(recs_pos_ids & watched_ids)
+
+    print("=== Verificacion recomendador ===")
+    print(f"Dataset cargado: {len(movies_df)} peliculas")
+    print(f"Zona de confort sintetica: {sorted(zona_confort)}")
+    print(f"Escenario sin historial: {len(recs_empty)} recomendaciones")
+    print(f"Escenario positivo (alegria): {len(recs_pos)} recomendaciones")
+    print(f"Escenario negativo (tristeza): {len(recs_neg)} recomendaciones")
+    print(f"Ratio recomendaciones dentro de zona (positivo): {pos_inside_ratio:.2f}")
+    print(f"Ratio recomendaciones dentro de zona (negativo): {neg_inside_ratio:.2f}")
+    print(f"Fuga de peliculas ya vistas (positivo): {seen_leak}")
+
+    checks = {
+        "sin_historial_limite": empty_ok,
+        "positivo_limite": pos_ok_len,
+        "negativo_limite": neg_ok_len,
+        "positivo_fuera_zona_predomina": pos_inside_ratio <= 0.50,
+        "negativo_dentro_zona_predomina": neg_inside_ratio >= 0.50,
+        "sin_fuga_vistas_en_positivo": not seen_leak,
+    }
+
+    failed = [name for name, ok in checks.items() if not ok]
+    exit_code = 0
+    if failed:
+        print("RESULTADO: FAIL")
+        print("Checks fallidos:")
+        for name in failed:
+            print(f"- {name}")
+        exit_code = 1
+    else:
+        print("RESULTADO: OK")
+
+    # Evita dejar datos sintéticos de test en la base de datos real.
+    with sqlite3.connect(db_path) as conn:
+        _limpiar_usuario(conn, TEST_USER)
+        _limpiar_usuario(conn, EMPTY_USER)
+        conn.commit()
+
+    return exit_code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

backend/services/recommender_service.py

@@ -356,7 +356,7 @@ def _score_emocional_ciclos(
         scores[movie_id] = (s + alpha) / (n + alpha + beta)
     return scores
 
-def _score_emo_peli(r: dict) -> float:
+def _score_emo_peli(r: dict, emotional_scores: dict[str, float]) -> float:
     mid = str(r.get("movieId", "")).strip()
     return float(emotional_scores.get(mid, 0.5))
         
@@ -439,7 +439,7 @@ def recomendar_peliculas(
             base,
             key=lambda r: (
                 _distancia_zona_confort(r, zona_confort, ranking_generos),
-                _score_emo_peli(r),
+                _score_emo_peli(r, emotional_scores),
                 _puntuacion_calidad_global(r, media_global_ratings),
             ),
             reverse=True,
@@ -452,7 +452,7 @@ def recomendar_peliculas(
         # Ordenar por calidad global
         ranked = sorted(
             base,
-            key=lambda r: (_score_emo_peli(r), _puntuacion_calidad_global(r, media_global_ratings)),
+            key=lambda r: (_score_emo_peli(r, emotional_scores), _puntuacion_calidad_global(r, media_global_ratings)),
             reverse=True,
         )
 

chatbot/src/App.vue

@@ -204,12 +204,19 @@ async function clearHistory() {
 @import url("https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,600;9..144,700&family=Space+Grotesk:wght@400;500;700&display=swap");
 
 :root {
-  --vs-bg-1: #0e1a2b;
-  --vs-bg-2: #10253d;
-  --vs-panel: #102033cc;
-  --vs-border: #3a5675;
-  --vs-text: #dbe7f5;
-  --vs-muted: #9fb3c8;
+  /* Variables para glassmorphism + VIP */
+  --vs-bg-1: #05070a;
+  --vs-bg-2: #0a0e27;
+  --vs-bg-3: #1a1f3a;
+  --vs-panel: rgba(30, 41, 82, 0.35);
+  --vs-panel-hover: rgba(30, 41, 82, 0.5);
+  --vs-border: rgba(212, 175, 55, 0.2);
+  --vs-text: #f0f6ff;
+  --vs-muted: #a8b8d0;
+  --vs-gold: #d4af37;
+  --vs-gold-glow: rgba(212, 175, 55, 0.4);
+  --vs-glass-blur: 30px;
+  --vs-glass-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
 }
 
 html,
@@ -220,21 +227,68 @@ body,
 
 body {
   margin: 0;
-  background:
-    radial-gradient(circle at 10% 20%, #103657 0%, transparent 35%),
-    radial-gradient(circle at 90% 0%, #3b2d58 0%, transparent 30%),
-    linear-gradient(140deg, var(--vs-bg-1), var(--vs-bg-2));
+  background: linear-gradient(135deg, #0a0e27 0%, #1a1f3a 50%, #0d1626 100%);
+  background-attachment: fixed;
   color: var(--vs-text);
+  overflow-x: hidden;
 }
 
 .sentimental-app {
   font-family: "Space Grotesk", "Segoe UI", sans-serif;
   color: var(--vs-text);
+  background: transparent;
 }
 
 .app-container {
-  max-width: 1280px;
+  max-width: 1400px;
   margin: 0 auto;
-  padding: 24px 16px 28px;
+  padding: 32px 20px 40px;
+  position: relative;
+}
+
+/* Efectos de fondo animado */
+@keyframes vipGlowPulse {
+  0%, 100% {
+    box-shadow: 0 0 30px rgba(212, 175, 55, 0.3), inset 0 0 30px rgba(212, 175, 55, 0.05);
+  }
+  50% {
+    box-shadow: 0 0 50px rgba(212, 175, 55, 0.5), inset 0 0 40px rgba(212, 175, 55, 0.1);
+  }
+}
+
+@keyframes liquidFlow {
+  0%, 100% {
+    transform: translateY(0);
+  }
+  50% {
+    transform: translateY(-2px);
+  }
+}
+
+/* Decoraciones VIP */
+.app-container::before {
+  content: '';
+  position: fixed;
+  top: -50%;
+  right: -10%;
+  width: 600px;
+  height: 600px;
+  background: radial-gradient(circle, rgba(212, 175, 55, 0.15) 0%, transparent 70%);
+  border-radius: 50%;
+  pointer-events: none;
+  z-index: 0;
+}
+
+.app-container::after {
+  content: '';
+  position: fixed;
+  bottom: -20%;
+  left: -5%;
+  width: 500px;
+  height: 500px;
+  background: radial-gradient(circle, rgba(102, 126, 234, 0.1) 0%, transparent 70%);
+  border-radius: 50%;
+  pointer-events: none;
+  z-index: 0;
 }
 </style>

chatbot/src/components/AppHero.vue

@@ -36,25 +36,62 @@ defineProps({
 
 <style scoped>
 .hero {
-  border: 1px solid color-mix(in srgb, var(--vs-border), transparent 55%);
-  background: linear-gradient(135deg, var(--vs-glass-bg-a), var(--vs-glass-bg-b));
-  box-shadow: var(--vs-glass-shadow);
-  backdrop-filter: blur(14px) saturate(130%);
-  -webkit-backdrop-filter: blur(14px) saturate(130%);
+  position: relative;
+  overflow: hidden;
+  border: 2px solid var(--vs-border);
+  background: linear-gradient(135deg, rgba(26, 31, 58, 0.5) 0%, rgba(30, 41, 82, 0.4) 100%);
+  box-shadow: 
+    0 8px 32px rgba(212, 175, 55, 0.15),
+    inset 0 0 50px rgba(212, 175, 55, 0.05),
+    0 0 0 1px rgba(212, 175, 55, 0.1);
+  backdrop-filter: blur(30px) saturate(150%);
+  -webkit-backdrop-filter: blur(30px) saturate(150%);
+  animation: vipGlowPulse 6s ease-in-out infinite;
+}
+
+@keyframes vipGlowPulse {
+  0%, 100% {
+    box-shadow: 
+      0 8px 32px rgba(212, 175, 55, 0.15),
+      inset 0 0 50px rgba(212, 175, 55, 0.05),
+      0 0 0 1px rgba(212, 175, 55, 0.1);
+  }
+  50% {
+    box-shadow: 
+      0 8px 32px rgba(212, 175, 55, 0.3),
+      inset 0 0 50px rgba(212, 175, 55, 0.1),
+      0 0 30px rgba(212, 175, 55, 0.2);
+  }
 }
 
 .hero::before {
-  background:
-    radial-gradient(600px 220px at 20% 0%,
-      rgba(255,255,255,0.65),
-      rgba(255,255,255,0) 60%),
-    repeating-linear-gradient(
-      45deg,
-      var(--vs-glass-stripe) 0,
-      var(--vs-glass-stripe) 1px,
-      transparent 1px,
-      transparent 12px
-    );
+  content: '';
+  position: absolute;
+  top: -50%;
+  right: -10%;
+  width: 300px;
+  height: 300px;
+  background: radial-gradient(circle, rgba(212, 175, 55, 0.3) 0%, transparent 70%);
+  border-radius: 50%;
+  pointer-events: none;
+  animation: liquidFlow 8s ease-in-out infinite;
+}
+
+.hero::after {
+  content: '';
+  position: absolute;
+  bottom: -30%;
+  left: -5%;
+  width: 250px;
+  height: 250px;
+  background: radial-gradient(circle, rgba(102, 126, 234, 0.2) 0%, transparent 70%);
+  border-radius: 50%;
+  pointer-events: none;
+}
+
+@keyframes liquidFlow {
+  0%, 100% { transform: translate(0, 0); }
+  50% { transform: translate(10px, -10px); }
 }
 
 .hero-top {
@@ -62,30 +99,62 @@ defineProps({
   align-items: center;
   justify-content: space-between;
   gap: 16px;
+  position: relative;
+  z-index: 1;
 }
 
 .kicker {
   margin: 0;
-  letter-spacing: 0.06em;
+  letter-spacing: 0.1em;
   text-transform: uppercase;
-  font-size: 0.72rem;
-  font-weight: 650;
-  color: color-mix(in srgb, #b45309, #000 10%); /* ámbar más “ink” */
+  font-size: 0.75rem;
+  font-weight: 700;
+  background: linear-gradient(90deg, #d4af37 0%, #f4e4c1 50%, #d4af37 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
 }
 
 .hero-title {
-  margin: 6px 0 0;
+  margin: 8px 0 0;
   font-family: "Fraunces", serif;
-  font-size: clamp(1.55rem, 3vw, 2.15rem);
-  line-height: 1.1;
-  color: color-mix(in srgb, #0f172a, transparent 5%);
+  font-size: clamp(1.8rem, 4vw, 2.4rem);
+  line-height: 1.2;
+  background: linear-gradient(135deg, #f0f6ff 0%, #d4af37 50%, #f0f6ff 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+  font-weight: 700;
+  text-shadow: 0 0 30px rgba(212, 175, 55, 0.3);
 }
 
 .hero-subtitle {
-  margin: 14px 0 0;
+  margin: 16px 0 16px;
   max-width: 74ch;
-  color: color-mix(in srgb, #0f172a, transparent 35%);
-  line-height: 1.55;
+  color: var(--vs-muted);
+  line-height: 1.6;
+  position: relative;
+  z-index: 1;
+}
+
+:deep(.v-chip) {
+  background: linear-gradient(135deg, rgba(212, 175, 55, 0.2), rgba(212, 175, 55, 0.1)) !important;
+  border: 1px solid var(--vs-gold) !important;
+  color: var(--vs-gold) !important;
+  font-weight: 600;
+  box-shadow: 0 0 15px rgba(212, 175, 55, 0.3);
+}
+
+:deep(.v-btn) {
+  background: linear-gradient(135deg, #667eea, #764ba2) !important;
+  color: white !important;
+  box-shadow: 0 8px 20px rgba(102, 126, 234, 0.4);
+  transition: all 0.3s ease;
+}
+
+:deep(.v-btn):hover {
+  box-shadow: 0 12px 30px rgba(102, 126, 234, 0.6);
+  transform: translateY(-2px);
 }
 
 @media (max-width: 960px) {
@@ -93,5 +162,9 @@ defineProps({
     flex-direction: column;
     align-items: flex-start;
   }
+
+  .hero-title {
+    font-size: clamp(1.5rem, 3vw, 2rem);
+  }
 }
 </style>

chatbot/src/components/MessageComposer.vue

@@ -47,14 +47,50 @@ defineEmits(["update:input", "analyze"]);
 
 <style scoped>
 .composer-card {
-  border: 1px solid color-mix(in srgb, var(--vs-border), transparent 40%);
+  border: 1.5px solid var(--vs-border);
   background: var(--vs-panel);
-  backdrop-filter: blur(5px);
+  backdrop-filter: blur(20px) saturate(120%);
+  -webkit-backdrop-filter: blur(20px) saturate(120%);
+  box-shadow: 0 8px 32px rgba(212, 175, 55, 0.1), inset 0 0 30px rgba(212, 175, 55, 0.03);
+  transition: all 0.3s ease;
+}
+
+.composer-card:focus-within {
+  box-shadow: 0 8px 32px rgba(212, 175, 55, 0.2), inset 0 0 30px rgba(212, 175, 55, 0.08);
+  border-color: rgba(212, 175, 55, 0.4);
 }
 
 .composer-actions {
-  margin-top: 10px;
+  margin-top: 14px;
   display: flex;
   justify-content: flex-end;
+  gap: 10px;
+}
+
+:deep(.v-textarea) {
+  background: rgba(255, 255, 255, 0.02) !important;
+}
+
+:deep(.v-field__input) {
+  color: var(--vs-text) !important;
+  font-weight: 500;
+}
+
+:deep(.v-field__outline__start),
+:deep(.v-field__outline__end) {
+  border-color: rgba(212, 175, 55, 0.2) !important;
+}
+
+:deep(.v-btn) {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+  color: white !important;
+  box-shadow: 0 8px 20px rgba(102, 126, 234, 0.4);
+  font-weight: 600;
+  transition: all 0.3s ease;
+}
+
+:deep(.v-btn):hover:not(:disabled) {
+  box-shadow: 0 12px 30px rgba(102, 126, 234, 0.6);
+  transform: translateY(-2px);
 }
 </style>

chatbot/src/components/MessageFeed.vue

@@ -174,9 +174,11 @@ defineEmits(["mark-viewed", "update:input", "analyze"]);
 
 <style scoped>
 .chat-card {
-  border: 1px solid color-mix(in srgb, var(--vs-border), transparent 40%);
+  border: 1.5px solid var(--vs-border);
   background: var(--vs-panel);
-  backdrop-filter: blur(5px);
+  backdrop-filter: blur(20px) saturate(120%);
+  -webkit-backdrop-filter: blur(20px) saturate(120%);
+  box-shadow: 0 8px 32px rgba(212, 175, 55, 0.1), inset 0 0 30px rgba(212, 175, 55, 0.03);
 }
 
 .feed-scroll {
@@ -211,16 +213,21 @@ defineEmits(["mark-viewed", "update:input", "analyze"]);
 
 .user-bubble {
   max-width: 78%;
-  padding: 10px 14px;
-  background: linear-gradient(125deg, #f59e0b, #f97316);
+  padding: 12px 16px;
+  background: linear-gradient(135deg, #f59e0b, #f97316);
   color: #1f1100;
   font-weight: 600;
+  box-shadow: 0 8px 20px rgba(245, 158, 11, 0.4);
+  border-radius: 18px;
 }
 
 .result-card {
-  border: 1px solid #4f6882;
+  border: 1.5px solid;
   border-left: 4px solid;
-  background: #0f2135bf;
+  background: rgba(15, 33, 53, 0.5);
+  backdrop-filter: blur(15px) saturate(120%);
+  -webkit-backdrop-filter: blur(15px) saturate(120%);
+  box-shadow: 0 8px 32px rgba(212, 175, 55, 0.08), inset 0 0 25px rgba(212, 175, 55, 0.02);
 }
 
 .quoted-text {
@@ -266,8 +273,11 @@ defineEmits(["mark-viewed", "update:input", "analyze"]);
 
 .reco-list {
   border-radius: 12px;
-  padding: 6px;
-  background: #ffffff06;
+  padding: 8px;
+  background: rgba(255, 255, 255, 0.05);
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  border: 1px solid rgba(212, 175, 55, 0.1);
 }
 
 .reco-item {

chatbot/src/components/SidePanel.vue

@@ -69,9 +69,11 @@ const emit = defineEmits(["clear-history"]);
 
 <style scoped>
 .panel-card {
-  border: 1px solid color-mix(in srgb, var(--vs-border), transparent 40%);
+  border: 1.5px solid var(--vs-border);
   background: var(--vs-panel);
-  backdrop-filter: blur(5px);
+  backdrop-filter: blur(20px) saturate(120%);
+  -webkit-backdrop-filter: blur(20px) saturate(120%);
+  box-shadow: 0 8px 32px rgba(212, 175, 55, 0.1), inset 0 0 30px rgba(212, 175, 55, 0.03);
 }
 
 .panel-title {
@@ -88,8 +90,18 @@ const emit = defineEmits(["clear-history"]);
 
 .history-item {
   border-radius: 10px;
-  margin-bottom: 3px;
-  background: #ffffff05;
+  margin-bottom: 6px;
+  background: rgba(255, 255, 255, 0.05);
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  border: 1px solid rgba(212, 175, 55, 0.1);
+  transition: all 0.3s ease;
+}
+
+.history-item:hover {
+  background: rgba(255, 255, 255, 0.08);
+  border-color: rgba(212, 175, 55, 0.2);
+  box-shadow: 0 4px 12px rgba(212, 175, 55, 0.1);
 }
 
 .history-movie {

chatbot/src/main.js

@@ -6,33 +6,105 @@ import { createVuetify } from "vuetify";
 import * as components from "vuetify/components";
 import * as directives from "vuetify/directives";
 
+// Estilos globales glassmorphism + liquid + VIP
+const globalStyles = document.createElement("style");
+globalStyles.textContent = `
+  :root {
+    /* Colores VIP - Dorado y Plateado */
+    --vip-gold: #d4af37;
+    --vip-gold-light: #f4e4c1;
+    --vip-silver: #c0c0c0;
+    --vip-platinum: #e8e8e8;
+    
+    /* Glassmorphism */
+    --glass-blur: 25px;
+    --glass-opacity: 0.25;
+    --glass-border: 1px solid rgba(255, 255, 255, 0.18);
+    
+    /* Colores modernos */
+    --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    --secondary-gradient: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    --accent-gold: #d4af37;
+    --dark-bg: #0a0e27;
+    --darker-bg: #05070a;
+  }
+
+  * {
+    box-sizing: border-box;
+  }
+
+  html, body {
+    margin: 0;
+    padding: 0;
+    overflow-x: hidden;
+  }
+
+  body {
+    background: linear-gradient(135deg, #0a0e27 0%, #1a1f3a 50%, #0d1626 100%);
+    background-attachment: fixed;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+    color: #f0f0f0;
+  }
+
+  /* Animación de fondo animado */
+  @keyframes gradientShift {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+  }
+
+  /* Efecto glow VIP */
+  @keyframes vipGlow {
+    0%, 100% { box-shadow: 0 0 20px rgba(212, 175, 55, 0.5), inset 0 0 20px rgba(212, 175, 55, 0.1); }
+    50% { box-shadow: 0 0 40px rgba(212, 175, 55, 0.8), inset 0 0 30px rgba(212, 175, 55, 0.2); }
+  }
+
+  /* Efecto liquid */
+  @keyframes liquidFlow {
+    0%, 100% { transform: translateY(0px) rotate(0deg); }
+    50% { transform: translateY(-4px) rotate(1deg); }
+  }
+
+  .v-app {
+    background: transparent !important;
+  }
+`;
+document.head.appendChild(globalStyles);
+
 const vuetify = createVuetify({
-	components,
-	directives,
-	theme: {
-		defaultTheme: "sentimental",
-		defaultTheme: 'vsLight',
+  components,
+  directives,
+  theme: {
+    defaultTheme: 'vsDark',
     themes: {
       vsLight: {
         dark: false,
         colors: {
           background: '#f6f7fb',
           surface: '#ffffff',
-          primary: '#3b82f6',
+          primary: '#667eea',
+          secondary: '#d4af37',
         },
       },
       vsDark: {
         dark: true,
         colors: {
-          background: '#0b1220',
-          surface: '#0f172a',
-          primary: '#60a5fa',
+          background: '#0a0e27',
+          surface: 'rgba(30, 41, 82, 0.4)',
+          primary: '#667eea',
+          secondary: '#d4af37',
+          accent: '#764ba2',
+          error: '#f5576c',
+          warning: '#d4af37',
+          info: '#667eea',
+          success: '#11bc9d',
         },
       },
-	},
-	icons: {
-		defaultSet: "mdi",
-	},
+    },
+  },
+  icons: {
+    defaultSet: "mdi",
+  },
 });
 
 createApp(App).use(vuetify).mount("#root");

data/download_movielens_large.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import argparse
+import shutil
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from urllib.request import urlretrieve
+from zipfile import ZipFile
+
+MOVIELENS_LARGE_URL = "https://files.grouplens.org/datasets/movielens/ml-latest.zip"
+
+
+def download_zip(url: str, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    print(f"Descargando: {url}")
+    urlretrieve(url, destination)
+    print(f"Archivo descargado en: {destination}")
+
+
+def extract_csv_files(zip_path: Path, output_dir: Path) -> list[Path]:
+    extracted_csvs: list[Path] = []
+
+    with ZipFile(zip_path, "r") as archive:
+        csv_members = [m for m in archive.namelist() if m.lower().endswith(".csv")]
+        if not csv_members:
+            raise RuntimeError("El ZIP no contiene archivos CSV.")
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        for member in csv_members:
+            filename = Path(member).name
+            target_path = output_dir / filename
+
+            with archive.open(member) as src, open(target_path, "wb") as dst:
+                shutil.copyfileobj(src, dst)
+
+            extracted_csvs.append(target_path)
+
+    return extracted_csvs
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Descarga y extrae los CSV de MovieLens (version grande: ml-latest)."
+    )
+    parser.add_argument(
+        "--url",
+        default=MOVIELENS_LARGE_URL,
+        help="URL del dataset ZIP de MovieLens.",
+    )
+    parser.add_argument(
+        "--output",
+        default=str(Path(__file__).resolve().parent / "ml-latest"),
+        help="Directorio donde se guardaran los CSV extraidos.",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Si se indica, elimina los CSV existentes y vuelve a descargarlos.",
+    )
+
+    args = parser.parse_args()
+    output_dir = Path(args.output).resolve()
+
+    if args.force and output_dir.exists():
+        for csv_file in output_dir.glob("*.csv"):
+            csv_file.unlink()
+
+    existing_csvs = list(output_dir.glob("*.csv")) if output_dir.exists() else []
+    if existing_csvs and not args.force:
+        print(f"Ya existen {len(existing_csvs)} CSV en: {output_dir}")
+        print("Usa --force para volver a descargarlos.")
+        return
+
+    with NamedTemporaryFile(suffix=".zip", delete=False) as temp_file:
+        temp_zip = Path(temp_file.name)
+
+    try:
+        download_zip(args.url, temp_zip)
+        extracted = extract_csv_files(temp_zip, output_dir)
+        print(f"CSV extraidos en: {output_dir}")
+        print(f"Total de archivos: {len(extracted)}")
+    finally:
+        temp_zip.unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    main()