Update src/components/ai_tutor.py

src/components/ai_tutor.py

@@ -1,126 +1,148 @@
 import streamlit as st
-from src.services.ai_service import AITutorService
-from src.utils.session import get_tutor_context
 from datetime import datetime
-import platform
-import base64
-from openai import OpenAI
-import tempfile
-import os
 import anthropic
+import os
+from typing import Dict
 
-class AITutor:
+class AITutorService:
     def __init__(self):
-        self.service = AITutorService()
-        self.voice_enabled = False
-        self.tts_mode = None  # 'local' or 'openai'
-        self.openai_enabled = False  # Initialize the flag
-        self.initialize_openai()  # Initialize OpenAI first
-        self.initialize_speech_components()  # Then initialize speech components
-
-    def initialize_openai(self):
-        """Initialize OpenAI client"""
+        self._client = None
+        self.initialize_client()
+        self._load_avatar_assets()
+
+    def initialize_client(self):
+        """Initialize Anthropic client with better error handling"""
         try:
-            # Get API key from environment variable
-            api_key = os.getenv('OPENAI_API_KEY')
+            # 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:
-                st.warning("OpenAI API key not found in environment variables. Voice features will be limited.")
-                self.openai_enabled = False
+                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'")
                 return
 
-            self.openai_client = OpenAI(api_key=api_key)
-            self.openai_enabled = True
-            
+            self._client = anthropic.Anthropic(api_key=api_key)
+
         except Exception as e:
-            st.warning("Error initializing OpenAI client. Voice features will be limited.")
-            self.openai_enabled = False
-
-    def initialize_speech_components(self):
-        """Initialize text-to-speech with fallback options"""
-        if 'tts_engine' not in st.session_state:
-            try:
-                import pyttsx3
-                
-                # Try local TTS first
-                system = platform.system()
-                if system == "Windows":
-                    st.session_state.tts_engine = pyttsx3.init(driverName='sapi5')
-                elif system == "Darwin":  # macOS
-                    st.session_state.tts_engine = pyttsx3.init(driverName='nsss')
-                else:  # Linux
-                    st.session_state.tts_engine = pyttsx3.init()
-                
-                # Configure voice properties
-                st.session_state.tts_engine.setProperty('rate', 150)
-                st.session_state.tts_engine.setProperty('volume', 0.9)
-                
-                try:
-                    voices = st.session_state.tts_engine.getProperty('voices')
-                    female_voice = next((voice for voice in voices if 'female' in voice.name.lower()), voices[0])
-                    st.session_state.tts_engine.setProperty('voice', female_voice.id)
-                except Exception:
-                    pass  # Use default voice if female voice setting fails
-                
-                self.voice_enabled = True
-                self.tts_mode = 'local'
-            except Exception as e:
-                st.info("Local text-to-speech unavailable. Falling back to OpenAI TTS.")
-                st.session_state.tts_engine = None
-                if self.openai_enabled:
-                    self.voice_enabled = True
-                    self.tts_mode = 'openai'
-                else:
-                    self.voice_enabled = False
-                    self.tts_mode = None
-
-    def speak_with_openai(self, text: str):
-        """Generate speech using OpenAI's TTS"""
+            st.error(f"Failed to initialize Anthropic client: {str(e)}")
+            self._client = 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
+
+    def display_avatar(self, state: str = 'neutral'):
+        """Display the AI tutor avatar"""
+        avatar_svg = self.avatar_states.get(state, self.avatar_states['neutral'])
+        st.markdown(f"""
+            <div style="display: flex; justify-content: center; margin: 20px 0;">
+                {avatar_svg}
+            </div>
+        """, unsafe_allow_html=True)
+
+    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:
-            # Generate speech using OpenAI
-            response = self.openai_client.audio.speech.create(
-                model="tts-1",
-                voice="alloy",  # or "nova", "shimmer", "echo", "fable"
-                input=text
+            # Get session context
+            context = st.session_state.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
+                }]
             )
-
-            # 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)
-
+            
+            # 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"Error during OpenAI speech synthesis: {e}")
-
-    def speak(self, text: str):
-        """Make the AI tutor speak using available TTS method"""
-        if not self.voice_enabled:
-            return
-
-        if self.tts_mode == 'local':
-            try:
-                import threading
-                def speak_text():
-                    st.session_state.tts_engine.say(text)
-                    st.session_state.tts_engine.runAndWait()
-
-                thread = threading.Thread(target=speak_text)
-                thread.start()
-            except Exception as e:
-                st.error(f"Error during local speech synthesis: {e}")
-                if self.openai_enabled:
-                    st.info("Falling back to OpenAI TTS...")
-                    self.speak_with_openai(text)
-        
-        elif self.tts_mode == 'openai':
-            self.speak_with_openai(text)
+            st.error(f"Unexpected error: {str(e)}")
+            return "I encountered an unexpected error. Please try again."
+
+    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)
+        })
+
+class AITutor:
+    def __init__(self):
+        self.service = AITutorService()
 
     def display_chat_interface(self):
         """Display the enhanced chat interface with avatar"""
@@ -129,13 +151,15 @@ class AITutor:
         # Voice controls with TTS mode indicator
         col1, col2 = st.columns([3, 2])
         with col1:
-            if self.voice_enabled:
-                voice_active = st.toggle("Enable Voice", value=False, key="voice_active")
-            else:
-                voice_active = False
+            st.write("Voice features not implemented yet.")
+            # if self.voice_enabled:
+            #     voice_active = st.toggle("Enable Voice", value=False, key="voice_active")
+            # else:
+            #     voice_active = False
         with col2:
-            if self.tts_mode:
-                st.info(f"Using {self.tts_mode.upper()} TTS")
+            st.write("TTS mode not implemented yet.")
+            # if self.tts_mode:
+            #     st.info(f"Using {self.tts_mode.upper()} TTS")
 
         # Display avatar
         self.service.display_avatar(state='neutral')
@@ -162,9 +186,9 @@ class AITutor:
                     st.write(message["content"])
                     if message["role"] == "assistant":
                         self.service.display_avatar(state='happy')
-                        if voice_active and message.get('speak', True):
-                            self.speak(message["content"])
-                            message['speak'] = False
+                        # if voice_active and message.get('speak', True):
+                        #     self.speak(message["content"])
+                        #     message['speak'] = False
 
         # Chat input
         if prompt := st.text_input("Ask your question...", key="chat_input"):
@@ -183,7 +207,7 @@ class AITutor:
         })
         
         # Generate and display AI response
-        response = self.service.generate_response(user_input, context['current_topic'])
+        response = self.service.generate_response(user_input)
         
         # Add AI response
         context['chat_history'].append({
@@ -196,9 +220,18 @@ class AITutor:
         self.service.display_avatar(state='happy')
         st.experimental_rerun()
 
+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
+
 def main():
     """Main Streamlit application entry point"""
-    st.set_page_config(page_title="AI Tutor", page_icon="🤖")
+    st.set_page_config(page_title="EduAI Platform", page_icon="🎓")
     
     ai_tutor = AITutor()
     ai_tutor.display_chat_interface()