Create semantic_agent_interaction.py

modules/semantic/semantic_agent_interaction.py

@@ -0,0 +1,404 @@
+# modules/semantic/semantic_agent_interaction.py
+import os
+import anthropic
+import streamlit as st
+import logging
+import time
+import json
+from datetime import datetime, timezone
+from io import BytesIO
+import base64
+
+# Local imports
+from ..utils.widget_utils import generate_unique_key
+from ..database.semantic_mongo_db import store_semantic_interaction
+
+logger = logging.getLogger(__name__)
+
+# Cache for conversation history to avoid redundant API calls
+conversation_cache = {}
+
+def get_conversation_cache_key(text, metrics, graph_data, lang_code):
+    """
+    Generate a cache key for conversations based on analysis data.
+    """
+    text_hash = hash(text[:1000])  # Only use first 1000 chars for hashing
+    metrics_hash = hash(json.dumps(metrics, sort_keys=True))
+    graph_hash = hash(graph_data[:100]) if graph_data else 0
+    return f"{text_hash}_{metrics_hash}_{graph_hash}_{lang_code}"
+
+def format_semantic_context(text, metrics, graph_data, lang_code):
+    """
+    Format the semantic analysis data for Claude's context.
+    """
+    formatted_data = {
+        'text_sample': text[:2000],  # Limit text sample
+        'key_concepts': metrics.get('key_concepts', []),
+        'concept_centrality': metrics.get('concept_centrality', {}),
+        'graph_description': "Network graph available" if graph_data else "No graph available",
+        'language': lang_code
+    }
+    
+    return json.dumps(formatted_data, indent=2, ensure_ascii=False)
+
+def initiate_semantic_conversation(text, metrics, graph_data, lang_code):
+    """
+    Start a conversation with Claude about semantic analysis results.
+    """
+    try:
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            logger.error("Claude API key not found in environment variables")
+            return get_fallback_response(lang_code)
+        
+        # Check cache first
+        cache_key = get_conversation_cache_key(text, metrics, graph_data, lang_code)
+        if cache_key in conversation_cache:
+            logger.info("Using cached conversation starter")
+            return conversation_cache[cache_key]
+        
+        # Format context for Claude
+        context = format_semantic_context(text, metrics, graph_data, lang_code)
+        
+        # Determine language for prompt
+        if lang_code == 'es':
+            system_prompt = """Eres un asistente especializado en análisis semántico de textos. 
+            El usuario ha analizado un texto y quiere discutir los resultados contigo. 
+            Estos son los datos del análisis:
+            - Fragmento del texto analizado
+            - Lista de conceptos clave identificados
+            - Medidas de centralidad de los conceptos
+            - Un grafo de relaciones conceptuales (si está disponible)
+            
+            Tu rol es:
+            1. Demostrar comprensión del análisis mostrado
+            2. Hacer preguntas relevantes sobre los resultados
+            3. Ayudar al usuario a interpretar los hallazgos
+            4. Sugerir posibles direcciones para profundizar el análisis
+            
+            Usa un tono profesional pero accesible. Sé conciso pero claro.
+            """
+            user_prompt = f"""Aquí están los resultados del análisis semántico:
+            
+            {context}
+            
+            Por favor:
+            1. Haz un breve resumen de lo que notas en los resultados
+            2. Formula 2-3 preguntas interesantes que podríamos explorar sobre estos datos
+            3. Sugiere un aspecto del análisis que podría profundizarse
+            
+            Mantén tu respuesta bajo 250 palabras."""
+        
+        elif lang_code == 'fr':
+            system_prompt = """Vous êtes un assistant spécialisé dans l'analyse sémantique de textes.
+            L'utilisateur a analysé un texte et souhaite discuter des résultats avec vous.
+            Voici les données d'analyse:
+            - Extrait du texte analysé
+            - Liste des concepts clés identifiés
+            - Mesures de centralité des concepts
+            - Un graphique des relations conceptuelles (si disponible)
+            
+            Votre rôle est:
+            1. Démontrer une compréhension de l'analyse présentée
+            2. Poser des questions pertinentes sur les résultats
+            3. Aider l'utilisateur à interpréter les résultats
+            4. Proposer des pistes pour approfondir l'analyse
+            
+            Utilisez un ton professionnel mais accessible. Soyez concis mais clair.
+            """
+            user_prompt = f"""Voici les résultats de l'analyse sémantique:
+            
+            {context}
+            
+            Veuillez:
+            1. Faire un bref résumé de ce que vous remarquez dans les résultats
+            2. Formuler 2-3 questions intéressantes que nous pourrions explorer
+            3. Suggérer un aspect de l'analyse qui pourrait être approfondi
+            
+            Limitez votre réponse à 250 mots."""
+            
+        elif lang_code == 'pt':
+            system_prompt = """Você é um assistente especializado em análise semântica de textos.
+            O usuário analisou um texto e quer discutir os resultados com você.
+            Aqui estão os dados da análise:
+            - Trecho do texto analisado
+            - Lista de conceitos-chave identificados
+            - Medidas de centralidade dos conceitos
+            - Um grafo de relações conceituais (se disponível)
+            
+            Seu papel é:
+            1. Demonstrar compreensão da análise apresentada
+            2. Fazer perguntas relevantes sobre os resultados
+            3. Ajudar o usuário a interpretar os achados
+            4. Sugerir possíveis direções para aprofundar a análise
+            
+            Use um tom profissional mas acessível. Seja conciso mas claro.
+            """
+            user_prompt = f"""Aqui estão os resultados da análise semântica:
+            
+            {context}
+            
+            Por favor:
+            1. Faça um breve resumo do que você nota nos resultados
+            2. Formule 2-3 perguntas interessantes que poderíamos explorar
+            3. Sugira um aspecto da análise que poderia ser aprofundado
+            
+            Mantenha sua resposta em até 250 palavras."""
+         
+        else:  # Default to English
+            system_prompt = """You are an assistant specialized in semantic text analysis.
+            The user has analyzed a text and wants to discuss the results with you.
+            Here is the analysis data:
+            - Sample of the analyzed text
+            - List of identified key concepts
+            - Concept centrality measures
+            - A concept relationship graph (if available)
+            
+            Your role is to:
+            1. Demonstrate understanding of the shown analysis
+            2. Ask relevant questions about the results
+            3. Help the user interpret the findings
+            4. Suggest possible directions to deepen the analysis
+            
+            Use a professional but accessible tone. Be concise but clear.
+            """
+            user_prompt = f"""Here are the semantic analysis results:
+            
+            {context}
+            
+            Please:
+            1. Give a brief summary of what you notice in the results
+            2. Formulate 2-3 interesting questions we could explore
+            3. Suggest one aspect of the analysis that could be deepened
+            
+            Keep your response under 250 words."""
+        
+        # Initialize Claude client
+        client = anthropic.Anthropic(api_key=api_key)
+        
+        # Call Claude API
+        start_time = time.time()
+        response = client.messages.create(
+            model="claude-3-sonnet-20240229",
+            max_tokens=1024,
+            temperature=0.7,
+            system=system_prompt,
+            messages=[
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        logger.info(f"Claude API call completed in {time.time() - start_time:.2f} seconds")
+        
+        # Extract response
+        initial_response = response.content[0].text
+        
+        # Cache the result
+        conversation_cache[cache_key] = initial_response
+        
+        return initial_response
+        
+    except Exception as e:
+        logger.error(f"Error initiating semantic conversation: {str(e)}")
+        return get_fallback_response(lang_code)
+
+def continue_conversation(conversation_history, new_message, lang_code):
+    """
+    Continue an existing conversation about semantic analysis.
+    """
+    try:
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            logger.error("Claude API key not found in environment variables")
+            return get_fallback_response(lang_code)
+        
+        # Prepare conversation history for Claude
+        messages = []
+        for msg in conversation_history:
+            messages.append({
+                "role": "user" if msg["sender"] == "user" else "assistant",
+                "content": msg["message"]
+            })
+        
+        # Add the new message
+        messages.append({"role": "user", "content": new_message})
+        
+        # System prompt based on language
+        if lang_code == 'es':
+            system_prompt = """Continúa la conversación sobre el análisis semántico.
+            Sé conciso pero útil. Responde en español."""
+        elif lang_code == 'fr':
+            system_prompt = """Continuez la conversation sur l'analyse sémantique.
+            Soyez concis mais utile. Répondez en français."""
+        elif lang_code == 'pt':
+            system_prompt = """Continue a conversa sobre a análise semântica.
+            Seja conciso mas útil. Responda em português."""
+        else:
+            system_prompt = """Continue the conversation about semantic analysis.
+            Be concise but helpful. Respond in English."""
+        
+        # Initialize Claude client
+        client = anthropic.Anthropic(api_key=api_key)
+        
+        # Call Claude API
+        response = client.messages.create(
+            model="claude-3-sonnet-20240229",
+            max_tokens=1024,
+            temperature=0.7,
+            system=system_prompt,
+            messages=messages
+        )
+        
+        return response.content[0].text
+        
+    except Exception as e:
+        logger.error(f"Error continuing semantic conversation: {str(e)}")
+        return get_fallback_response(lang_code)
+
+def get_fallback_response(lang_code):
+    """
+    Return fallback response if Claude API fails.
+    """
+    if lang_code == 'es':
+        return """Parece que hay un problema técnico. Por favor intenta de nuevo más tarde.
+        
+        Mientras tanto, aquí hay algunas preguntas que podrías considerar sobre tu análisis:
+        1. ¿Qué conceptos tienen la mayor centralidad y por qué podría ser?
+        2. ¿Hay conexiones inesperadas entre conceptos en tu grafo?
+        3. ¿Cómo podrías profundizar en las relaciones entre los conceptos clave?"""
+        
+    elif lang_code == 'fr':
+        return """Il semble y avoir un problème technique. Veuillez réessayer plus tard.
+        
+        En attendant, voici quelques questions que vous pourriez considérer:
+        1. Quels concepts ont la plus grande centralité et pourquoi?
+        2. Y a-t-il des connexions inattendues entre les concepts?
+        3. Comment pourriez-vous approfondir les relations entre les concepts clés?"""
+    
+    elif lang_code == 'pt':
+        return """Parece haver um problema técnico. Por favor, tente novamente mais tarde.
+        
+        Enquanto isso, aqui estão algumas perguntas que você poderia considerar:
+        1. Quais conceitos têm maior centralidade e por que isso pode ocorrer?
+        2. Há conexões inesperadas entre conceitos no seu grafo?
+        3. Como você poderia aprofundar as relações entre os conceitos-chave?"""
+    
+    else:
+        return """There seems to be a technical issue. Please try again later.
+        
+        Meanwhile, here are some questions you might consider about your analysis:
+        1. Which concepts have the highest centrality and why might that be?
+        2. Are there unexpected connections between concepts in your graph?
+        3. How could you explore the relationships between key concepts further?"""
+
+def store_conversation(username, text, metrics, graph_data, conversation):
+    """
+    Store the conversation in the database.
+    """
+    try:
+        result = store_semantic_interaction(
+            username=username,
+            text=text,
+            metrics=metrics,
+            graph_data=graph_data,
+            conversation=conversation
+        )
+        
+        logger.info(f"Conversation stored successfully: {result}")
+        return result
+    except Exception as e:
+        logger.error(f"Error storing conversation: {str(e)}")
+        return False
+
+def display_semantic_chat(text, metrics, graph_data, lang_code, t):
+    """
+    Display the chat interface for semantic analysis discussion.
+    """
+    try:
+        # Initialize session state for conversation if not exists
+        if 'semantic_chat' not in st.session_state:
+            st.session_state.semantic_chat = {
+                'history': [],
+                'initialized': False
+            }
+        
+        # Container for chat display
+        chat_container = st.container()
+        
+        # Initialize conversation if not done yet
+        if not st.session_state.semantic_chat['initialized']:
+            with st.spinner(t.get('initializing_chat', 'Initializing conversation...')):
+                initial_response = initiate_semantic_conversation(
+                    text, metrics, graph_data, lang_code
+                )
+                
+                st.session_state.semantic_chat['history'].append({
+                    "sender": "assistant",
+                    "message": initial_response
+                })
+                st.session_state.semantic_chat['initialized'] = True
+                
+                # Store initial conversation
+                if 'username' in st.session_state:
+                    store_conversation(
+                        st.session_state.username,
+                        text,
+                        metrics,
+                        graph_data,
+                        st.session_state.semantic_chat['history']
+                    )
+        
+        # Display chat history
+        with chat_container:
+            st.markdown("### 💬 " + t.get('semantic_discussion', 'Semantic Analysis Discussion'))
+            
+            for msg in st.session_state.semantic_chat['history']:
+                if msg["sender"] == "user":
+                    st.chat_message("user").write(msg["message"])
+                else:
+                    st.chat_message("assistant").write(msg["message"])
+        
+        # Input for new message
+        user_input = st.chat_input(
+            t.get('chat_input_placeholder', 'Ask about your semantic analysis...')
+        )
+        
+        if user_input:
+            # Add user message to history
+            st.session_state.semantic_chat['history'].append({
+                "sender": "user",
+                "message": user_input
+            })
+            
+            # Display user message immediately
+            with chat_container:
+                st.chat_message("user").write(user_input)
+                with st.spinner(t.get('assistant_thinking', 'Assistant is thinking...')):
+                    # Get assistant response
+                    assistant_response = continue_conversation(
+                        st.session_state.semantic_chat['history'],
+                        user_input,
+                        lang_code
+                    )
+                    
+                    # Add assistant response to history
+                    st.session_state.semantic_chat['history'].append({
+                        "sender": "assistant",
+                        "message": assistant_response
+                    })
+                    
+                    # Display assistant response
+                    st.chat_message("assistant").write(assistant_response)
+            
+            # Store updated conversation
+            if 'username' in st.session_state:
+                store_conversation(
+                    st.session_state.username,
+                    text,
+                    metrics,
+                    graph_data,
+                    st.session_state.semantic_chat['history']
+                )
+    
+    except Exception as e:
+        logger.error(f"Error displaying semantic chat: {str(e)}")
+        st.error(t.get('chat_error', 'Error in chat interface. Please try again.'))