Add hierarchical menu navigation from Excel

api/main.py

@@ -20,6 +20,7 @@ if project_root not in sys.path:
 from config.settings import settings, print_config_summary
 from config.models import ChatRequest, ChatResponse, FeedbackRequest
 from rag.core import RAGSystem
+from data.build_menu_json import build_menu_json, load_menu_json
 
 # Configurar logging
 logging.basicConfig(level=logging.INFO)
@@ -50,6 +51,9 @@ rag_system = RAGSystem()
 feedback_store = {}
 conversation_store = {}
 
+# Estado del menú jerárquico
+app.state.menu = {}
+
 # Montar archivos estáticos
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
@@ -57,14 +61,38 @@ app.mount("/static", StaticFiles(directory="static"), name="static")
 async def startup_event():
     """Inicializar sistema al arrancar"""
     try:
-        print_config_summary()  # <-- MUESTRA CONFIGURACIÓN
+        print_config_summary()
+        
         # Cargar intents
         rag_system.load_intents("data/intents.json")
+        
+        # Cargar o generar menú jerárquico
+        menu_json_path = "data/menu.json"
+        excel_path = "data/Navegación Jerárquica_FER.xlsx"
+        
+        if os.path.exists(menu_json_path):
+            app.state.menu = load_menu_json(menu_json_path)
+            logger.info(f"✅ Menú cargado desde: {menu_json_path}")
+            logger.info(f"   Categorías: {len(app.state.menu)}")
+        elif os.path.exists(excel_path):
+            logger.info("📋 Generando menú desde Excel...")
+            if build_menu_json(excel_path, menu_json_path):
+                app.state.menu = load_menu_json(menu_json_path)
+                logger.info(f"✅ Menú generado y cargado: {len(app.state.menu)} categorías")
+            else:
+                logger.warning("⚠️ No se pudo generar el menú desde Excel")
+                app.state.menu = {}
+        else:
+            logger.warning(f"⚠️ Archivo Excel no encontrado: {excel_path}")
+            logger.warning("   El menú jerárquico no estará disponible")
+            app.state.menu = {}
+        
         logger.info("Sistema RAG inicializado correctamente")
         logger.info("Interfaz web disponible en: http://localhost:8000")
         logger.info("API Docs disponible en: http://localhost:8000/api/docs")
     except Exception as e:
         logger.error(f"Error inicializando RAG: {e}")
+        app.state.menu = {}
 
 @app.get("/")
 async def root():
@@ -231,6 +259,13 @@ async def get_rag_stats():
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/menu")
+async def get_menu():
+    """Endpoint para obtener la estructura del menú jerárquico"""
+    if hasattr(app.state, 'menu') and app.state.menu:
+        return {"menu": app.state.menu}
+    return {"menu": {}}
+
 if __name__ == "__main__":
     import uvicorn
     logger.info(f"🚀 Iniciando servidor en {settings.API_HOST}:{settings.API_PORT}")

data/build_menu_json.py

