Update src/components/ai_tutor.py

src/components/ai_tutor.py

@@ -1,80 +1,236 @@
 import streamlit as st
-from src.services.ai_service import AITutorService
-from src.utils.session import get_tutor_context
+from datetime import datetime
+import anthropic
+import os
+from typing import Dict
 
-class AITutor:
+class AITutorService:
     def __init__(self):
-        self.service = AITutorService()
+        self._client = None
+        self.initialize_client()
+        self._load_avatar_assets()
 
-    def display_chat_interface(self):
-        """Display the enhanced chat interface with avatar"""
-        st.header("AI Tutor")
+    def initialize_client(self):
+        """Initialize Anthropic client with better error handling"""
+        try:
+            # First try getting API key from Streamlit secrets
+            api_key = None
+            if hasattr(st, 'secrets') and 'ANTHROPIC_API_KEY' in st.secrets:
+                api_key = st.secrets['ANTHROPIC_API_KEY']
+            
+            # If not in secrets, try environment variable
+            if not api_key:
+                api_key = os.getenv('ANTHROPIC_API_KEY')
+            
+            if not api_key:
+                st.error("Anthropic API key not found. Please set ANTHROPIC_API_KEY in .streamlit/secrets.toml or environment variables.")
+                st.info("For testing, you can set this up locally by creating a .streamlit/secrets.toml file with:\nANTHROPIC_API_KEY='your-key-here'")
+                self.voice_enabled = False
+                self.tts_mode = None
+                return
 
-        # Voice controls with TTS mode indicator
-        col1, col2 = st.columns([3, 2])
-        with col1:
-            if self.service.voice_enabled:
-                voice_active = st.toggle("Enable Voice", value=False, key="voice_active")
+            self._client = anthropic.Anthropic(api_key=api_key)
+            self.voice_enabled = True
+            self.tts_mode = 'openai'
+
+        except Exception as e:
+            st.error(f"Failed to initialize Anthropic client: {str(e)}")
+            self._client = None
+            self.voice_enabled = False
+            self.tts_mode = None
+
+    def _load_avatar_assets(self):
+        """Initialize avatar states and assets"""
+        self.avatar_states = {
+            'neutral': """
+                <svg width="100" height="100" viewBox="0 0 100 100">
+                    <circle cx="50" cy="50" r="45" fill="#4A90E2"/>
+                    <circle cx="35" cy="40" r="5" fill="white"/>
+                    <circle cx="65" cy="40" r="5" fill="white"/>
+                    <path d="M 30 65 Q 50 65 70 65" stroke="white" fill="none" stroke-width="3"/>
+                </svg>
+            """,
+            'thinking': """
+                <svg width="100" height="100" viewBox="0 0 100 100">
+                    <circle cx="50" cy="50" r="45" fill="#4A90E2"/>
+                    <circle cx="35" cy="40" r="5" fill="white"/>
+                    <circle cx="65" cy="40" r="5" fill="white"/>
+                    <path d="M 30 60 Q 50 70 70 60" stroke="white" fill="none" stroke-width="3"/>
+                </svg>
+            """,
+            'happy': """
+                <svg width="100" height="100" viewBox="0 0 100 100">
+                    <circle cx="50" cy="50" r="45" fill="#4A90E2"/>
+                    <circle cx="35" cy="40" r="5" fill="white"/>
+                    <circle cx="65" cy="40" r="5" fill="white"/>
+                    <path d="M 30 60 Q 50 80 70 60" stroke="white" fill="none" stroke-width="3"/>
+                </svg>
+            """
+        }
+
+    @property
+    def client(self):
+        """Property to safely access the Anthropic client"""
+        if self._client is None:
+            raise ValueError("Anthropic client not properly initialized")
+        return self._client
+
+import base64
+from io import BytesIO
+from typing import Dict
+
+class AITutorService:
+    def __init__(self):
+        self._client = None
+        self.initialize_client()
+        self._load_avatar_assets()
+
+    def _load_avatar_assets(self):
+        """Initialize avatar states and assets"""
+        self.avatar_states: Dict[str, bytes] = {
+            'neutral': self._svg_to_bytes("""
+                <svg width="100" height="100" viewBox="0 0 100 100">
+                    <circle cx="50" cy="50" r="45" fill="#4A90E2"/>
+                    <circle cx="35" cy="40" r="5" fill="white"/>
+                    <circle cx="65" cy="40" r="5" fill="white"/>
+                    <path d="M 30 65 Q 50 65 70 65" stroke="white" fill="none" stroke-width="3"/>
+                </svg>
+            """),
+            'thinking': self._svg_to_bytes("""
+                <svg width="100" height="100" viewBox="0 0 100 100">
+                    <circle cx="50" cy="50" r="45" fill="#4A90E2"/>
+                    <circle cx="35" cy="40" r="5" fill="white"/>
+                    <circle cx="65" cy="40" r="5" fill="white"/>
+                    <path d="M 30 60 Q 50 70 70 60" stroke="white" fill="none" stroke-width="3"/>
+                </svg>
+            """),
+            'happy': self._svg_to_bytes("""
+                <svg width="100" height="100" viewBox="0 0 100 100">
+                    <circle cx="50" cy="50" r="45" fill="#4A90E2"/>
+                    <circle cx="35" cy="40" r="5" fill="white"/>
+                    <circle cx="65" cy="40" r="5" fill="white"/>
+                    <path d="M 30 60 Q 50 80 70 60" stroke="white" fill="none" stroke-width="3"/>
+                </svg>
+            """)
+        }
+
+    def _svg_to_bytes(self, svg_str: str) -> bytes:
+        """Convert SVG string to bytes"""
+        return base64.b64encode(svg_str.encode()).decode().encode()
+
+    def display_avatar(self, state: str = 'neutral'):
+        """Display the AI tutor avatar"""
+        avatar_bytes = self.avatar_states.get(state, self.avatar_states['neutral'])
+        st.image(avatar_bytes, width=100)
+
+    def generate_response(self, user_input: str) -> str:
+        """Generate response using Claude with better error handling"""
+        if not self._client:
+            return "I apologize, but I'm not properly connected right now. Please check the API configuration."
+
+        try:
+            # Get session context
+            context = get_tutor_context()
+            current_topic = context.get('current_topic')
+            
+            # Build system prompt
+            system_prompt = """You are an expert tutor helping students learn. 
+                             Give clear, step-by-step explanations with examples.
+                             Focus on the current topic if specified."""
+            
+            if current_topic and current_topic != "All Topics":
+                system_prompt += f"\nYou are currently tutoring about {current_topic}."
+
+            # Generate response
+            response = self.client.messages.create(
+                model="claude-3-opus-20240229",
+                temperature=0.7,
+                max_tokens=1024,
+                system=system_prompt,
+                messages=[{
+                    "role": "user",
+                    "content": user_input
+                }]
+            )
+            
+            # Get response text
+            response_text = response.content[0].text
+            
+            # Update metrics
+            self.update_engagement_metrics(user_input, response_text)
+            
+            return response_text
+
+        except anthropic.APIError as e:
+            st.error(f"API Error: {str(e)}")
+            return "I encountered an API error. Please try again in a moment."
+        except anthropic.APIConnectionError as e:
+            st.error(f"Connection Error: {str(e)}")
+            return "I'm having trouble connecting to my API. Please check your internet connection."
+        except Exception as e:
+            st.error(f"Unexpected error: {str(e)}")
+            return "I encountered an unexpected error. Please try again."
+
+    def speak(self, text: str):
+        """Make the AI tutor speak using available TTS method"""
+        if not self.voice_enabled:
+            return
+
+        if self.tts_mode == 'openai':
+            if self.openai_enabled:
+                self.speak_with_openai(text)
             else:
