Update app.py

app.py

@@ -1,44 +1,84 @@
-# Las librerias 
+import streamlit as st
+from google import genai
+from google.genai import types
 import os
 import hashlib
-import pickle
-import streamlit as st
-from google.generativeai import configure, GenerativeModel
 from sentence_transformers import SentenceTransformer
 from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np
 import PyPDF2
+import logging
+
+# ==================== CONFIGURACIÓN DE LA PÁGINA ====================
+st.set_page_config(
+    page_title="Pregúntale al Búho 🦉",
+    page_icon="🦉",
+    layout="centered"
+)
+
+# Configuración de Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("buho_app")
+
+# ==================== CONFIGURACIÓN DE API GOOGLE ====================
+try:
+    # Intenta obtener la API key de las variables de entorno o secrets de Streamlit
+    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY") 
+    
+    if not GOOGLE_API_KEY:
+        st.error("❌ No se encontró la variable de entorno GOOGLE_API_KEY. Por favor, configúrala en los Secrets del Space.")
+        st.stop()
+
+except Exception as e:
+    st.error(f"❌ Error al configurar el entorno: {e}")
+    st.stop()
 
-# Configuracion de  la API de Google (Manejo una variable interna)
-configure(api_key=os.getenv('GOOGLE_API_KEY'))
+# ==================== FUNCIONES DE CACHÉ Y CARGA ====================
 
-# Inicializar el modelo Gemini
-model = GenerativeModel('gemini-2.5-flash-lite')
-chat = model.start_chat()
+@st.cache_resource
+def get_gemini_client():
+    """Inicializa el cliente de Google GenAI."""
+    return genai.Client(api_key=GOOGLE_API_KEY)
 
-# Inicializar el modelo Sentence Transformer
-encoder = SentenceTransformer("all-mpnet-base-v2")
+@st.cache_resource
+def get_embedding_model():
+    """Carga el modelo de Sentence Transformer una sola vez."""
+    return SentenceTransformer("all-mpnet-base-v2")
 
-# Función para calcular el hash del directorio
+# Función auxiliar para hashing (para invalidar caché si cambian los archivos)
 def compute_directory_hash(directory):
     hash_md5 = hashlib.md5()
+    if not os.path.exists(directory):
+        return "empty"
     for root, _, files in os.walk(directory):
         for file in sorted(files):
             file_path = os.path.join(root, file)
-            with open(file_path, "rb") as f:
-                for chunk in iter(lambda: f.read(4096), b""):
-                    hash_md5.update(chunk)
+            try:
+                with open(file_path, "rb") as f:
+                    for chunk in iter(lambda: f.read(4096), b""):
+                        hash_md5.update(chunk)
+            except Exception:
+                pass
     return hash_md5.hexdigest()
 
-# Función para dividir texto en chunks
 def split_into_chunks(text, chunk_size=1000):
     words = text.split()
     return [" ".join(words[i:i+chunk_size]) for i in range(0, len(words), chunk_size)]
 
-# Función para cargar documentos y crear embeddings
-def load_documents_and_create_embeddings(directory):
+@st.cache_data(show_spinner=True)
+def load_and_process_documents(directory, dir_hash):
+    """
+    Carga documentos PDF, extrae texto y crea embeddings.
+    El argumento 'dir_hash' asegura que si los archivos cambian, la función se re-ejecute.
+    """
+    logger.info("Procesando documentos PDF...")
     documents = []
     file_chunks = {}
+    
+    if not os.path.exists(directory):
+        os.makedirs(directory, exist_ok=True)
+        return [], None, {}
+
     for root, _, files in os.walk(directory):
         for file in files:
             if file.endswith(".pdf"):
@@ -56,101 +96,133 @@ def load_documents_and_create_embeddings(directory):
                             file_chunks[file] = len(chunks)
                             documents.extend(chunks)
                         else:
-                            print(f"Advertencia: No se pudo extraer texto del archivo {file_path}")
+                            logger.warning(f"Advertencia: No se pudo extraer texto del archivo {file_path}")
                 except Exception as e:
-                    print(f"Error al procesar {file_path}: {e}")
+                    logger.error(f"Error al procesar {file_path}: {e}")
     
     if not documents:
-        return [], None, {}  # No se encontraron documentos PDF válidos
+        return [], None, {}
     
+    # Crear embeddings usando el modelo cargado en cache_resource
+    encoder = get_embedding_model()
     embeddings = encoder.encode(documents)
-    return documents, embeddings, file_chunks
-
-# Función para cargar o actualizar caché
-def load_or_update_cache(directory):
-    cache_file = "cache.pkl"
-    dir_hash = compute_directory_hash(directory)
-    
-    if os.path.exists(cache_file):
-        with open(cache_file, "rb") as f:
-            cache = pickle.load(f)
-        if cache["hash"] == dir_hash:
-            return cache["documents"], cache["embeddings"], cache["file_chunks"]
-    
-    documents, embeddings, file_chunks = load_documents_and_create_embeddings(directory)
-    if embeddings is not None:  # Solo actualizar caché si se encontraron documentos válidos
-        with open(cache_file, "wb") as f:
-            pickle.dump({
-                "hash": dir_hash,
-                "documents": documents,
-                "embeddings": embeddings,
-                "file_chunks": file_chunks
-            }, f)
     
+    logger.info(f"Procesados {len(documents)} fragmentos de texto.")
     return documents, embeddings, file_chunks
 
-# Función para generar respuesta usando Gemini
-def generate_response(prompt, context=None):
-    if context:
-        full_prompt = f"""Contexto: {context}
-
-Pregunta: {prompt}
-
-Por favor, responde a la pregunta basándote en el contexto proporcionado."""
-    else:
-        full_prompt = f"""Pregunta: {prompt}
-
-Por favor, responde a la pregunta utilizando tu conocimiento general."""
-
-    response_with_context = chat.send_message(full_prompt).text
-    response_general = chat.send_message(f"Pregunta: {prompt}\n\nPor favor, responde a la pregunta utilizando tu conocimiento general.").text
+# ==================== LÓGICA DE IA ====================
 
-    combined_response = f"{response_with_context}\n\nEn un contexto general: {response_general}"
-    return combined_response
-
-# Función para reducir el contexto si es necesario
 def reduce_context(context, max_tokens=8000):
     words = context.split()
     if len(words) > max_tokens:
         return " ".join(words[:max_tokens])
     return context
 
-# Cargar documentos y crear embeddings
-directory = "./data"
-documents, embeddings, file_chunks = load_or_update_cache(directory)
-
-# Interfaz de Streamlit
-st.title("Pregúntale al Búho")
-
-# Entrada del usuario
-user_input = st.text_input("Tu duda:", key="user_input")
-
-# Generar respuesta
-if st.button("Enviar"):
-    if user_input:
-        # Buscar en los documentos si hay embeddings válidos
-        if embeddings is not None and len(documents) > 0:
-            question_embedding = encoder.encode([user_input])
-            similarities = cosine_similarity(question_embedding, embeddings)
-            most_similar_idx = np.argmax(similarities)
-            retrieved_doc = reduce_context(documents[most_similar_idx])
+def generate_response(client, prompt, context=None):
+    """Genera respuesta usando la nueva sintaxis de google-genai."""
+    model_id = 'gemini-2.5-flash-lite'
+    
+    try:
+        if context:
+            full_prompt = f"""Usa el siguiente contexto para responder a la pregunta.
+            
+Contexto: {context}
+
+Pregunta: {prompt}
+
+Respuesta:"""
             
