Update app.py

app.py

@@ -6,13 +6,16 @@ import os
 import io
 import json
 import requests
+import base64
 from PIL import Image
 from gtts import gTTS
 from duckduckgo_search import DDGS
 import warnings
 warnings.filterwarnings('ignore')
 
-# Page Configuration
+# -----------------------------------------------------------------------------
+# 1. PAGE CONFIGURATION
+# -----------------------------------------------------------------------------
 st.set_page_config(
     page_title="H2 Physics Feynman Bot",
     page_icon="⚛️",
@@ -20,10 +23,13 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Audio generation
+# -----------------------------------------------------------------------------
+# 2. HELPER FUNCTIONS
+# -----------------------------------------------------------------------------
+
 @st.cache_data(show_spinner=False, ttl=3600)
 def generate_audio(text):
-    """Generates MP3 audio from text, skipping code/image tags."""
+    """Generates MP3 audio from text."""
     clean_text = re.sub(r'```.*?```', 'I have generated a graph.', text, flags=re.DOTALL)
     clean_text = re.sub(r'\[IMAGE:.*?\]', 'Here is a diagram.', clean_text)
     
@@ -37,12 +43,10 @@ def generate_audio(text):
         audio_fp.seek(0)
         return audio_fp
     except Exception as e:
-        st.error(f"Audio generation error: {e}")
         return None
 
-# Image search functions
 def google_search_api(query, api_key, cx):
-    """Helper: Performs a single Google Search."""
+    """Google Custom Search API."""
     try:
         url = "https://www.googleapis.com/customsearch/v1"
         params = {
@@ -69,180 +73,219 @@ def google_search_api(query, api_key, cx):
             return data["items"][0]["link"]
             
     except Exception as e:
-        print(f"Google API Exception: {e}")
         return None
     return None
 
 def duckduckgo_search_api(query):
-    """Helper: Fallback search using DuckDuckGo."""
+    """DuckDuckGo image search."""
     try:
         with DDGS() as ddgs:
             results = list(ddgs.images(query, max_results=1))
             if results:
                 return results[0]['image']
     except Exception as e:
-        return f"Search Error: {e}"
+        return None
     return None
 
 @st.cache_data(show_spinner=False, ttl=300)
 def search_image(query):
-    """MASTER FUNCTION: Google Search -> DuckDuckGo - FIXED FOR HUGGING FACE"""
+    """Image search with fallback."""
     try:
-        # Try to get secrets from Hugging Face Spaces
-        # Method 1: Check st.secrets (Hugging Face Spaces method)
-        try:
-            if hasattr(st, 'secrets'):
-                # Hugging Face Spaces stores secrets in st.secrets
-                cx = st.secrets.get("GOOGLE_CX", "")
-                key1 = st.secrets.get("GOOGLE_SEARCH_KEY", "")
-                key2 = st.secrets.get("GOOGLE_SEARCH_KEY_2", "")
-                
-                if key1 and cx:
-                    url = google_search_api(query, key1, cx)
-                    if url: 
-                        return url
-                
-                if key2 and cx:
-                    url = google_search_api(query, key2, cx)
-                    if url: 
-                        return url
-        except:
-            pass
+        # Check secrets
+        if hasattr(st, 'secrets'):
+            cx = st.secrets.get("GOOGLE_CX", "")
+            key1 = st.secrets.get("GOOGLE_SEARCH_KEY", "")
+            key2 = st.secrets.get("GOOGLE_SEARCH_KEY_2", "")
+            
+            if key1 and cx:
+                url = google_search_api(query, key1, cx)
+                if url: return url
+            
+            if key2 and cx:
+                url = google_search_api(query, key2, cx)
+                if url: return url
         
-        # Method 2: Check environment variables
-        cx = os.environ.get("GOOGLE_CX", "")
-        key1 = os.environ.get("GOOGLE_SEARCH_KEY", "")
-        key2 = os.environ.get("GOOGLE_SEARCH_KEY_2", "")
+        # Fallback to DuckDuckGo
+        return duckduckgo_search_api(query)
         
-        if key1 and cx:
-            url = google_search_api(query, key1, cx)
-            if url: 
-                return url
+    except Exception as e:
+        return None
 
-        if key2 and cx:
-            url = google_search_api(query, key2, cx)
-            if url: 
-                return url
+# -----------------------------------------------------------------------------
+# 3. QWEN-VL IMAGE ANALYSIS FUNCTIONS
+# -----------------------------------------------------------------------------
 
-        # Method 3: Fallback to DuckDuckGo
-        return duckduckgo_search_api(query)
+def analyze_image_with_qwen_api(image, query="What physics concepts are shown in this image?", api_key=None):
+    """Analyze image using DashScope Qwen-VL API."""
+    try:
+        # Convert image to base64
+        buffered = io.BytesIO()
+        
+        # Convert to RGB if necessary
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+            
+        image.save(buffered, format="JPEG", quality=85)
+        img_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+        
+        # Prepare API request
+        url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation"
+        
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        # Build message
+        messages = [
+            {
+                "role": "system",
+                "content": [
+                    {
+                        "text": "You are a physics expert analyzing images for educational purposes. Focus on identifying physics concepts, diagrams, equations, and explaining them clearly."
+                    }
+                ]
+            },
+            {
+                "role": "user",
+                "content": [
+                    {"image": f"data:image/jpeg;base64,{img_base64}"},
+                    {"text": query}
+                ]
+            }
+        ]
+        
+        payload = {
+            "model": "qwen-vl-plus",
+            "input": {"messages": messages},
+            "parameters": {
+                "max_tokens": 1000,
+                "temperature": 0.7
+            }
+        }
         
+        # Make API call
+        response = requests.post(url, json=payload, headers=headers, timeout=30)
+        
+        if response.status_code == 200:
+            result = response.json()
+            if "output" in result and "choices" in result["output"]:
+                return result["output"]["choices"][0]["message"]["content"]
+            else:
+                return "Analysis completed but no detailed response."
+        else:
+            return f"API Error {response.status_code}: {response.text[:200]}"
+            
     except Exception as e:
-        return f"Search Error: {str(e)[:100]}"
+        return f"Image analysis error: {str(e)[:100]}"
+
+def analyze_image_local_fallback(image, query):
+    """Simple local image analysis fallback."""
+    try:
+        # Get basic image info
+        width, height = image.size
+        format_info = image.format if image.format else "Unknown"
+        mode = image.mode
+        
+        analysis = f"Image analysis: {width}x{height} pixels, format: {format_info}, mode: {mode}. "
+        
+        # Try to detect if it's a physics-related image
+        if width > height:
+            analysis += "The image appears to be landscape orientation. "
+        else:
+            analysis += "The image appears to be portrait orientation. "
+        
+        # Add physics context
+        analysis += "For physics analysis, please describe what you see in the image, and I'll help explain the physics concepts."
+        
+        return analysis
+    except:
+        return "Image received. Please describe what you see in the image for physics analysis."
+
+# -----------------------------------------------------------------------------
+# 4. GRAPH FUNCTIONS
+# -----------------------------------------------------------------------------
 
-# Graph plotting function - REORDERED AND FIXED
 def execute_plotting_code(code_snippet):
-    """Execute plotting code in a safe environment."""
+    """Execute Python plotting code."""
     try:
-        # Clear any existing plots FIRST
         plt.close('all')
+        fig, ax = plt.subplots(figsize=(10, 6))
         
-        # Create a fresh figure
-        fig = plt.figure(figsize=(10, 6))
-        
-        # Create execution namespace with ALL required imports
         namespace = {
             'plt': plt,
             'np': np,
+            'ax': ax,
             'fig': fig,
-            'ax': None,
             'math': __import__('math')
         }
         
-        # Clean the code
         cleaned_code = code_snippet.strip()
         
-        # CRITICAL FIX: Ensure imports are at the top
+        # Ensure imports
         if 'import matplotlib' not in cleaned_code:
             cleaned_code = 'import matplotlib.pyplot as plt\nimport numpy as np\n' + cleaned_code
         
-        # CRITICAL FIX: Ensure plt.figure or plt.subplots is called
-        if 'plt.figure' not in cleaned_code and 'plt.subplots' not in cleaned_code:
-            cleaned_code = cleaned_code.replace('import matplotlib.pyplot as plt', 
-                                                'import matplotlib.pyplot as plt\nplt.figure(figsize=(10, 6))')
-        
-        # CRITICAL FIX: Check if there's actual plotting
-        plot_keywords = ['plt.plot(', 'ax.plot(', 'plt.scatter(', 'ax.scatter(', 
-                        'plt.bar(', 'ax.bar(', 'plt.hist(', 'ax.hist(']
-        
+        # Ensure plotting
+        plot_keywords = ['plt.plot(', 'ax.plot(', 'plt.scatter(', 'ax.scatter(']
         has_plot = any(keyword in cleaned_code for keyword in plot_keywords)
         
         if not has_plot:
-            # Add a sample plot
-            cleaned_code += '\n\n# Adding sample plot since no plotting command was found\n'
-            cleaned_code += 'x = np.linspace(0, 10, 100)\n'
-            cleaned_code += 'y = np.sin(x)\n'
-            cleaned_code += 'plt.plot(x, y, "b-", linewidth=2, label="sin(x)")\n'
+            cleaned_code += '\n\n# Sample plot\nx = np.linspace(0, 10, 100)\ny = np.sin(x)\nplt.plot(x, y, "b-", linewidth=2, label="sin(x)")\n'
         
-        # CRITICAL FIX: Ensure plt.show() is NOT in the code (Streamlit handles this)
+        # Remove plt.show
         cleaned_code = cleaned_code.replace('plt.show()', '')
-        cleaned_code = cleaned_code.replace('plt.show', '')
         
         # Add labels if missing
         if 'plt.xlabel' not in cleaned_code:
             cleaned_code += '\nplt.xlabel("X-axis", fontsize=12)'
         if 'plt.ylabel' not in cleaned_code:
             cleaned_code += '\nplt.ylabel("Y-axis", fontsize=12)'
-        if 'plt.title' not in cleaned_code:
-            cleaned_code += '\nplt.title("Physics Graph", fontsize=14)'
         if 'plt.grid' not in cleaned_code:
             cleaned_code += '\nplt.grid(True, linestyle="--", alpha=0.6)'
         
-        # DEBUG: Print the code being executed
-        # print("DEBUG - Executing code:\n", cleaned_code[:200])
-        
-        # EXECUTE THE CODE
         exec(cleaned_code, namespace)
         
-        # Get current figure
-        fig = plt.gcf()
+        ax = plt.gca()
+        if not ax.get_title():
+            ax.set_title('Physics Graph', fontsize=14)
         
-        # Display the plot IMMEDIATELY
         st.pyplot(fig)
-        
-        # Close the figure
         plt.close(fig)
         
-        return True
-        
     except Exception as e:
-        st.error(f"❌ Graph Error: {str(e)[:100]}")
+        st.error(f"Graph Error: {str(e)[:100]}")
         
-        # Create a SIMPLE guaranteed plot
+        # Fallback plot
         try:
             fig, ax = plt.subplots(figsize=(10, 6))
             x = np.linspace(0, 10, 100)
-            y = x**2  # Simple quadratic
+            y = x**2
             ax.plot(x, y, 'b-', linewidth=2, label='y = x²')
             ax.set_xlabel('X', fontsize=12)
             ax.set_ylabel('Y', fontsize=12)
-            ax.set_title('Sample Graph (Code had issues)', fontsize=14)
+            ax.set_title('Sample Graph', fontsize=14)
             ax.grid(True, linestyle='--', alpha=0.6)
             ax.legend()
             st.pyplot(fig)
             plt.close(fig)
-            st.warning("Displayed sample graph. The AI's code may need adjustment.")
         except:
-            st.error("⚠️ Could not generate any graph.")
-        
-        return False
-# Display message function
-# UPDATED Display message function - FIXED DEPRECATED PARAMETER
+            st.warning("Could not generate graph.")
+
 def display_message(role, content, enable_voice=False):
-    """Display chat message with all features."""
+    """Display chat message."""
     with st.chat_message(role):
         
         text_to_display = content
         
-        # 1. Extract Python code blocks
+        # Extract code blocks
         code_pattern = r'```python\s*(.*?)```'
         code_matches = list(re.finditer(code_pattern, content, re.DOTALL))
         
-        # Remove code blocks from displayed text
         for match in reversed(code_matches):
             text_to_display = text_to_display.replace(match.group(0), "")
         
-        # 2. Check for [IMAGE: query] Tags
+        # Check for image tags
         image_match = re.search(r'\[IMAGE:\s*(.*?)\]', text_to_display, re.IGNORECASE)
         image_result = None
         
@@ -252,48 +295,43 @@ def display_message(role, content, enable_voice=False):
             with st.spinner(f"Searching for '{search_query}'..."):
                 image_result = search_image(search_query)
 
-        # --- DISPLAY TEXT FIRST ---
+        # Display text
         st.markdown(text_to_display)
-        
-        # --- SHOW CODE IN EXPANDER FIRST ---
+
+        # Show code and graph
         if code_matches and role == "assistant":
             for match in code_matches:
                 code_content = match.group(1).strip()
                 if code_content:
-                    # Show code FIRST
                     with st.expander("📝 View Python Code", expanded=False):
                         st.code(code_content, language='python')
                     
-                    # Then show graph BELOW the code
                     with st.expander("📊 Generated Graph", expanded=True):
-                        # Execute and display graph
                         execute_plotting_code(code_content)
         
-        # --- DISPLAY IMAGE - FIXED WIDTH VALUE ---
+        # Show image
         if image_match and role == "assistant":
-            if image_result and not any(error in str(image_result).lower() for error in ["error", "no image", "search error"]):
+            if image_result and "http" in str(image_result):
                 try:
-                    # FIXED: Use 'auto' for automatic sizing or specify pixel width
-                    st.image(image_result, caption=f"📷 {image_match.group(1)}", width="auto")
+                    st.image(image_result, caption=f"📷 {image_match.group(1)}", width=500)
                     st.markdown(f"🔗 [Open Image]({image_result})")
-                except Exception as img_error:
-                    # Try alternative width values
-                    try:
-                        st.image(image_result, caption=f"📷 {image_match.group(1)}", width=500)
-                    except:
-                        st.warning(f"⚠️ Could not display image from URL: {image_result[:100]}")
+                except:
+                    st.warning("Could not display image.")
             else:
-                st.warning(f"⚠️ Image search failed for: '{image_match.group(1)}'")
+                st.warning(f"Image search failed.")
 
-
-        # --- AUDIO OUTPUT ---
+        # Audio output
         if enable_voice and role == "assistant" and len(text_to_display.strip()) > 10:
             audio_bytes = generate_audio(text_to_display)
             if audio_bytes:
                 st.audio(audio_bytes, format='audio/mp3')
-# Groq API function
+
+# -----------------------------------------------------------------------------
+# 5. GROQ API FUNCTION
+# -----------------------------------------------------------------------------
+
 def call_groq_api(api_key, messages, max_tokens=2000):
-    """Call Groq API - FREE tier available (10,000 requests/month)."""
+    """Call Groq API."""
     url = "https://api.groq.com/openai/v1/chat/completions"
     
     headers = {
@@ -301,7 +339,6 @@ def call_groq_api(api_key, messages, max_tokens=2000):
         "Content-Type": "application/json"
     }
     
-    # Format messages for Groq API
     formatted_messages = []
     for msg in messages:
         if msg["role"] == "system":
@@ -315,11 +352,9 @@ def call_groq_api(api_key, messages, max_tokens=2000):
                 "content": msg["content"]
             })
     
