Update modules/chatbot/sidebar_chat.py

modules/chatbot/sidebar_chat.py

@@ -1,166 +1,123 @@
 # modules/chatbot/sidebar_chat.py
 import streamlit as st
 from .chat_process import ChatProcessor
-from ..database.chat_mongo_db import store_chat_history, get_chat_history
+from ..database.chat_mongo_db import store_chat_history
 import logging
 
 logger = logging.getLogger(__name__)
 
 def display_sidebar_chat(lang_code: str, chatbot_t: dict):
-    """
-    Muestra el chatbot en el sidebar con soporte para contexto semántico
-    """
+    """Chatbot mejorado con manejo completo del contexto semántico"""
     with st.sidebar:
-        # Configurar logging
-        logging.basicConfig(
-            level=logging.INFO,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
-
-        # Estilos CSS para el chat
+        # Configuración de estilos
         st.markdown("""
         <style>
             .chat-container {
                 max-height: 60vh;
                 overflow-y: auto;
-                padding-right: 10px;
-            }
-            .chat-input {
-                position: sticky;
-                bottom: 0;
-                background: white;
-                padding-top: 10px;
-                z-index: 100;
+                padding: 10px;
             }
+            .chat-message { margin-bottom: 15px; }
         </style>
         """, unsafe_allow_html=True)
 
         try:
-            # Inicializar el procesador de chat si no existe
+            # Inicialización del procesador
             if 'chat_processor' not in st.session_state:
                 st.session_state.chat_processor = ChatProcessor()
-                logger.info("ChatProcessor initialized")
+                logger.info("Nuevo ChatProcessor inicializado")
 
             # Configurar contexto semántico si está activo
             if st.session_state.get('semantic_agent_active', False):
                 semantic_data = st.session_state.get('semantic_agent_data')
-                if semantic_data:
-                    st.session_state.chat_processor.set_semantic_context(
-                        text=semantic_data['text'],
-                        metrics=semantic_data['metrics'],
-                        graph_data=semantic_data['graph_data'],
-                        lang_code=lang_code  # Pasar el idioma actual
-                    )
-                    logger.info(f"Semantic context set for language: {lang_code}")
+                if semantic_data and all(k in semantic_data for k in ['text', 'metrics']):
+                    try:
+                        st.session_state.chat_processor.set_semantic_context(
+                            text=semantic_data['text'],
+                            metrics=semantic_data['metrics'],
+                            graph_data=semantic_data.get('graph_data'),
+                            lang_code=lang_code
+                        )
+                        logger.info("Contexto semántico configurado en el chat")
+                    except Exception as e:
+                        logger.error(f"Error configurando contexto: {str(e)}")
+                        st.error("Error al configurar el análisis. Recargue el documento.")
+                        return
 
-            with st.expander("💬 Asistente Virtual", expanded=True):
-                # Inicializar mensajes del chat
+            # Interfaz del chat
+            with st.expander("💬 Asistente de Análisis", expanded=True):
+                # Inicializar historial si no existe
                 if 'sidebar_messages' not in st.session_state:
-                    initial_messages = {
-                        'en': "Hello! How can I help you today?",
-                        'es': "¡Hola! ¿Cómo puedo ayudarte hoy?",
-                        'pt': "Olá! Como posso ajudar você hoje?",
-                        'fr': "Bonjour ! Comment puis-je vous aider aujourd'hui ?"
-                    }
-                    initial_message = initial_messages.get(lang_code, initial_messages['en'])
+                    initial_msg = {
+                        'en': "Hello! Ask me about the semantic analysis.",
+                        'es': "¡Hola! Pregúntame sobre el análisis semántico.",
+                        'pt': "Olá! Pergunte-me sobre a análise semântica."
+                    }.get(lang_code, "Hello!")
                     
                     st.session_state.sidebar_messages = [
-                        {"role": "assistant", "content": initial_message}
+                        {"role": "assistant", "content": initial_msg}
                     ]
-                    logger.info("Chat messages initialized")
 
-                # Contenedor del chat
+                # Mostrar historial
                 chat_container = st.container()
                 with chat_container:
-                    for message in st.session_state.sidebar_messages:
-                        with st.chat_message(message["role"]):
-                            st.markdown(message["content"])
+                    for msg in st.session_state.sidebar_messages:
+                        st.chat_message(msg["role"]).write(msg["content"])
 
-                # Input del usuario
+                # Manejo de mensajes nuevos
                 user_input = st.chat_input(
                     {
-                        'en': "Type your message...",
-                        'es': "Escribe tu mensaje...",
-                        'pt': "Digite sua mensagem...",
-                        'fr': "Tapez votre message..."
-                    }.get(lang_code, "Type your message...")
+                        'en': "Ask about the analysis...",
+                        'es': "Pregunta sobre el análisis...",
+                        'pt': "Pergunte sobre a análise..."
+                    }.get(lang_code, "Message...")
                 )
 
                 if user_input:
                     try:
-                        # Agregar mensaje del usuario
-                        st.session_state.sidebar_messages.append(
-                            {"role": "user", "content": user_input}
-                        )
-                        logger.info(f"User message received: {user_input[:50]}...")
-
                         # Mostrar mensaje del usuario
                         with chat_container:
-                            with st.chat_message("user"):
-                                st.markdown(user_input)
+                            st.chat_message("user").write(user_input)
+                            st.session_state.sidebar_messages.append(
+                                {"role": "user", "content": user_input}
+                            )
 
-                            # Mostrar respuesta del asistente
+                            # Obtener y mostrar respuesta
                             with st.chat_message("assistant"):
-                                response_placeholder = st.empty()
-                                full_response = ""
-
-                                # Obtener respuesta del procesador
-                                for chunk in st.session_state.chat_processor.process_chat_input(
-                                    user_input, 
-                                    lang_code
-                                ):
-                                    full_response += chunk
-                                    response_placeholder.markdown(full_response + "▌")
-
-                                response_placeholder.markdown(full_response)
-                                logger.info(f"Assistant response generated: {full_response[:50]}...")
-                                
-                                # Guardar respuesta
+                                response = st.write_stream(
+                                    st.session_state.chat_processor.process_chat_input(
+                                        user_input, lang_code
+                                    )
+                                )
                                 st.session_state.sidebar_messages.append(
-                                    {"role": "assistant", "content": full_response}
+                                    {"role": "assistant", "content": response.replace("▌", "")}
                                 )
 
                         # Guardar en base de datos
-                        store_chat_history(
-                            username=st.session_state.username,
-                            messages=st.session_state.sidebar_messages,
-                            chat_type='semantic' if st.session_state.get('semantic_agent_active') else 'general'
-                        )
-                        logger.info("Conversation saved to database")
-
+                        if 'username' in st.session_state:
+                            store_chat_history(
+                                username=st.session_state.username,
+                                messages=st.session_state.sidebar_messages,
+                                chat_type='semantic_analysis',
+                                metadata={
+                                    'text_sample': st.session_state.semantic_agent_data['text'][:500],
+                                    'concepts': st.session_state.semantic_agent_data['metrics']['key_concepts'][:5]
+                                }
+                            )
+                            
                     except Exception as e:
-                        logger.error(f"Error processing user input: {str(e)}", exc_info=True)
+                        logger.error(f"Error en conversación: {str(e)}", exc_info=True)
                         st.error({
-                            'en': "Error processing message. Please try again.",
-                            'es': "Error al procesar el mensaje. Por favor, inténtalo de nuevo.",
-                            'pt': "Erro ao processar a mensagem. Por favor, tente novamente.",
-                            'fr': "Erreur lors du traitement du message. Veuillez réessayer."
-                        }.get(lang_code, "Error processing message."))
-
-                # Botón para limpiar el chat
-                if st.button({
-                    'en': "🔄 Clear conversation",
-                    'es': "🔄 Limpiar conversación",
-                    'pt': "🔄 Limpar conversa",
-                    'fr': "🔄 Effacer la conversation"
-                }.get(lang_code, "🔄 Clear")):
-                    st.session_state.sidebar_messages = [{
-                        "role": "assistant",
-                        "content": {
-                            'en': "Hello! How can I help you today?",
-                            'es': "¡Hola! ¿Cómo puedo ayudarte hoy?",
-                            'pt': "Olá! Como posso ajudar você hoje?",
-                            'fr': "Bonjour ! Comment puis-je vous aider aujourd'hui ?"
-                        }.get(lang_code, "Hello! How can I help you?")
-                    }]
+                            'en': "Error processing request. Try again.",
+                            'es': "Error al procesar. Intente nuevamente.",
+                            'pt': "Erro ao processar. Tente novamente."
+                        }.get(lang_code, "Error"))
+
+                # Botón para reiniciar
+                if st.button("🔄 Reiniciar Chat"):
+                    st.session_state.sidebar_messages = []
                     st.rerun()
-                    logger.info("Conversation cleared")
 
         except Exception as e:
-            logger.error(f"Error in sidebar chat: {str(e)}", exc_info=True)
-            st.error({
-                'en': "An error occurred in the chat. Please try again.",
-                'es': "Ocurrió un error en el chat. Por favor, inténtalo de nuevo.",
-                'pt': "Ocorreu um erro no chat. Por favor, tente novamente.",
-                'fr': "Une erreur s'est produite dans le chat. Veuillez réessayer."
-            }.get(lang_code, "Chat error occurred."))
+            logger.error(f"Error fatal en sidebar_chat: {str(e)}", exc_info=True)
+            st.error("System error. Please refresh the page.")