Update modules/chatbot/chat_process.py

modules/chatbot/chat_process.py

@@ -14,116 +14,116 @@ class ChatProcessor:
         )
         self.conversation_history = []
         self.semantic_context = None
-        self.current_lang = 'en'  # Idioma por defecto
+        self.current_lang = 'en'
 
     def set_semantic_context(self, text, metrics, graph_data, lang_code='en'):
-        """Configura el contexto semántico para el chat"""
+        """Configura el contexto semántico completo para el chat"""
+        if not text or not metrics:
+            logger.error("Faltan datos esenciales para el contexto semántico")
+            raise ValueError("Texto y métricas son requeridos")
+            
         self.semantic_context = {
-            'text_sample': text[:2000],
+            'full_text': text,  # Texto completo del documento
             'key_concepts': metrics.get('key_concepts', []),
-            'graph_data': graph_data is not None
+            'concept_centrality': metrics.get('concept_centrality', {}),
+            'graph_available': graph_data is not None,
+            'language': lang_code
         }
-        self.current_lang = lang_code  # Establece el idioma actual
+        self.current_lang = lang_code
         self.conversation_history = []
-
-    def clear_semantic_context(self):
-        """Limpia el contexto semántico"""
-        self.semantic_context = None
-        self.conversation_history = []
-        self.current_lang = 'en'
+        logger.info("Contexto semántico configurado correctamente")
 
     def _get_system_prompt(self):
-        """Genera el prompt del sistema según el idioma y contexto"""
+        """Genera el prompt del sistema con todo el contexto necesario"""
         if not self.semantic_context:
-            return {
-                'en': "You are a helpful assistant. Answer general questions.",
-                'es': "Eres un asistente útil. Responde preguntas generales.",
-                'pt': "Você é um assistente útil. Responda a perguntas gerais.",
-                'fr': "Vous êtes un assistant utile. Répondez aux questions générales."
-            }.get(self.current_lang, "You are a helpful assistant.")
-        
-        concepts = ', '.join([c[0] for c in self.semantic_context['key_concepts'][:5]])
+            return "You are a helpful assistant."
+            
+        concepts = self.semantic_context['key_concepts']
+        top_concepts = ", ".join([f"{c[0]} ({c[1]:.2f})" for c in concepts[:5]])
         
         prompts = {
-            'en': f"""You are an assistant specialized in semantic text analysis.
-            The user has analyzed a text with these key concepts: {concepts}
-            
-            Answer specific questions about this analysis, including:
-            - Interpretation of key concepts
-            - Relationships between concepts
-            - Suggestions to improve the text
-            - Explanations about the semantic graph""",
-            
-            'es': f"""Eres un asistente especializado en análisis semántico de textos.
-            El usuario ha analizado un texto con estos conceptos clave: {concepts}
+            'en': f"""You are a semantic analysis expert. The user analyzed a research article.
+            Full text available (abbreviated for context).
+            Key concepts: {top_concepts}
+            Graph available: {self.semantic_context['graph_available']}
             
-            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""",
+            Your tasks:
+            1. Answer questions about concepts and their relationships
+            2. Explain the semantic network structure
+            3. Suggest text improvements
+            4. Provide insights based on concept centrality""",
             
-            'pt': f"""Você é um assistente especializado em análise semântica de textos.
-            O usuário analisou um texto com estes conceitos-chave: {concepts}
+            'es': f"""Eres un experto en análisis semántico. El usuario analizó un artículo de investigación.
+            Texto completo disponible (abreviado para contexto).
+            Conceptos clave: {top_concepts}
+            Gráfico disponible: {self.semantic_context['graph_available']}
             
-            Responda perguntas específicas sobre esta análise, incluindo:
-            - Interpretação de conceitos-chave
-            - Relações entre conceitos
-            - Sugestões para melhorar o texto
-            - Explicações sobre o gráfico semântico""",
+            Tus tareas:
+            1. Responder preguntas sobre conceptos y sus relaciones
+            2. Explicar la estructura de la red semántica
+            3. Sugerir mejoras al texto
+            4. Proporcionar insights basados en centralidad de conceptos""",
             
-            'fr': f"""Vous êtes un assistant spécialisé dans l'analyse sémantique de textes.
-            L'utilisateur a analysé un texte avec ces concepts clés: {concepts}
+            'pt': f"""Você é um especialista em análise semântica. O usuário analisou um artigo de pesquisa.
+            Texto completo disponível (abreviado para contexto).
+            Conceitos-chave: {top_concepts}
+            Gráfico disponível: {self.semantic_context['graph_available']}
             
-            Répondez aux questions spécifiques sur cette analyse, y compris:
-            - Interprétation des concepts clés
-            - Relations entre les concepts
-            - Suggestions pour améliorer le texte
-            - Explications sur le graphique sémantique"""
+            Suas tarefas:
+            1. Responder perguntas sobre conceitos e suas relações
+            2. Explicar a estrutura da rede semântica
+            3. Sugerir melhorias no texto
+            4. Fornecer insights com base na centralidade dos conceitos"""
         }
         
         return prompts.get(self.current_lang, prompts['en'])
 