@@ -0,0 +1,206 @@
+"""
+Script para construir el archivo JSON del menú desde un Excel.
+
+Lee todas las hojas del archivo Excel y las convierte en una estructura
+jerárquica JSON con: Categoría → Subcategoría → Pregunta → Respuesta.
+"""
+
+import os
+import json
+import logging
+from typing import Dict, List, Any, Optional
+
+import pandas as pd
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def normalize_column_name(col: str) -> str:
+    """
+    Normaliza nombres de columnas para coincidir con los esperados.
+    
+    Args:
+        col: Nombre original de la columna
+        
+    Returns:
+        Nombre normalizado en minúsculas sin acentos
+    """
+    col_lower = col.lower().strip()
+    mapping = {
+        'categoría': 'categoria',
+        'subcategoría': 'subcategoria',
+        'asunto': 'asunto',
+        'solución': 'solucion',
+        'pregunta': 'solucion',
+        'respuesta': 'respuesta',
+        'url': 'url',
+        'formato': 'formato',
+        'etiquetas': 'etiquetas',
+    }
+    return mapping.get(col_lower, col_lower)
+
+
+def get_column_value(row: pd.Series, possible_names: List[str]) -> Optional[str]:
+    """
+    Obtiene el valor de una columna probando múltiples nombres posibles.
+    
+    Args:
+        row: Fila del DataFrame
+        possible_names: Lista de nombres de columna posibles
+        
+    Returns:
+        Valor de la columna o None si no se encuentra
+    """
+    for col_name in possible_names:
+        if col_name in row.index and pd.notna(row[col_name]):
+            return str(row[col_name]).strip()
+    return None
+
+
+def extract_additional_columns(row: pd.Series) -> Dict[str, Any]:
+    """
+    Extrae columnas adicionales como metadatos.
+    
+    Args:
+        row: Fila del DataFrame
+        
+    Returns:
+        Diccionario con columnas adicionales
+    """
+    main_columns = {'categoria', 'subcategoria', 'asunto', 'solucion', 'respuesta'}
+    additional = {}
+    
+    for col in row.index:
+        col_normalized = normalize_column_name(col)
+        if col_normalized not in main_columns and pd.notna(row[col]):
+            additional[col_normalized] = str(row[col]).strip()
+    
+    return additional
+
+
+def build_menu_json(excel_path: str, output_json_path: str) -> bool:
+    """
+    Lee el archivo Excel y genera el JSON del menú.
+    
+    Args:
+        excel_path: Ruta al archivo Excel
+        output_json_path: Ruta donde se guardará el JSON
+        
+    Returns:
+        True si se generó correctamente, False si hubo errores
+    """
+    if not os.path.exists(excel_path):
+        logger.warning(f"⚠️ Archivo Excel no encontrado: {excel_path}")
+        return False
+    
+    try:
+        logger.info(f"📊 Leyendo Excel: {excel_path}")
+        
+        excel_file = pd.ExcelFile(excel_path)
+        sheet_names = excel_file.sheet_names
+        logger.info(f"📋 Hojas encontradas: {sheet_names}")
+        
+        menu_structure = {}
+        
+        for sheet_name in sheet_names:
+            try:
+                logger.info(f"  → Procesando hoja: {sheet_name}")
+                
+                df = pd.read_excel(excel_file, sheet_name=sheet_name)
+                
+                if df.empty:
+                    logger.warning(f"  ⚠️ Hoja vacía: {sheet_name}")
+                    continue
+                
+                category_name = sheet_name.strip()
+                subcategories: Dict[str, List[Dict]] = {}
+                
+                for idx, row in df.iterrows():
+                    subcategory = get_column_value(row, ['subcategoria', 'asunto', 'categoría', 'subcategoría'])
+                    question = get_column_value(row, ['solucion', 'pregunta', 'solución', 'pregunta'])
+                    answer = get_column_value(row, ['respuesta'])
+                    
+                    if not question or not answer:
+                        continue
+                    
+                    subcat_key = subcategory if subcategory else "General"
+                    
+                    if subcat_key not in subcategories:
+                        subcategories[subcat_key] = []
+                    
+                    question_data = {
+                        "question": question,
+                        "answer": answer,
+                    }
+                    
+                    additional_cols = extract_additional_columns(row)
+                    if additional_cols:
+                        question_data["metadata"] = additional_cols
+                    
+                    subcategories[subcat_key].append(question_data)
+                
+                if subcategories:
+                    menu_structure[category_name] = subcategories
+                    logger.info(f"    ✓ Categoría '{category_name}': {len(subcategories)} subcategorías")
+                else:
+                    logger.warning(f"    ⚠️ Sin datos válidos: {sheet_name}")
+                    
+            except Exception as e:
+                logger.error(f"  ❌ Error procesando hoja '{sheet_name}': {e}")
+                continue
+        
+        if not menu_structure:
+            logger.warning("⚠️ No se generó ninguna categoría")
+            return False
+        
+        os.makedirs(os.path.dirname(output_json_path), exist_ok=True)
+        
+        with open(output_json_path, 'w', encoding='utf-8') as f:
+            json.dump(menu_structure, f, ensure_ascii=False, indent=2)
+        
+        logger.info(f"✅ JSON guardado en: {output_json_path}")
+        logger.info(f"   Categorías: {len(menu_structure)}")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Error general al generar JSON: {e}")
+        return False
+
+
+def load_menu_json(json_path: str) -> Dict[str, Any]:
+    """
+    Carga el menú desde el archivo JSON.
+    
+    Args:
+        json_path: Ruta al archivo JSON
+        
+    Returns:
+        Diccionario con la estructura del menú
+    """
+    if not os.path.exists(json_path):
+        return {}
+    
+    try:
+        with open(json_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"❌ Error cargando JSON: {e}")
+        return {}
+
+
+if __name__ == "__main__":
+    excel_path = "data/Navegación Jerárquica_FER.xlsx"
+    output_path = "data/menu.json"
+    
+    logger.info("🚀 Iniciando generación de menú JSON")
+    
+    success = build_menu_json(excel_path, output_path)
+    
+    if success:
+        logger.info("✅ Proceso completado")
+        menu = load_menu_json(output_path)
+        logger.info(f"Estructura: {json.dumps(menu, ensure_ascii=False, indent=2)[:500]}...")
+    else:
+        logger.error("❌ Proceso fallido")