-    # Try multiple models
     models_to_try = [
         "llama-3.1-8b-instant",
         "llama-3.2-3b-preview",
-        "mixtral-8x7b-32768",
     ]
     
     for model in models_to_try:
@@ -339,18 +374,12 @@ def call_groq_api(api_key, messages, max_tokens=2000):
                 return result["choices"][0]["message"]["content"]
             elif response.status_code == 429:
                 continue
-            elif response.status_code == 401:
-                return "❌ Invalid API Key. Please check your Groq API key."
-            elif response.status_code == 402:
-                return "❌ Payment required. The free model might be unavailable. Try again later."
                 
-        except requests.exceptions.Timeout:
-            continue
-        except Exception as e:
+        except:
             continue
     
-    return "⚠️ All models are currently unavailable. Please try again in a few moments."
-
+    return "Service temporarily unavailable. Please try again."
+    
 # System Instructions for the AI - Part 5a (Start)
 SYSTEM_INSTRUCTIONS = """
 **Identity:** Richard Feynman. Tutor for Singapore H2 Physics (9478).
@@ -467,38 +496,124 @@ with st.sidebar:
     )
     
     enable_voice = st.toggle("🗣️ Text-to-Speech", value=False)
-    st.caption("Read responses aloud")
+    
+    st.divider()
+    
+    # Image Analysis Settings
+    st.header("🖼️ Image Analysis")
+    
+    image_analysis_mode = st.radio(
+        "Analysis Method:",
+        ["DashScope API", "Basic Analysis"],
+        index=0,
+        help="DashScope: Advanced AI analysis. Basic: Simple image info."
+    )
+    
+    if image_analysis_mode == "DashScope API":
+        # Get API key from secrets or env
+        dashscope_key = None
+        if hasattr(st, 'secrets') and "DASHSCOPE_API_KEY" in st.secrets:
+            dashscope_key = st.secrets["DASHSCOPE_API_KEY"]
+            st.success("✓ DashScope API configured")
+        elif "DASHSCOPE_API_KEY" in os.environ:
+            dashscope_key = os.environ["DASHSCOPE_API_KEY"]
+            st.success("✓ DashScope API configured")
+        else:
+            st.warning("Add DASHSCOPE_API_KEY to secrets")
+            st.info("Get free credits: dashscope.aliyun.com")
+    else:
+        st.info("Basic image analysis mode")
     
     #st.divider()
     
-    # Media Input (Kept simple)
-    st.header("📤 Upload Content")
+    # Media Input
+    st.header("📤 Input Methods")
     
     visual_content = None
-    uploaded_file = st.file_uploader(
-        "Upload Image", 
-        type=["jpg", "jpeg", "png"],
-        help="Upload diagrams, graphs, or physics problems"
+    image_analysis = None
+    
+    # Method selection
+    input_method = st.radio(
+        "Choose input method:",
+        ["Camera", "Upload"],
+        horizontal=True
     )
     
-    if uploaded_file:
-        try:
-            image = Image.open(uploaded_file)
-            visual_content = image
-            st.image(image, caption="Uploaded Image", width=200)
-            st.success("Image loaded")
-        except Exception as e:
-            st.error(f"Error: {e}")
+    if input_method == "Camera":
+        st.subheader("📷 Camera")
+        camera_photo = st.camera_input("Take a photo of physics problem")
+        
+        if camera_photo:
+            try:
+                image = Image.open(camera_photo)
+                visual_content = image
+                st.image(image, caption="Camera Capture", width=200)
+                st.success("✓ Photo captured")
+                
+                # Analyze immediately
+                with st.spinner("Analyzing image..."):
+                    if image_analysis_mode == "DashScope API" and dashscope_key:
+                        image_analysis = analyze_image_with_qwen_api(
+                            image, 
+                            "Analyze this physics image. What concepts, diagrams, or equations do you see?",
+                            dashscope_key
+                        )
+                    else:
+                        image_analysis = analyze_image_local_fallback(
+                            image,
+                            "Analyze this physics image"
+                        )
+                        
+                if image_analysis:
+                    st.info(f"📋 Analysis: {image_analysis[:150]}...")
+                    
+            except Exception as e:
+                st.error(f"Camera error: {e}")
+    
+    else:  # Upload
+        st.subheader("📁 Upload")
+        uploaded_file = st.file_uploader(
+            "Choose image", 
+            type=["jpg", "jpeg", "png"],
+            help="Upload physics diagrams or problems"
+        )
+        
+        if uploaded_file:
+            try:
+                image = Image.open(uploaded_file)
+                visual_content = image
+                st.image(image, caption="Uploaded Image", width=200)
+                st.success("✓ Image loaded")
+                
+                # Analyze immediately
+                with st.spinner("Analyzing image..."):
+                    if image_analysis_mode == "DashScope API" and dashscope_key:
+                        image_analysis = analyze_image_with_qwen_api(
+                            image, 
+                            "Analyze this physics image. What concepts, diagrams, or equations do you see?",
+                            dashscope_key
+                        )
+                    else:
+                        image_analysis = analyze_image_local_fallback(
+                            image,
+                            "Analyze this physics image"
+                        )
+                        
+                if image_analysis:
+                    st.info(f"📋 Analysis: {image_analysis[:150]}...")
+                    
+            except Exception as e:
+                st.error(f"Upload error: {e}")
     
     #st.divider()
     
-    # Simple Controls
+    # Controls
     if st.button("🧹 Clear Chat History", use_container_width=True):
         st.session_state.messages = []
         st.rerun()
     
     st.divider()
-    #st.caption("H2 Physics (9478) Syllabus")
+    st.caption("H2 Physics 9478 | Qwen-VL Image Analysis")
     st.caption("Made with ❤️ for JPJC H2 Physics students | Powered by Groq AI")
 
 # 7 Main Chat Interface
@@ -526,97 +641,77 @@ if user_input or visual_content:
     user_message = ""
     if user_input:
         user_message += user_input + " "
+    
     if visual_content:
-        user_message += "[I've uploaded an image related to physics. Please analyze it.] "
+        user_message += "[I have uploaded/taken a photo of a physics problem] "
+    
+    if image_analysis:
+        user_message += f"[Image Analysis: {image_analysis}] "
+    
     if topic != "General / Any":
         user_message += f"(Focus on: {topic})"
     
-    # Add user message to history
+    # Add to history
     st.session_state.messages.append({"role": "user", "content": user_message})
     
     # Display user message
     with st.chat_message("user"):
         if user_input:
             st.markdown(user_input)
+        
         if visual_content:
-            st.image(visual_content, caption="Uploaded Image", use_column_width=True)
-            st.caption("📸 Image attached for analysis")
+            st.image(visual_content, caption="Your Image", width=300)
+        
+        if image_analysis:
+            with st.expander("📋 Image Analysis Details"):
+                st.write(image_analysis)
     
-   
-    # Check for API key
-    if not api_key:
+    # Check for Groq API key
+    groq_key = None
+    if hasattr(st, 'secrets') and "GROQ_API_KEY" in st.secrets:
+        groq_key = st.secrets["GROQ_API_KEY"]
+    elif "GROQ_API_KEY" in os.environ:
+        groq_key = os.environ["GROQ_API_KEY"]
+    
+    if not groq_key:
         st.error(
-            "**❌ API Configuration Required**\n\n"
-            "The app needs API keys to function.\n\n"
-            "Please contact the administrator or check if the API keys "
-            "are properly configured in the deployment settings."
+            "**API Configuration Required**\n\n"
+            "Groq API key not found. Please ensure GROQ_API_KEY is set in secrets."
         )
         st.stop()
     
     # Prepare API call
     try:
-        # Build conversation context
         conversation_context = []
-        
-        # Add system message
         conversation_context.append({"role": "system", "content": SYSTEM_INSTRUCTIONS})
         
-        # Add recent conversation (last 8 messages for context)
         recent_messages = st.session_state.messages[-8:]
         for msg in recent_messages:
-            if msg["role"] != "system":  # Don't duplicate system message
+            if msg["role"] != "system":
                 conversation_context.append(msg)
         
         # Call Groq API
         with st.spinner("Feynman is thinking... ⚛️"):
-            response_text = call_groq_api(api_key, conversation_context)
+            response_text = call_groq_api(groq_key, conversation_context)
         
-        # Handle response
         if response_text:
-            # Check for error messages
-            if response_text.startswith("❌") or response_text.startswith("⚠️"):
-                st.error(response_text)
-                if "Invalid API Key" in response_text:
-                    st.info(
-                        "**Fix Invalid API Key:**\n"
-                        "1. Go to [console.groq.com](https://console.groq.com)\n"
-                        "2. Check your API keys\n"
-                        "3. Make sure you're using the correct key\n"
-                        "4. Keys start with: `gsk_`"
-                    )
-            else:
-                # Add assistant response to history
-                st.session_state.messages.append({"role": "assistant", "content": response_text})
-                
-                # Display response
-                display_message("assistant", response_text, enable_voice)
+            st.session_state.messages.append({"role": "assistant", "content": response_text})
+            display_message("assistant", response_text, enable_voice)
+            
+            # Clear image content after processing
+            if 'visual_content' in locals():
+                visual_content = None
+            if 'image_analysis' in locals():
+                image_analysis = None
                 
-                # Show token estimate
-                estimated_tokens = len(response_text) // 4
-                st.caption(f"📝 Response length: ~{estimated_tokens} tokens | ⚡ Powered by Groq")
         else:
-            st.error(
-                "**Failed to get response from Groq API.**\n\n"
-                "Possible reasons:\n"
-                "1. **Rate Limit** - Free tier has limits, wait a moment\n"
-                "2. **Service Down** - Groq might be experiencing issues\n"
-                "3. **Network Issue** - Check your connection\n\n"
-                "Try again in a moment."
-            )
+            st.error("Failed to get response. Please try again.")
             
     except Exception as e:
-        st.error(
-            f"**❌ Unexpected Error**\n\n"
-            f"```python\n{str(e)[:200]}\n```\n\n"
-            f"**Troubleshooting:**\n"
-            f"1. Refresh the page\n"
-            f"2. Check your API key\n"
-            f"3. Clear chat and try again\n"
-            f"4. Visit [status.groq.com](https://status.groq.com) for service status"
-        )
+        st.error(f"Error: {str(e)[:200]}")
 
 # Footer - SIMPLE VERSION
 st.divider()
-st.markdown("**H2 Physics Feynman Tutor** | Singapore H2 Physics (9478) Syllabus")
-st.markdown("Powered by [Groq AI](https://groq.com)")
-st.markdown("*Disclaimer: AI tutoring assistant. Always verify with official syllabus documents.*")
+st.markdown("H2 Physics Feynman Tutor | Singapore H2 Physics (9478) Syllabus")
+st.markdown("Powered by Groq AI + Qwen-VL Image Analysis")
+st.markdown("AI tutoring assistant. Verify with official syllabus.")