Update modules/chatbot/chat_process.py

modules/chatbot/chat_process.py

@@ -1,73 +1,120 @@
-# modules/chatbot/chat_process.py
-import os
-import anthropic
+# 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
 import logging
-from typing import Generator
 
 logger = logging.getLogger(__name__)
 
-class ChatProcessor:
-    def __init__(self):
-        """Inicializa el procesador de chat con la API de Claude"""
-        self.client = anthropic.Anthropic(
-            api_key=os.environ.get("ANTHROPIC_API_KEY")
-        )
-        self.conversation_history = []
-        self.semantic_context = None
+def display_sidebar_chat(lang_code: str, chatbot_t: dict):
+    """
+    Muestra el chatbot en el sidebar con soporte para contexto semántico
+    """
+    with st.sidebar:
+        # Estilos CSS para el chat
+        st.markdown("""
+        <style>
+            /* Contenedor del chat con scroll */
+            div[data-testid="stExpanderContent"] > div {
+                max-height: 60vh;
+                overflow-y: auto;
+                padding-right: 10px;
+            }
+            
+            /* Input fijo en la parte inferior */
+            div[data-testid="stHorizontalBlock"]:has(> div[data-testid="column"]) {
+                position: sticky;
+                bottom: 0;
+                background: white;
+                padding-top: 10px;
+                z-index: 100;
+            }
+        </style>
+        """, unsafe_allow_html=True)
 
-    def set_semantic_context(self, text, metrics, graph_data):
-        """Configura el contexto semántico para el chat"""
-        self.semantic_context = {
-            'text_sample': text[:2000],  # Tomamos solo un fragmento
-            'key_concepts': metrics.get('key_concepts', []),
-            'graph_data': graph_data is not None
-        }
-        # Reiniciamos el historial para el nuevo contexto
-        self.conversation_history = []
+        # Inicializar el procesador de chat si no existe
+        if 'chat_processor' not in st.session_state:
+            st.session_state.chat_processor = ChatProcessor()
 
-    def clear_semantic_context(self):
-        """Limpia el contexto semántico"""
-        self.semantic_context = None
-        self.conversation_history = []
+        # 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']
+                )
 
-    def process_chat_input(self, message: str, lang_code: str) -> Generator[str, None, None]:
-        """Procesa el mensaje del usuario y genera la respuesta"""
-        try:
-            # Construir el prompt del sistema según el contexto
-            if self.semantic_context:
-                system_prompt = f"""
-                Eres un asistente especializado en análisis semántico de textos. 
-                El usuario ha analizado un texto con los siguientes conceptos clave: 
-                {', '.join([c[0] for c in self.semantic_context['key_concepts'][:5]])}
-                
-                Responde preguntas específicas sobre este análisis, incluyendo:
-                - Interpretación de conceptos clave
-                - Relaciones entre conceptos
-                - Sugerencias para mejorar el texto
-                - Explicaciones sobre el gráfico semántico
-                """
-            else:
-                system_prompt = "Eres un asistente útil. Responde preguntas generales."
+        with st.expander("💬 Asistente Virtual", expanded=True):
+            try:
+                # Inicializar mensajes del chat
+                if 'sidebar_messages' not in st.session_state:
+                    # Mensaje inicial según el modo (normal o semántico)
+                    initial_message = (
+                        "¡Hola! Soy tu asistente de análisis semántico. ¿En qué puedo ayudarte?"
+                        if st.session_state.get('semantic_agent_active', False)
+                        else "¡Hola! ¿Cómo puedo ayudarte hoy?"
+                    )
+                    st.session_state.sidebar_messages = [
+                        {"role": "assistant", "content": initial_message}
+                    ]
 
-            # Agregar mensaje al historial
-            self.conversation_history.append({
-                "role": "user", 
-                "content": message
-            })
+                # Mostrar historial del chat
+                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"])
 
-            # Llamar a la API de Claude
-            with anthropic.Anthropic().messages.stream(
-                model="claude-3-sonnet-20240229",
-                max_tokens=4000,
-                temperature=0.7,
-                system=system_prompt,
-                messages=self.conversation_history
-            ) as stream:
-                for text in stream.text_stream:
-                    yield text
+                # Input del usuario
+                user_input = st.chat_input("Escribe tu mensaje...")
 
-            # Actualizar historial (la API lo hace automáticamente)
-            
-        except Exception as e:
-            logger.error(f"Error en process_chat_input: {str(e)}")
-            yield "Lo siento, ocurrió un error al procesar tu mensaje. Por favor, inténtalo de nuevo."
+                if user_input:
+                    # Agregar mensaje del usuario
+                    st.session_state.sidebar_messages.append(
+                        {"role": "user", "content": user_input}
+                    )
+
+                    # Mostrar mensaje del usuario
+                    with chat_container:
+                        with st.chat_message("user"):
+                            st.markdown(user_input)
+
+                        # Mostrar respuesta del asistente
+                        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)
+                            
+                            # Guardar respuesta
+                            st.session_state.sidebar_messages.append(
+                                {"role": "assistant", "content": full_response}
+                            )
+
+                    # 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'
+                    )
+
+                # Botón para limpiar el chat
+                if st.button("🔄 Limpiar conversación"):
+                    st.session_state.sidebar_messages = [
+                        {"role": "assistant", "content": "¡Hola! ¿En qué puedo ayudarte?"}
+                    ]
+                    st.rerun()
+
+            except Exception as e:
+                logger.error(f"Error en el chat: {str(e)}")
+                st.error("Ocurrió un error en el chat. Por favor, inténtalo de nuevo.")