requirements.txt

@@ -51,6 +51,12 @@ tiktoken==0.5.1
 psutil==5.9.8
 pynvml==11.5.0  # Para monitorear GPU NVIDIA
 
+# ============================================
+# Excel and Data Processing
+# ============================================
+openpyxl==3.1.2
+pandas==2.0.3
+
 # Serialización (para guardar/recuperar índices)
 joblib==1.3.2
 

static/index.html

@@ -123,6 +123,144 @@
             transform: translateX(5px);
         }
 
+        /* Menú jerárquico */
+        .menu-section {
+            margin-top: 20px;
+            border-top: 1px solid rgba(255, 255, 255, 0.1);
+            padding-top: 20px;
+        }
+
+        .menu-section h3 {
+            margin-bottom: 15px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .menu-container {
+            max-height: 300px;
+            overflow-y: auto;
+        }
+
+        .menu-category {
+            margin-bottom: 8px;
+        }
+
+        .menu-btn {
+            width: 100%;
+            background: rgba(255, 255, 255, 0.15);
+            border: none;
+            border-radius: 8px;
+            padding: 12px;
+            color: white;
+            cursor: pointer;
+            text-align: left;
+            font-size: 14px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: all 0.3s;
+        }
+
+        .menu-btn:hover {
+            background: rgba(255, 255, 255, 0.25);
+            transform: translateX(5px);
+        }
+
+        .menu-btn.active {
+            background: var(--accent-color);
+        }
+
+        .menu-btn i {
+            transition: transform 0.3s;
+        }
+
+        .menu-btn.expanded i {
+            transform: rotate(90deg);
+        }
+
+        .menu-subcategory {
+            display: none;
+            margin-left: 20px;
+            margin-top: 5px;
+        }
+
+        .menu-subcategory.visible {
+            display: block;
+        }
+
+        .menu-question {
+            display: none;
+            margin-left: 20px;
+            margin-top: 5px;
+        }
+
+        .menu-question.visible {
+            display: block;
+        }
+
+        .subcategory-btn {
+            width: 100%;
+            background: rgba(255, 255, 255, 0.1);
+            border: none;
+            border-radius: 6px;
+            padding: 10px;
+            color: white;
+            cursor: pointer;
+            text-align: left;
+            font-size: 13px;
+            margin-bottom: 5px;
+            transition: all 0.3s;
+        }
+
+        .subcategory-btn:hover {
+            background: rgba(255, 255, 255, 0.2);
+        }
+
+        .question-btn {
+            width: 100%;
+            background: rgba(26, 188, 156, 0.2);
+            border: 1px solid rgba(26, 188, 156, 0.3);
+            border-radius: 6px;
+            padding: 8px 10px;
+            color: white;
+            cursor: pointer;
+            text-align: left;
+            font-size: 12px;
+            margin-bottom: 4px;
+            transition: all 0.3s;
+        }
+
+        .question-btn:hover {
+            background: rgba(26, 188, 156, 0.4);
+        }
+
+        .menu-back-btn {
+            background: rgba(255, 255, 255, 0.1);
+            border: none;
+            border-radius: 6px;
+            padding: 8px 12px;
+            color: white;
+            cursor: pointer;
+            font-size: 13px;
+            margin-bottom: 10px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: all 0.3s;
+        }
+
+        .menu-back-btn:hover {
+            background: rgba(255, 255, 255, 0.2);
+        }
+
+        .menu-empty {
+            text-align: center;
+            padding: 20px;
+            color: rgba(255, 255, 255, 0.6);
+            font-size: 14px;
+        }
+
         /* Área principal del chat */
         .main-content {
             flex: 1;
@@ -415,6 +553,13 @@
                     ¿Cuál es el proceso de reingreso?
                 </div>
             </div>
+
+            <div class="menu-section">
+                <h3><i class="fas fa-folder-tree"></i> Navegación por Temas</h3>
+                <div id="menuContainer" class="menu-container">
+                    <div class="menu-empty">Cargando menú...</div>
+                </div>
+            </div>
         </div>
 
         <!-- Área principal -->
@@ -474,6 +619,11 @@
         let messageCount = 0;
         let ragResponseCount = 0;
         let totalConfidence = 0;
+        
+        // Estado del menú jerárquico
+        let menuData = {};
+        let currentCategory = null;
+        let currentSubcategory = null;
 
         // Inicialización
         document.addEventListener('DOMContentLoaded', function() {
@@ -487,6 +637,9 @@
             // Cargar estadísticas iniciales
             loadStats();
             
+            // Cargar menú jerárquico
+            loadMenu();
+            
             // Enfocar el input
             document.getElementById('messageInput').focus();
         });
@@ -759,6 +912,130 @@
             }
         }
 