-            # Verificar si el documento recuperado es relevante
-            if similarities[0][most_similar_idx] > 0.07:  # Umbral de similitud
-                response = generate_response(user_input, context=retrieved_doc)
-            else:
-                response = generate_response(user_input)  # Usar conocimiento general
+            # Llamada al modelo con contexto
+            response_ctx = client.models.generate_content(
+                model=model_id,
+                contents=full_prompt
+            )
+            text_ctx = response_ctx.text
+        else:
+            text_ctx = "No se encontró contexto relevante en los documentos."
+
+        # Llamada para conocimiento general (opcional, como estaba en el original)
+        general_prompt = f"Pregunta: {prompt}\n\nResponde utilizando tu conocimiento general de forma concisa."
+        response_gen = client.models.generate_content(
+            model=model_id,
+            contents=general_prompt
+        )
+        text_gen = response_gen.text
+
+        combined_response = f"{text_ctx}\n\n---\n**Perspectiva General:**\n{text_gen}"
+        return combined_response
+
+    except Exception as e:
+        return f"Error al generar respuesta con Gemini: {e}"
+
+# ==================== INTERFAZ PRINCIPAL ====================
+
+def main():
+    col_img, col_text = st.columns([1, 5])
+    with col_img:
+        # Si tienes una imagen 'buho.png' en la carpeta, se mostrará
+        if os.path.exists("buho.png"):
+            st.image("buho.png", width=80)
         else:
-            response = generate_response(user_input)  # Usar conocimiento general
-        
-        st.text_area("Respuesta del Búho:", value=response, height=300)
+            st.write("🦉")
+    with col_text:
+        st.title("Pregúntale al Búho")
+        st.markdown("Sistema de consulta sobre documentos PDF usando **Gemini 2.5**.")
+
+    # Inicializar cliente y modelo
+    client = get_gemini_client()
+    encoder = get_embedding_model()
+
+    # Cargar datos
+    directory = "./data"
+    dir_hash = compute_directory_hash(directory) # Calcula hash para invalidar cache si hay cambios
+    
+    with st.spinner("Cargando conocimiento del Búho..."):
+        documents, embeddings, file_chunks = load_and_process_documents(directory, dir_hash)
 
-# Mostrar información sobre los chunks de archivos al final (comentado)
-# if file_chunks:
-#     st.markdown("---")  # Añadir una línea divisoria para separar visualmente
-#     st.subheader("Información sobre los archivos procesados:")
-#     for file, num_chunks in file_chunks.items():
-#         st.write(f"- {file}: {num_chunks} chunks")
+    # Mostrar estado de la base de conocimiento
+    if not documents:
+        st.warning(f"No se encontraron documentos PDF en la carpeta '{directory}'. Sube archivos para empezar.")
+    else:
+        st.caption(f"📚 Base de conocimiento activa: {len(file_chunks)} documentos procesados.")
+
+    # Entrada del usuario
+    user_input = st.text_input("¿Cuál es tu duda?", key="user_input")
+
+    if st.button("Enviar Consulta", type="primary"):
+        if user_input:
+            with st.spinner("El Búho está pensando..."):
+                retrieved_doc = None
+                
+                # Buscar en documentos si existen
+                if embeddings is not None and len(documents) > 0:
+                    question_embedding = encoder.encode([user_input])
+                    similarities = cosine_similarity(question_embedding, embeddings)
+                    most_similar_idx = np.argmax(similarities)
+                    score = similarities[0][most_similar_idx]
+                    
+                    # Umbral de similitud (ajustado ligeramente)
+                    if score > 0.15: 
+                        raw_context = documents[most_similar_idx]
+                        retrieved_doc = reduce_context(raw_context)
+                        # st.expander("Ver contexto recuperado").write(retrieved_doc) # Debug
+                    
+                # Generar respuesta
+                response = generate_response(client, user_input, context=retrieved_doc)
+                
+                st.markdown("### Respuesta del Búho:")
+                st.write(response)
+        else:
+            st.warning("Por favor escribe una pregunta.")
+
+    # Sidebar con información
+    with st.sidebar:
+        st.header("Archivos Indexados")
+        if file_chunks:
+            for file, chunks in file_chunks.items():
+                st.text(f"📄 {file} ({chunks} fragmentos)")
+        else:
+            st.info("Carpeta vacía.")
 
 if __name__ == "__main__":
-    pass
+    main()