-                voice_active = False
-        with col2:
-            if self.service.tts_mode:
-                st.info(f"Using {self.service.tts_mode.upper()} TTS")
-
-        # Display avatar
-        self.service.display_avatar(state='neutral')
-
-        # Topic selection
-        topics = [None, 'Physics', 'Mathematics', 'Computer Science', 'Artificial Intelligence']
-        selected_topic = st.selectbox(
-            "Select Topic",
-            topics,
-            format_func=lambda x: 'All Topics' if x is None else x,
-            key="topic_selector"
-        )
-
-        context = get_tutor_context()
-        if selected_topic != context['current_topic']:
-            context['current_topic'] = selected_topic
-
-        # Display chat container
-        chat_container = st.container()
-        with chat_container:
-            # Display chat history with avatar states
-            for message in context['chat_history']:
-                with st.chat_message(message["role"]):
-                    st.write(message["content"])
-                    if message["role"] == "assistant":
-                        self.service.display_avatar(state='happy')
-                        if voice_active and message.get('speak', True):
-                            self.service.speak(message["content"])
-                            message['speak'] = False
-
-        # Chat input
-        if prompt := st.text_input("Ask your question...", key="chat_input"):
-            self.handle_user_input(prompt)
-
-    def handle_user_input(self, user_input: str):
-        """Process user input and generate response"""
-        # Show thinking avatar
-        self.service.display_avatar(state='thinking')
-        
-        # Add user message
-        context = get_tutor_context()
-        context['chat_history'].append({
-            "role": "user",
-            "content": user_input
-        })
-        
-        # Generate and display AI response
-        response = self.service.generate_response(user_input)
-        
-        # Add AI response
-        context['chat_history'].append({
-            "role": "assistant",
-            "content": response,
-            "speak": True
+                st.warning("OpenAI TTS is not available. Voice output is disabled.")
+                self.tts_mode = None
+                self.voice_enabled = False
+        else:
+            st.warning("Local TTS is not implemented yet.")
+
+    def speak_with_openai(self, text: str):
+        """Generate speech using OpenAI's TTS"""
+        try:
+            # Generate speech using OpenAI
+            response = self.client.audio.speech.create(
+                model="tts-1",
+                voice="alloy",  # or "nova", "shimmer", "echo", "fable"
+                input=text
+            )
+
+            # Create a temporary file to store the audio
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as tmp_file:
+                response.stream_to_file(tmp_file.name)
+                
+                # Create audio player in Streamlit
+                audio_file = open(tmp_file.name, 'rb')
+                audio_bytes = audio_file.read()
+                st.audio(audio_bytes, format='audio/mp3')
+                
+                # Clean up
+                audio_file.close()
+                os.unlink(tmp_file.name)
+
+        except Exception as e:
+            st.error(f"Error during OpenAI speech synthesis: {e}")
+
+    def update_engagement_metrics(self, user_input: str, response: str):
+        """Update engagement metrics"""
+        if 'tutor_context' not in st.session_state:
+            st.session_state.tutor_context = {
+                'engagement_metrics': []
+            }
+            
+        metrics = st.session_state.tutor_context['engagement_metrics']
+        metrics.append({
+            'timestamp': datetime.now().isoformat(),
+            'sentiment_score': min(1.0, len(user_input) / 100.0),
+            'interaction_length': len(user_input)
         })
-        
-        # Show happy avatar
-        self.service.display_avatar(state='happy')
+
+def get_tutor_context() -> Dict:
+    """Get or initialize tutor context"""
+    if 'tutor_context' not in st.session_state:
+        st.session_state.tutor_context = {
+            'current_topic': None,
+            'chat_history': []
+        }
+    return st.session_state.tutor_context