modules/studentact/claude_recommendations.py

# modules/studentact/claude_recommendations.py

import anthropic
import os
import streamlit as st
import logging
from typing import Dict, Any
import json

logger = logging.getLogger(__name__)

def generate_claude_recommendations(text: str, metrics: Dict[str, Any], text_type: str, lang_code: str):
    """
    Genera recomendaciones personalizadas utilizando la API de Claude.
    
    Args:
        text: El texto original que se analizó
        metrics: Métricas calculadas por el sistema
        text_type: Tipo de texto (academic_article, student_essay, general_communication)
        lang_code: Código del idioma
        
    Returns:
        str: HTML formateado con recomendaciones personalizadas
    """
    # Diccionario para traducción de tipos de texto
    text_type_names = {
        'academic_article': 'artículo académico',
        'student_essay': 'trabajo universitario',
        'general_communication': 'comunicación general'
    }
    
    # Identificar las áreas más débiles (ordenadas de peor a mejor)
    areas = ['vocabulary', 'structure', 'cohesion', 'clarity']
    scores = {area: metrics[area]['normalized_score'] for area in areas}
    weak_areas = sorted(areas, key=lambda x: scores[x])
    
    try:
        api_key = os.environ.get("ANTHROPIC_API_KEY")
        if not api_key:
            logger.warning("No se encontró ANTHROPIC_API_KEY en las variables de entorno")
            return fallback_recommendations(weak_areas)
            
        client = anthropic.Anthropic(api_key=api_key)
        
        # Truncar el texto si es muy largo para evitar exceder límites de tokens
        truncated_text = text[:1000] + "..." if len(text) > 1000 else text
        
        # Construir el prompt para Claude
        prompt = f"""
        Actúa como un asistente experto en escritura académica y comunicación.
        
        Analiza el siguiente texto (clasificado como {text_type_names.get(text_type, text_type)}) y genera recomendaciones personalizadas para mejorarlo.
        
        Las métricas de análisis del texto son:
        - Vocabulario: {scores['vocabulary']:.2f}/1.00
        - Estructura: {scores['structure']:.2f}/1.00
        - Cohesión: {scores['cohesion']:.2f}/1.00
        - Claridad: {scores['clarity']:.2f}/1.00
        
        Áreas que necesitan mayor atención (de mayor a menor prioridad):
        {', '.join([area for area in weak_areas[:2]])}
        
        Texto analizado:
        "{truncated_text}"
        
        Por favor, proporciona:
        1. Un breve resumen del análisis (2-3 oraciones)
        2. 3-4 recomendaciones específicas para mejorar el texto, identificando problemas concretos que has detectado
        3. Un ejemplo concreto de cómo mejorar una frase del texto (si es posible)
        
        Utiliza un tono profesional pero amigable, y estructura tus recomendaciones en HTML simple usando etiquetas <h4>, <p>, <ul>, <li>, y <strong>.
        """
        
        # Llamada a la API de Claude
        try:
            message = client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=1000,
                temperature=0.3,
                system="Eres un asistente experto en análisis textual que proporciona recomendaciones claras y útiles para mejorar textos.",
                messages=[
                    {"role": "user", "content": prompt}
                ]
            )
            
            # Obtener la respuesta
            response = message.content[0].text
            
            # Guardar en caché para uso futuro
            cache_key = f"claude_recommendations_{text_type}_{weak_areas[0]}"
            st.session_state[cache_key] = response
            
            return response
            
        except Exception as api_error:
            logger.error(f"Error en la llamada a la API de Claude: {str(api_error)}")
            return fallback_recommendations(weak_areas)
        
    except Exception as e:
        logger.error(f"Error generando recomendaciones con Claude: {str(e)}")
        return fallback_recommendations(weak_areas)

def fallback_recommendations(weak_areas):
    """Recomendaciones de respaldo en caso de fallo con la API"""
    area_names = {
        'vocabulary': 'vocabulario',
        'structure': 'estructura',
        'cohesion': 'cohesión',
        'clarity': 'claridad'
    }
    
    return f"""
    <h4>Recomendaciones para mejorar tu texto</h4>
    <p>Hemos detectado que las áreas de <strong>{area_names.get(weak_areas[0], weak_areas[0])}</strong> y <strong>{area_names.get(weak_areas[1], weak_areas[1])}</strong> 
    son las que más podrían beneficiarse de mejoras.</p>
    <p>Para obtener recomendaciones más detalladas, utiliza el asistente virtual de Claude AI
    ubicado en la esquina superior izquierda (presiona la flecha junto al logo).</p>
    """

def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
    """
    Muestra recomendaciones personalizadas