+        // Cargar menú jerárquico
+        async function loadMenu() {
+            try {
+                const response = await fetch(`${API_URL}/menu`);
+                if (response.ok) {
+                    const data = await response.json();
+                    menuData = data.menu || {};
+                    renderMenuCategories();
+                } else {
+                    document.getElementById('menuContainer').innerHTML = '<div class="menu-empty">Menú no disponible</div>';
+                }
+            } catch (error) {
+                console.error('Error cargando menú:', error);
+                document.getElementById('menuContainer').innerHTML = '<div class="menu-empty">Error al cargar menú</div>';
+            }
+        }
+
+        // Renderizar categorías
+        function renderMenuCategories() {
+            const container = document.getElementById('menuContainer');
+            
+            if (Object.keys(menuData).length === 0) {
+                container.innerHTML = '<div class="menu-empty">No hay temas disponibles</div>';
+                return;
+            }
+            
+            let html = '';
+            Object.keys(menuData).forEach(category => {
+                html += `
+                    <div class="menu-category">
+                        <button class="menu-btn" onclick="toggleCategory('${escapeHtml(category)}')">
+                            <i class="fas fa-chevron-right"></i>
+                            ${escapeHtml(category)}
+                        </button>
+                        <div class="menu-subcategory" id="subcat-${escapeHtml(category)}">
+                            ${renderSubcategories(category)}
+                        </div>
+                    </div>
+                `;
+            });
+            container.innerHTML = html;
+        }
+
+        // Renderizar subcategorías
+        function renderSubcategories(category) {
+            const subcategories = menuData[category];
+            let html = '';
+            
+            Object.keys(subcategories).forEach(subcat => {
+                const questions = subcategories[subcat];
+                html += `
+                    <button class="subcategory-btn" onclick="toggleSubcategory('${escapeHtml(category)}', '${escapeHtml(subcat)}')">
+                        <i class="fas fa-folder"></i> ${escapeHtml(subcat)} (${questions.length})
+                    </button>
+                    <div class="menu-question" id="ques-${escapeHtml(category)}-${escapeHtml(subcat)}">
+                        ${renderQuestions(category, subcat)}
+                    </div>
+                `;
+            });
+            
+            return html;
+        }
+
+        // Renderizar preguntas
+        function renderQuestions(category, subcategory) {
+            const questions = menuData[category][subcategory];
+            let html = '';
+            
+            questions.forEach((q, idx) => {
+                html += `
+                    <button class="question-btn" onclick="showAnswer('${escapeHtml(category)}', '${escapeHtml(subcategory)}', ${idx})">
+                        <i class="fas fa-question-circle"></i> ${escapeHtml(q.question)}
+                    </button>
+                `;
+            });
+            
+            return html;
+        }
+
+        // Alternar categoría
+        function toggleCategory(category) {
+            const subcatDiv = document.getElementById(`subcat-${category}`);
+            const btn = subcatDiv.previousElementSibling;
+            
+            subcatDiv.classList.toggle('visible');
+            btn.classList.toggle('expanded');
+        }
+
+        // Alternar subcategoría
+        function toggleSubcategory(category, subcategory) {
+            const quesDiv = document.getElementById(`ques-${category}-${subcategory}`);
+            quesDiv.classList.toggle('visible');
+        }
+
+        // Mostrar respuesta en el chat
+        function showAnswer(category, subcategory, questionIdx) {
+            const question = menuData[category][subcategory][questionIdx];
+            
+            const chatMessages = document.getElementById('chatMessages');
+            
+            // Crear mensaje del bot
+            const messageDiv = document.createElement('div');
+            messageDiv.className = 'message bot-message';
+            
+            const contentDiv = document.createElement('div');
+            contentDiv.className = 'message-content';
+            contentDiv.innerHTML = `
+                <strong><i class="fas fa-folder-tree"></i> Asistente:</strong><br>
+                <span style="font-size: 12px; color: var(--accent-color);">Tema: ${escapeHtml(category)} > ${escapeHtml(subcategory)}</span><br><br>
+                <strong>Pregunta:</strong> ${escapeHtml(question.question)}<br><br>
+                <strong>Respuesta:</strong><br>${escapeHtml(question.answer)}
+            `;
+            
+            const timeDiv = document.createElement('div');
+            timeDiv.className = 'message-time';
+            timeDiv.textContent = getCurrentTime();
+            
+            messageDiv.appendChild(contentDiv);
+            messageDiv.appendChild(timeDiv);
+            chatMessages.appendChild(messageDiv);
+            
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
         // Seguridad: escapar HTML
         function escapeHtml(text) {
             const div = document.createElement('div');