Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+imagenes/Tu[[:space:]]mundo[[:space:]]en[[:space:]]una[[:space:]]servilleta[[:space:]]-[[:space:]]Dan[[:space:]]Roam.png filter=lfs diff=lfs merge=lfs -text

GD App.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:427cf83a082b68de1b06e51867e4d59a0d40735e34b09c6e21039a5868cec8e4
+size 204791

bookbot.py

@@ -0,0 +1,364 @@
+import streamlit as st
+import os
+import requests
+import base64
+from typing import List, Dict
+
+# Configuración de la aplicación
+st.set_page_config(
+    page_title="Biblioteca de Resúmenes de Libros", 
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Función para cargar imagen y codificarla en base64
+def get_image_base64(image_path):
+    """Carga una imagen y la convierte a base64 para mostrarla"""
+    try:
+        with open(image_path, "rb") as img_file:
+            return base64.b64encode(img_file.read()).decode()
+    except Exception:
+        return None
+
+# CSS personalizado para un diseño moderno y minimalista
+def apply_custom_css():
+    st.markdown("""
+    <style>
+        /* Estilos generales */
+        .main {
+            padding: 2rem 3rem;
+            background-color: #f8f9fa;
+        }
+        
+        /* Título principal */
+        .main h1 {
+            color: #1E3A8A;
+            font-size: 2.5rem;
+            font-weight: 600;
+            margin-bottom: 2rem;
+        }
+        
+        /* Subtítulos */
+        .main h2, .main h3 {
+            color: #1E3A8A;
+            font-weight: 500;
+        }
+        
+        /* Contenedor de chat */
+        .chat-container {
+            background-color: white;
+            border-radius: 8px;
+            padding: 20px;
+            margin-top: 20px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+        }
+        
+        /* Mensajes del usuario */
+        .user-message {
+            background-color: #E7F3FF;
+            border-radius: 15px 15px 0 15px;
+            padding: 10px 15px;
+            margin: 10px 0;
+            max-width: 80%;
+            align-self: flex-end;
+            margin-left: auto;
+        }
+        
+        /* Mensajes del asistente */
+        .assistant-message {
+            background-color: #F0F0F0;
+            border-radius: 15px 15px 15px 0;
+            padding: 10px 15px;
+            margin: 10px 0;
+            max-width: 80%;
+        }
+        
+        /* Campo de entrada de texto */
+        .stTextInput input {
+            border-radius: 20px;
+            border: 1px solid #E0E0E0;
+            padding: 10px 15px;
+            font-size: 1rem;
+        }
+        
+        /* Tarjeta del libro */
+        .book-card {
+            background-color: white;
+            border-radius: 8px;
+            padding: 15px;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+            margin-bottom: 20px;
+        }
+        
+        /* Imagen del libro */
+        .book-image {
+            width: 100%;
+            border-radius: 4px;
+            margin-bottom: 15px;
+        }
+        
+        /* Separador */
+        hr {
+            margin: 1.5rem 0;
+            border: 0;
+            border-top: 1px solid #E0E0E0;
+        }
+        
+        /* Botón de envío */
+        .stButton button {
+            background-color: #1E3A8A;
+            color: white;
+            border-radius: 20px;
+            padding: 5px 20px;
+            font-weight: 500;
+            border: none;
+            transition: all 0.3s;
+        }
+        
+        .stButton button:hover {
+            background-color: #2563EB;
+            box-shadow: 0 4px 8px rgba(37, 99, 235, 0.2);
+        }
+        
+        /* Sidebar */
+        .sidebar .sidebar-content {
+            background-color: #F8F9FA;
+            padding: 20px;
+        }
+        
+        /* Título del sidebar */
+        .sidebar h2 {
+            color: #1E3A8A;
+            font-size: 1.5rem;
+            font-weight: 500;
+            margin-bottom: 1rem;
+        }
+    </style>
+    """, unsafe_allow_html=True)
+
+# Función para cargar resúmenes de libros desde archivos de texto
+def cargar_resumenes_libros(carpeta_libros: str) -> List[Dict[str, str]]:
+    """
+    Carga resúmenes de libros desde archivos de texto en una carpeta específica.
+    
+    Args:
+        carpeta_libros (str): Ruta de la carpeta que contiene los resúmenes de libros.
+    
+    Returns:
+        List[Dict[str, str]]: Lista de diccionarios con información de los libros.
+    """
+    resumenes = []
+    try:
+        # Verificar si la carpeta existe
+        if not os.path.exists(carpeta_libros):
+            st.error(f"La carpeta {carpeta_libros} no existe.")
+            return resumenes
+
+        # Listar archivos de texto en la carpeta
+        archivos = [f for f in os.listdir(carpeta_libros) if f.endswith('.txt')]
+        
+        if not archivos:
+            st.warning("No se encontraron archivos de resúmenes en la carpeta.")
+            return resumenes
+
+        # Cargar cada archivo de resumen
+        for archivo in archivos:
+            ruta_archivo = os.path.join(carpeta_libros, archivo)
+            try:
+                with open(ruta_archivo, 'r', encoding='utf-8') as f:
+                    # Extraer título del nombre del archivo (sin extensión)
+                    titulo = os.path.splitext(archivo)[0]
+                    # Leer contenido del archivo
+                    contenido = f.read().strip()
+                    
+                    # Extraer un breve resumen (primeros 200 caracteres)
+                    breve_resumen = contenido[:200] + "..." if len(contenido) > 200 else contenido
+                    
+                    # Agregar resumen a la lista
+                    resumenes.append({
+                        "titulo": titulo,
+                        "resumen": contenido,
+                        "breve_resumen": breve_resumen
+                    })
+            except Exception as e:
+                st.error(f"Error al leer el archivo {archivo}: {str(e)}")
+
+    except Exception as e:
+        st.error(f"Error al cargar los resúmenes: {str(e)}")
+    
+    return resumenes
+
+# Configuración de la API de Hugging Face
+API_URL = "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+
+# Inicializar la sesión state para el historial de chat si no existe
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+
+# Función para obtener la API key de Hugging Face desde secrets
+@st.cache_resource
+def get_huggingface_api_key():
+    """Obtener la API key de Hugging Face desde secrets"""
+    try:
+        # Intenta acceder al token usando la clave HF_TOKEN
+        return st.secrets["HF_TOKEN"]
+    except KeyError:
+        # Si no está disponible con esa clave, intenta el formato anterior
+        try:
+            return st.secrets["huggingface"]["api_key"]
+        except:
+            return None
+
+# Función para enviar solicitudes a la API de Hugging Face
+def query_huggingface(payload):
+    """Envía una solicitud a la API de Hugging Face y retorna la respuesta"""
+    api_key = get_huggingface_api_key()
+    if not api_key:
+        st.error("No se proporcionó una API key de Hugging Face.")
+        return None
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    try:
+        # Añadido verify=False para ignorar la verificación SSL
+        response = requests.post(API_URL, headers=headers, json=payload, timeout=60, verify=False)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.Timeout:
+        st.error("La solicitud a la API de Hugging Face ha excedido el tiempo de espera.")
+        return None
+    except requests.exceptions.HTTPError as e:
+        st.error(f"Error HTTP: {e.response.status_code} - {e.response.text}")
+        return None
+    except Exception as e:
+        st.error(f"Error al comunicarse con la API de Hugging Face: {str(e)}")
+        return None
+    
+# Interfaz principal de la aplicación
+def main():
+    # Aplicar CSS personalizado
+    apply_custom_css()
+    
+    # Título principal
+    st.title("📚 Biblioteca de Resúmenes de Libros")
+
+    # Cargar resúmenes de libros
+    carpeta_libros = "libros"  # Asegúrate de que esta carpeta exista en tu proyecto
+    resumenes = cargar_resumenes_libros(carpeta_libros)
+
+    # Verificar si se cargaron resúmenes
+    if not resumenes:
+        st.warning("No se pudieron cargar los resúmenes de libros.")
+        return
+
+    # Selector de libros (en la barra lateral)
+    with st.sidebar:
+        st.header("Selección de Libro")
+        titulos_libros = [libro["titulo"] for libro in resumenes]
+        libro_seleccionado = st.selectbox("Elige un libro para explorar", titulos_libros)
+        
+        # Encontrar la información del libro seleccionado
+        libro_actual = next(
+            (libro for libro in resumenes if libro["titulo"] == libro_seleccionado), 
+            None
+        )
+        
+        if libro_actual:
+            st.subheader("Resumen Breve")
+            st.markdown(f"<div class='sidebar-summary'>{libro_actual['breve_resumen']}</div>", unsafe_allow_html=True)
+            
+            # Información sobre el modelo
+            st.markdown("---")
+            st.caption("Asistente virtual potenciado por deepseek-ai/DeepSeek-R1-Distill-Qwen-32B")
+
+    # Contenido principal
+    if libro_actual:
+        col1, col2 = st.columns([1, 2])
+        
+        with col1:
+            # Mostrar imagen del libro (buscar en la carpeta "imagenes")
+            st.markdown("<div class='book-card'>", unsafe_allow_html=True)
+            
+            # Intentar cargar la imagen del libro
+            imagen_path = f"imagenes/{libro_seleccionado}.png"
+            if os.path.exists(imagen_path):
+                st.image(imagen_path, caption=libro_seleccionado, use_container_width=True)
+            else:
+                # Mostrar imagen de placeholder si no existe
+                st.error(f"Imagen no encontrada: {imagen_path}")
+                st.markdown("ℹ️ **Nota**: Asegúrate de tener una carpeta 'imagenes' con archivos PNG que coincidan con los nombres de tus libros.")
+            
+            st.markdown("</div>", unsafe_allow_html=True)
+        
+        with col2:
+            # Sección del chatbot
+            st.markdown("<div class='chat-container'>", unsafe_allow_html=True)
+            st.subheader("💬 Consulta sobre este libro")
+            
+            # Mostrar el historial de chat
+            for message in st.session_state.chat_history:
+                if message["role"] == "user":
+                    st.markdown(f"<div class='user-message'><strong>😀 Tú:</strong> {message['content']}</div>", unsafe_allow_html=True)
+                else:
+                    st.markdown(f"<div class='assistant-message'><strong>🤖 Asistente:</strong> {message['content']}</div>", unsafe_allow_html=True)
+            
+            # Crear el widget de entrada de usuario
+            user_input = st.text_input("", key="user_query", placeholder="Escribe tu pregunta sobre el libro...")
+            send_button = st.button("Enviar")
+            
+            # Procesar la entrada del usuario
+            if user_input and send_button:
+                # Preparar el contexto
+                context = f"""
+                CONTEXTO DEL LIBRO:
+                Título: {libro_seleccionado}
+                Resumen: {libro_actual['resumen']}
+                
+                PREGUNTA DEL USUARIO:
+                {user_input}
+                
+                Responde de manera concisa y precisa, basándote en el resumen y contexto del libro.
+                """
+                
+                # Mostrar un mensaje de espera personalizado con icono
+                with st.spinner("🧠 Pensando..."):
+                    # Llamar a la API de Hugging Face
+                    payload = {
+                        "inputs": context,
+                        "parameters": {
+                            "max_new_tokens": 250,
+                            "temperature": 0.7,
+                            "top_p": 0.9,
+                            "do_sample": True
+                        }
+                    }
+                    
+                    response = query_huggingface(payload)
+                    
+                    if response:
+                        # Extraer la respuesta del modelo
+                        if isinstance(response, list) and len(response) > 0:
+                            bot_response = response[0].get("generated_text", "")
+                            # Intentar extraer solo la respuesta del asistente
+                            try:
+                                bot_response = bot_response.split("Responde de manera concisa y precisa")[-1]
+                                if "PREGUNTA DEL USUARIO:" in bot_response:
+                                    bot_response = bot_response.split("PREGUNTA DEL USUARIO:")[-1]
+                                bot_response = bot_response.strip()
+                            except:
+                                # Si falla la extracción, usar la respuesta completa
+                                pass
+                        else:
+                            bot_response = str(response)
+                        
+                        # Agregar al historial de chat
+                        st.session_state.chat_history.append({"role": "user", "content": user_input})
+                        st.session_state.chat_history.append({"role": "assistant", "content": bot_response})
+                        
+                        # Recargar la página para mostrar la nueva respuesta
+                        st.experimental_rerun()
+            
+            st.markdown("</div>", unsafe_allow_html=True)
+
+# Ejecutar la aplicación principal
+if __name__ == "__main__":
+    main()

libros/Tu mundo en una servilleta - Dan Roam.txt

@@ -0,0 +1,49 @@
+"The Back of the Napkin" por Dan Roam
+Este resumen se centra en el marco de 6 preguntas, el SQVID y las estrategias visuales recomendadas en el libro "The Back of the Napkin" de Dan Roam para resolver problemas y vender ideas.
+
+El libro argumenta que el pensamiento visual, utilizando dibujos sencillos, es una herramienta poderosa para la resolución de problemas y la comunicación efectiva. Roam explica que cualquier problema se puede aclarar con una imagen, y cualquier imagen se puede crear utilizando un conjunto simple de herramientas y reglas. [1]
+
+El Marco de las 6 Preguntas (6W)
+Roam propone un marco de seis preguntas fundamentales, conocidas como las 6W, para analizar y abordar cualquier problema:
+
+Quién/Qué (Who/What): Define los actores y objetos involucrados.
+Cuánto (How Much): Analiza las cantidades, medidas y datos.
+Dónde (Where): Ubica el problema en un contexto espacial.
+Cuándo (When): Establece un marco temporal para el problema.
+Cómo (How): Describe los procesos y relaciones de causa y efecto.
+Por qué (Why): Explora las razones, motivaciones y causas subyacentes.
+Estas preguntas no solo ayudan a comprender el problema, sino que también guían la elección del gráfico o estrategia visual más efectiva para comunicarlo. [2, 3]
+
+El SQVID como Herramienta de Imaginación
+El SQVID es un acrónimo que representa cinco preguntas para activar la imaginación visual y explorar diferentes perspectivas de una idea:
+
+Simple (Simple) vs. Elaborado (Elaborate): ¿Se necesita una representación simple o detallada?
+Cualitativo (Qualitative) vs. Cuantitativo (Quantitative): ¿Se enfatizan las características o los datos numéricos?
+Visión (Vision) vs. Ejecución (Execution): ¿Se busca inspirar o mostrar los pasos concretos?
+Individual (Individual) vs. Comparación (Comparison): ¿Se presenta una sola idea o se compara con otras?
+Cambio (Change) vs. Status Quo: ¿Se propone una transformación o se describe la situación actual? [4, 5]
+Al responder estas preguntas, se pueden generar múltiples representaciones visuales de una idea y elegir la más efectiva para la audiencia y el objetivo. [5, 6]
+
+Gráficos y Estrategias Visuales Recomendadas
+El libro presenta seis marcos visuales principales, cada uno correspondiente a una de las 6W:
+
+Retrato (Portrait): Para mostrar quién/qué (ej. un organigrama, un diagrama de personajes) [7, 8]
+Gráfico (Chart): Para visualizar cuánto (ej. gráfico de barras, gráfico circular) [7, 8]
+Mapa (Map): Para representar dónde (ej. mapa mental, diagrama de flujo de procesos) [7, 8]
+Línea de Tiempo (Timeline): Para ilustrar cuándo (ej. cronograma, diagrama de Gantt) [7, 8]
+Diagrama de Flujo (Flowchart): Para explicar cómo (ej. diagrama de flujo de trabajo, algoritmo) [7, 8]
+Gráfico de Múltiples Variables (Multiple-variable Plot): Para analizar por qué (ej. gráfico de dispersión, mapa de calor) [7, 8]
+El libro ofrece ejemplos concretos y consejos prácticos para dibujar cada tipo de gráfico y adaptarlo al problema específico. [9]
+
+Combinando el Marco de 6W y el SQVID: El Codex
+El Codex de Pensamiento Visual es una herramienta que combina las 6W y el SQVID para guiar la creación de la imagen más efectiva. Permite seleccionar el marco visual adecuado (ej. mapa) y la versión más apropiada según el SQVID (ej. simple, cualitativo). [10-12]
+
+Consejos para "Mostrar y Contar"
+El libro también destaca la importancia de saber presentar las imágenes de manera efectiva. Se recomienda un proceso de "mostrar y contar" que implica:
+
+Mirar en Voz Alta (Looking Aloud): Guiar a la audiencia a través de los elementos visuales clave.
+Ver en Voz Alta (Seeing Aloud): Ayudar a la audiencia a interpretar la información visual y descubrir patrones.
+Imaginar en Voz Alta (Imagining Aloud): Fomentar la generación de ideas y soluciones a partir de la imagen.
+Mostrar en Voz Alta (Showing Aloud): Presentar la imagen como un punto de partida para la conversación y la toma de decisiones. [13-15]
+En resumen, "The Back of the Napkin" ofrece un enfoque práctico y accesible para utilizar el pensamiento visual como herramienta para la resolución de problemas y la comunicación efectiva en el mundo empresarial.
+

requirements.txt

@@ -0,0 +1,4 @@
+streamlit
+pandas
+plotly
+prophet