Update modules/chatbot/chat_process.py

modules/chatbot/chat_process.py

@@ -2,82 +2,72 @@
 import os
 import anthropic
 import logging
-from typing import Dict, Generator
+from typing import Generator
 
 logger = logging.getLogger(__name__)
 
-####################################################
 class ChatProcessor:
     def __init__(self):
         """Inicializa el procesador de chat con la API de Claude"""
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
-        if not api_key:
-            raise ValueError("No se encontró la clave API de Anthropic.")
-        self.client = anthropic.Anthropic(api_key=api_key)
+        self.client = anthropic.Anthropic(
+            api_key=os.environ.get("ANTHROPIC_API_KEY")
+        )
         self.conversation_history = []
-        self.semantic_context = None  # <-- Añade esta línea para inicializar el atributo
+        self.semantic_context = None
 
     def set_semantic_context(self, text, metrics, graph_data):
-        """Configura el contexto semántico para conversaciones especializadas"""
+        """Configura el contexto semántico para el chat"""
         self.semantic_context = {
-            'text_sample': text[:2000],
+            'text_sample': text[:2000],  # Tomamos solo un fragmento
             'key_concepts': metrics.get('key_concepts', []),
-            'concept_centrality': metrics.get('concept_centrality', {}),
-            'graph_description': "Available" if graph_data else "Not available"
+            'graph_data': graph_data is not None
         }
-    
+        # Reiniciamos el historial para el nuevo contexto
+        self.conversation_history = []
+
     def clear_semantic_context(self):
         """Limpia el contexto semántico"""
         self.semantic_context = None
+        self.conversation_history = []
 
     def process_chat_input(self, message: str, lang_code: str) -> Generator[str, None, None]:
-        """Procesa el mensaje con contexto semántico si está disponible"""
+        """Procesa el mensaje del usuario y genera la respuesta"""
         try:
-            # Preparar mensaje con contexto si existe
+            # 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. Datos del análisis actual:
-                - Conceptos clave: {', '.join([c[0] for c in self.semantic_context['key_concepts'][:5]])}...
-                - Centralidad: {len(self.semantic_context['concept_centrality'])} conceptos
-                - Grafo: {self.semantic_context['graph_description']}
+                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 sobre este análisis específico.
+                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."
-            
-            # Agregar mensaje a la historia
-            self.conversation_history.append({"role": "user", "content": message})
-            
-            # Generar respuesta usando la API de Claude
-            response = self.client.messages.create(
-                model="claude-3-5-sonnet-20241022",
-                messages=self.conversation_history,
-                max_tokens=8000,  # Añadimos este parámetro requerido
+
+            # Agregar mensaje al historial
+            self.conversation_history.append({
+                "role": "user", 
+                "content": message
+            })
+
+            # Llamar a la API de Claude
+            with anthropic.Anthropic().messages.stream(
+                model="claude-3-sonnet-20240229",
+                max_tokens=4000,
                 temperature=0.7,
-            )
-            
-            # Procesar la respuesta
-            claude_response = response.content[0].text
-            self.conversation_history.append({"role": "assistant", "content": claude_response})
+                system=system_prompt,
+                messages=self.conversation_history
+            ) as stream:
+                for text in stream.text_stream:
+                    yield text
+
+            # Actualizar historial (la API lo hace automáticamente)
             
-            # Mantener un historial limitado
-            if len(self.conversation_history) > 10:
-                self.conversation_history = self.conversation_history[-10:]
-                
-            # Dividir la respuesta en palabras para streaming
-            words = claude_response.split()
-            for word in words:
-                yield word + " "
-                
         except Exception as e:
             logger.error(f"Error en process_chat_input: {str(e)}")
-            yield f"Error: {str(e)}"
-
-    def get_conversation_history(self) -> list:
-        """Retorna el historial de la conversación"""
-        return self.conversation_history
-
-    def clear_history(self):
-        """Limpia el historial de la conversación"""
-        self.conversation_history = []
+            yield "Lo siento, ocurrió un error al procesar tu mensaje. Por favor, inténtalo de nuevo."