-    def _get_error_response(self):
-        """Devuelve mensaje de error en el idioma correcto"""
-        return {
-            'en': "Sorry, an error occurred. Please try again.",
-            'es': "Lo siento, ocurrió un error. Por favor, inténtalo de nuevo.",
-            'pt': "Desculpe, ocorreu um erro. Por favor, tente novamente.",
-            'fr': "Désolé, une erreur s'est produite. Veuillez réessayer."
-        }.get(self.current_lang, "Sorry, an error occurred.")
-
     def process_chat_input(self, message: str, lang_code: str) -> Generator[str, None, None]:
-        """Procesa el mensaje del usuario y genera la respuesta"""
+        """Procesa el mensaje con todo el contexto disponible"""
         try:
+            if not self.semantic_context:
+                yield "Error: Contexto semántico no configurado. Recargue el análisis."
+                return
+                
             # Actualizar idioma si es diferente
             if lang_code != self.current_lang:
                 self.current_lang = lang_code
-                logger.info(f"Language changed to: {lang_code}")
+                logger.info(f"Idioma cambiado a: {lang_code}")
 
-            # Construir prompt del sistema
-            system_prompt = self._get_system_prompt()
-            
-            # Agregar mensaje al historial
-            self.conversation_history.append({
-                "role": "user", 
-                "content": message
-            })
+            # Construir historial de mensajes
+            messages = [
+                {
+                    "role": "user",
+                    "content": f"Documento analizado (extracto):\n{self.semantic_context['full_text'][:2000]}..."
+                },
+                *self.conversation_history,
+                {"role": "user", "content": message}
+            ]
 
-            # Llamar a la API de Claude
-            with anthropic.Anthropic().messages.stream(
+            # Llamar a Claude con streaming
+            with self.client.messages.stream(
                 model="claude-3-sonnet-20240229",
                 max_tokens=4000,
                 temperature=0.7,
-                system=system_prompt,
-                messages=self.conversation_history
+                system=self._get_system_prompt(),
+                messages=messages
             ) as stream:
-                for text in stream.text_stream:
-                    yield text
+                full_response = ""
+                for chunk in stream.text_stream:
+                    full_response += chunk
+                    yield chunk + "▌"
+                
+                # Guardar respuesta en historial
+                self.conversation_history.extend([
+                    {"role": "user", "content": message},
+                    {"role": "assistant", "content": full_response}
+                ])
+                logger.info("Respuesta generada y guardada en historial")
 
-            # Registrar conversación exitosa
-            logger.info(f"Chat response generated for language: {self.current_lang}")
-            
         except Exception as e:
-            logger.error(f"Error in process_chat_input: {str(e)}", exc_info=True)
-            yield self._get_error_response()
+            logger.error(f"Error en process_chat_input: {str(e)}", exc_info=True)
+            yield {
+                'en': "Error processing message. Please reload the analysis.",
+                'es': "Error al procesar mensaje. Recargue el análisis.",
+                'pt': "Erro ao processar mensagem. Recarregue a análise."
+            }.get(self.current_lang, "Processing error")