Update app.py

app.py

@@ -8,15 +8,34 @@ from collections import defaultdict
 from typing import Dict, List, Optional, Tuple, Union
 import html
 from pathlib import Path
+import fitz  # PyMuPDF for better PDF text extraction
+import pytesseract
+from PIL import Image
+import io
+import secrets
+import string
+from huggingface_hub import HfApi, HfFolder
 
 # ========== CONFIGURATION ==========
 PROFILES_DIR = "student_profiles"
-ALLOWED_FILE_TYPES = [".pdf"]
+ALLOWED_FILE_TYPES = [".pdf", ".png", ".jpg", ".jpeg"]  # Added image support
 MAX_FILE_SIZE_MB = 5
 MIN_AGE = 5
 MAX_AGE = 120
+SESSION_TOKEN_LENGTH = 32
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+# Initialize Hugging Face API
+if HF_TOKEN:
+    hf_api = HfApi(token=HF_TOKEN)
+    HfFolder.save_token(HF_TOKEN)
 
 # ========== UTILITY FUNCTIONS ==========
+def generate_session_token() -> str:
+    """Generate a random session token for user identification."""
+    alphabet = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(alphabet) for _ in range(SESSION_TOKEN_LENGTH))
+
 def sanitize_input(text: str) -> str:
     """Sanitize user input to prevent XSS and injection attacks."""
     return html.escape(text.strip())
@@ -55,52 +74,84 @@ def validate_file(file_obj) -> None:
     if file_size > MAX_FILE_SIZE_MB:
         raise gr.Error(f"File too large. Max size: {MAX_FILE_SIZE_MB}MB")
 
+def extract_text_with_ocr(file_path: str) -> str:
+    """Extract text from image files using OCR."""
+    try:
+        image = Image.open(file_path)
+        text = pytesseract.image_to_string(image)
+        return text
+    except Exception as e:
+        raise gr.Error(f"OCR processing failed: {str(e)}")
+
 # ========== TRANSCRIPT PARSING ==========
 def extract_gpa(text: str, gpa_type: str) -> str:
     """Extract GPA information from text with validation."""
-    pattern = rf'{gpa_type}\s*([\d\.]+)'
-    match = re.search(pattern, text)
-    if not match:
-        return "N/A"
+    patterns = [
+        rf'{gpa_type}\s*GPA\s*:\s*([\d\.]+)',  # "Weighted GPA: 3.5"
+        rf'{gpa_type}\s*GPA\s*([\d\.]+)',      # "Weighted GPA 3.5"
+        rf'{gpa_type}\s*:\s*([\d\.]+)',        # "Weighted: 3.5"
+        rf'{gpa_type}\s*([\d\.]+)'             # "Weighted 3.5"
+    ]
     
-    gpa_value = match.group(1)
-    try:
-        gpa_float = float(gpa_value)
-        if not 0.0 <= gpa_float <= 5.0:  # Assuming 5.0 is max for weighted GPA
-            return "Invalid GPA"
-        return gpa_value
-    except ValueError:
-        return "N/A"
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            gpa_value = match.group(1)
+            try:
+                gpa_float = float(gpa_value)
+                if not 0.0 <= gpa_float <= 5.0:  # Assuming 5.0 is max for weighted GPA
+                    return "Invalid GPA"
+                return gpa_value
+            except ValueError:
+                continue
+    
+    return "N/A"
 
 def extract_courses_from_table(text: str) -> Dict[str, List[Dict]]:
     """Extract course information with multiple pattern fallbacks."""
-    # Primary pattern with strict formatting
-    primary_pattern = re.compile(
-        r'(\d{4}-\d{4})\s*'  # School year
-        r'\|?\s*(\d+)\s*'     # Grade level
-        r'\|?\s*([A-Z0-9]+)\s*'  # Course code
-        r'\|?\s*([^\|]+?)\s*'  # Course name
-        r'(?:\|\s*[^\|]*){2}'  # Skip Term and DstNumber
-        r'\|\s*([A-FW]?)\s*'   # Grade (FG column)
-        r'(?:\|\s*[^\|]*)'     # Skip Incl column
-        r'\|\s*([\d\.]+|inProgress)'  # Credits
-    )
-    
-    # Fallback pattern for less structured data
-    fallback_pattern = re.compile(
-        r'(\d{4}-\d{4})\s+'  # School year
-        r'(\d+)\s+'          # Grade level
-        r'([A-Z0-9]+)\s+'     # Course code
-        r'(.+?)\s+'           # Course name
-        r'([A-FW]?)\s*'       # Grade
-        r'([\d\.]+|inProgress)'  # Credits
-    )
+    # Enhanced patterns to handle more transcript formats
+    patterns = [
+        # Pattern 1: Structured table format
+        re.compile(
+            r'(\d{4}-\d{4})\s*'  # School year
+            r'\|?\s*(\d+)\s*'     # Grade level
+            r'\|?\s*([A-Z0-9]+)\s*'  # Course code
+            r'\|?\s*([^\|]+?)\s*'  # Course name
+            r'(?:\|\s*[^\|]*){2}'  # Skip Term and DstNumber
+            r'\|\s*([A-FW][+-]?)\s*'   # Grade (FG column)
+            r'(?:\|\s*[^\|]*)'     # Skip Incl column
+            r'\|\s*([\d\.]+|inProgress)'  # Credits
+        ),
+        # Pattern 2: Less structured format
+        re.compile(
+            r'(\d{4}-\d{4})\s+'  # School year
+            r'(\d+)\s+'          # Grade level
+            r'([A-Z0-9]+)\s+'     # Course code
+            r'(.+?)\s+'           # Course name
+            r'([A-FW][+-]?)\s*'       # Grade
+            r'([\d\.]+|inProgress)'  # Credits
+        ),
+        # Pattern 3: Semester-based format
+        re.compile(
+            r'(Fall|Spring|Summer)\s+(\d{4})\s+'  # Term and year
+            r'(\d+)\s+'          # Grade level
+            r'([A-Z0-9]+)\s+'     # Course code
+            r'(.+?)\s+'           # Course name
+            r'([A-FW][+-]?)\s*'       # Grade
+            r'([\d\.]+)'          # Credits
+        )
+    ]
     
     courses_by_grade = defaultdict(list)
     
-    for pattern in [primary_pattern, fallback_pattern]:
+    for pattern in patterns:
         for match in re.finditer(pattern, text):
-            year_range, grade_level, course_code, course_name, grade, credits = match.groups()
+            if len(match.groups()) == 6:
+                year_range, grade_level, course_code, course_name, grade, credits = match.groups()
+                term = None
+            else:
+                term, year, grade_level, course_code, course_name, grade, credits = match.groups()
+                year_range = f"{term} {year}"
             
             # Clean and format course information
             course_name = course_name.strip()
@@ -126,7 +177,7 @@ def extract_courses_from_table(text: str) -> Dict[str, List[Dict]]:
     return courses_by_grade
 
 def parse_transcript(file_obj) -> Tuple[str, Optional[Dict]]:
-    """Parse transcript file with robust error handling."""
+    """Parse transcript file with robust error handling and OCR support."""
     try:
         if not file_obj:
             raise gr.Error("Please upload a file first")
@@ -134,28 +185,44 @@ def parse_transcript(file_obj) -> Tuple[str, Optional[Dict]]:
         validate_file(file_obj)
         
         text = ''
+        file_ext = os.path.splitext(file_obj.name)[1].lower()
+        
         try:
-            reader = PdfReader(file_obj)
-            for page in reader.pages:
-                page_text = page.extract_text()
-                if page_text:
-                    text += page_text + '\n'
+            if file_ext == '.pdf':
+                # Try PyMuPDF first for better text extraction
+                try:
+                    doc = fitz.open(file_obj.name)
+                    for page in doc:
+                        text += page.get_text() + '\n'
+                except:
+                    # Fallback to PyPDF2
+                    reader = PdfReader(file_obj.name)
+                    for page in reader.pages:
+                        page_text = page.extract_text()
+                        if page_text:
+                            text += page_text + '\n'
+            elif file_ext in ['.png', '.jpg', '.jpeg']:
+                text = extract_text_with_ocr(file_obj.name)
         except Exception as e:
-            raise gr.Error(f"Error processing PDF: {str(e)}")
+            raise gr.Error(f"Error processing file: {str(e)}")
         
         if not text.strip():
-            raise gr.Error("No text could be extracted from the PDF")
+            raise gr.Error("No text could be extracted from the file")
         
-        # Extract GPA data with validation
+        # Enhanced GPA extraction
         gpa_data = {
-            'weighted': extract_gpa(text, 'Weighted GPA'),
-            'unweighted': extract_gpa(text, 'Un-weighted GPA')
+            'weighted': extract_gpa(text, 'Weighted'),
+            'unweighted': extract_gpa(text, 'Unweighted')
         }
         
-        # Extract grade level with fallback
-        grade_match = re.search(r'Current Grade:\s*(\d+)', text) or \
-                     re.search(r'Grade\s*:\s*(\d+)', text) or \
-                     re.search(r'Grade\s+(\d+)', text)
+        # Extract grade level with multiple fallback patterns
+        grade_match = (
+            re.search(r'Current Grade:\s*(\d+)', text) or
+            re.search(r'Grade\s*:\s*(\d+)', text) or
+            re.search(r'Grade\s+(\d+)', text) or
+            re.search(r'Grade\s+Level:\s*(\d+)', text) or
+            re.search(r'Grade\s*\(?\s*(\d+)\s*\)?', text)
+        )
         grade_level = grade_match.group(1) if grade_match else "Unknown"
         
         courses_by_grade = extract_courses_from_table(text)
@@ -244,6 +311,10 @@ class LearningStyleQuiz:
                     "Watch educational videos",
                     "Use flashcards with images",
                     "Highlight important information in different colors"
+                ],
+                "careers": [
+                    "Graphic Designer", "Architect", "Photographer", 
+                    "Engineer", "Surgeon", "Pilot"
                 ]
             },
             "Auditory": {
@@ -254,6 +325,10 @@ class LearningStyleQuiz:
                     "Explain concepts out loud to yourself",
                     "Use rhymes or songs to remember information",
                     "Listen to educational podcasts"
+                ],
+                "careers": [
+                    "Musician", "Journalist", "Lawyer",
+                    "Psychologist", "Teacher", "Customer Service"
                 ]
             },
             "Reading/Writing": {
@@ -264,6 +339,10 @@ class LearningStyleQuiz:
                     "Read textbooks and articles",
                     "Make lists to organize information",
                     "Rewrite your notes to reinforce learning"
+                ],
+                "careers": [
+                    "Writer", "Researcher", "Editor",
+                    "Accountant", "Programmer", "Historian"
                 ]
             },
             "Kinesthetic": {
@@ -274,12 +353,16 @@ class LearningStyleQuiz:
                     "Create physical models",
                     "Associate information with physical actions",
                     "Study while walking or pacing"
+                ],
+                "careers": [
+                    "Athlete", "Chef", "Mechanic",
+                    "Dancer", "Physical Therapist", "Carpenter"
                 ]
             }
         }
     
     def evaluate_quiz(self, *answers) -> str:
-        """Evaluate quiz answers and generate results."""
+        """Evaluate quiz answers and generate enhanced results."""
         answers = list(answers)  # Convert tuple to list
         if len(answers) != len(self.questions):
             raise gr.Error("Not all questions were answered")
@@ -302,7 +385,7 @@ class LearningStyleQuiz:
         percentages = {style: (score/total_answered)*100 for style, score in scores.items()}
         sorted_styles = sorted(scores.items(), key=lambda x: x[1], reverse=True)
         
-        # Generate results report
+        # Generate enhanced results report
         result = "## Your Learning Style Results\n\n"
         result += "### Scores:\n"
         for style, score in sorted_styles:
@@ -324,6 +407,10 @@ class LearningStyleQuiz:
             for tip in style_info['tips']:
                 result += f"- {tip}\n"
             
+            result += "\n**Potential Career Paths**:\n"
+            for career in style_info['careers'][:6]:
+                result += f"- {career}\n"
+            
             # Add complementary strategies
             complementary = [s for s in sorted_styles if s[0] != primary_style][0][0]
             result += f"\nYou might also benefit from some **{complementary}** strategies:\n"
@@ -340,6 +427,10 @@ class LearningStyleQuiz:
                 result += f"\n**{style}** techniques:\n"
                 for tip in self.learning_styles[style]['tips'][:2]:
                     result += f"- {tip}\n"
+                
+                result += f"\n**{style}** career suggestions:\n"
+                for career in self.learning_styles[style]['careers'][:3]:
+                    result += f"- {career}\n"
         
         return result
 
@@ -351,6 +442,17 @@ class ProfileManager:
     def __init__(self):
         self.profiles_dir = Path(PROFILES_DIR)
         self.profiles_dir.mkdir(exist_ok=True, parents=True)
+        self.current_session = None
+    
+    def set_session(self, session_token: str) -> None:
+        """Set the current session token."""
+        self.current_session = session_token
+    
+    def get_profile_path(self, name: str) -> Path:
+        """Get profile path with session token if available."""
+        if self.current_session:
+            return self.profiles_dir / f"{name.replace(' ', '_')}_{self.current_session}_profile.json"
+        return self.profiles_dir / f"{name.replace(' ', '_')}_profile.json"
     
     def save_profile(self, name: str, age: Union[int, str], interests: str, 
                     transcript: Dict, learning_style: str, 
@@ -384,34 +486,67 @@ class ProfileManager:
                 "transcript": transcript if transcript else {},
                 "learning_style": learning_style if learning_style else "Not assessed",
                 "favorites": favorites,
-                "blog": sanitize_input(blog) if blog else ""
+                "blog": sanitize_input(blog) if blog else "",
+                "session_token": self.current_session
             }
             
             # Save to JSON file
-            filename = f"{name.replace(' ', '_')}_profile.json"
-            filepath = self.profiles_dir / filename
+            filepath = self.get_profile_path(name)
             
             with open(filepath, "w", encoding='utf-8') as f:
                 json.dump(data, f, indent=2, ensure_ascii=False)
             
+            # Upload to HF Hub if token is available
+            if HF_TOKEN:
+                try:
+                    hf_api.upload_file(
+                        path_or_fileobj=filepath,
+                        path_in_repo=f"profiles/{filepath.name}",
+                        repo_id="your-username/student-learning-assistant",
+                        repo_type="dataset"
+                    )
+                except Exception as e:
+                    print(f"Failed to upload to HF Hub: {str(e)}")
+            
             return self._generate_profile_summary(data)
         
         except Exception as e:
             raise gr.Error(f"Error saving profile: {str(e)}")
     
-    def load_profile(self, name: str = None) -> Dict:
+    def load_profile(self, name: str = None, session_token: str = None) -> Dict:
         """Load profile by name or return the first one found."""
         try:
-            profiles = list(self.profiles_dir.glob("*.json"))
+            if session_token:
+                profile_pattern = f"*{session_token}_profile.json"
+            else:
+                profile_pattern = "*.json"
+            
+            profiles = list(self.profiles_dir.glob(profile_pattern))
             if not profiles:
                 return {}
             
             if name:
                 # Find profile by name
                 name = name.replace(" ", "_")
-                profile_file = self.profiles_dir / f"{name}_profile.json"
+                if session_token:
+                    profile_file = self.profiles_dir / f"{name}_{session_token}_profile.json"
+                else:
+                    profile_file = self.profiles_dir / f"{name}_profile.json"
+                
                 if not profile_file.exists():
-                    raise gr.Error(f"No profile found for {name}")
+                    # Try loading from HF Hub
+                    if HF_TOKEN:
+                        try:
+                            hf_api.download_file(
+                                path_in_repo=f"profiles/{profile_file.name}",
+                                repo_id="your-username/student-learning-assistant",
+                                repo_type="dataset",
+                                local_dir=self.profiles_dir
+                            )
+                        except:
+                            raise gr.Error(f"No profile found for {name}")
+                    else:
+                        raise gr.Error(f"No profile found for {name}")
             else:
                 # Load the first profile found
                 profile_file = profiles[0]
@@ -423,26 +558,36 @@ class ProfileManager:
             print(f"Error loading profile: {str(e)}")
             return {}
     
-    def list_profiles(self) -> List[str]:
-        """List all available profile names."""
-        profiles = list(self.profiles_dir.glob("*.json"))
-        return [p.stem.replace("_profile", "").replace("_", " ") for p in profiles]
+    def list_profiles(self, session_token: str = None) -> List[str]:
+        """List all available profile names for the current session."""
+        if session_token:
+            profiles = list(self.profiles_dir.glob(f"*{session_token}_profile.json"))
+        else:
+            profiles = list(self.profiles_dir.glob("*.json"))
+        
+        # Extract just the name part (without session token)
+        profile_names = []
+        for p in profiles:
+            name_part = p.stem.replace("_profile", "")
+            if session_token:
+                name_part = name_part.replace(f"_{session_token}", "")
+            profile_names.append(name_part.replace("_", " "))
+        
+        return profile_names
     
     def _generate_profile_summary(self, data: Dict) -> str:
         """Generate markdown summary of the profile."""
         transcript = data.get("transcript", {})
         favorites = data.get("favorites", {})
+        learning_style = data.get("learning_style", "Not assessed")
         
         markdown = f"""## Student Profile: {data['name']}
-
 ### Basic Information
 - **Age:** {data['age']}
 - **Interests:** {data['interests']}
-- **Learning Style:** {data['learning_style'].split('##')[0].strip()}
-
+- **Learning Style:** {learning_style.split('##')[0].strip()}
 ### Academic Information
 {self._format_transcript(transcript)}
-
 ### Favorites
 - **Movie:** {favorites.get('movie', 'Not specified')}  
   *Reason:* {favorites.get('movie_reason', 'Not specified')}
@@ -452,7 +597,6 @@ class ProfileManager:
   *Reason:* {favorites.get('book_reason', 'Not specified')}
 - **Character:** {favorites.get('character', 'Not specified')}  
   *Reason:* {favorites.get('character_reason', 'Not specified')}
-
 ### Personal Blog
 {data.get('blog', '_No blog provided_')}
 """
@@ -494,11 +638,11 @@ class TeachingAssistant:
         self.context_history = []
         self.max_context_length = 5  # Keep last 5 exchanges for context
     
-    def generate_response(self, message: str, history: List[List[Union[str, None]]]) -> str:
+    def generate_response(self, message: str, history: List[List[Union[str, None]]], session_token: str) -> str:
         """Generate personalized response based on student profile and context."""
         try:
-            # Load profile (simplified - in real app would handle multiple profiles)
-            profile = profile_manager.load_profile()
+            # Load profile with session token
+            profile = profile_manager.load_profile(session_token=session_token)
             if not profile:
                 return "Please complete and save your profile first using the previous tabs."
             
@@ -725,7 +869,6 @@ class TeachingAssistant:
 - **Course advice**: "Show me my course history"
 - **Interest suggestions**: "What clubs match my interests?"
 - **General advice**: "How can I improve my grades?"
-
 Try asking about any of these topics!""")
 
 # Initialize teaching assistant
@@ -734,6 +877,10 @@ teaching_assistant = TeachingAssistant()
 # ========== GRADIO INTERFACE ==========
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Student Learning Assistant") as app:
+        # Session state
+        session_token = gr.State(value=generate_session_token())
+        profile_manager.set_session(session_token.value)
+        
         # Custom CSS for better styling
         app.css = """
         .gradio-container {
@@ -758,6 +905,16 @@ def create_interface():
             background: #f5f5f5;
             border-radius: 5px;
         }
+        .profile-card {
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 15px;
+            margin-bottom: 15px;
+            background: white;
+        }
+        .chatbot {
+            min-height: 500px;
+        }
         """
         
         gr.Markdown("""
@@ -786,17 +943,20 @@ def create_interface():
                 with gr.Row():
                     with gr.Column(scale=1):
                         gr.Markdown("### Step 1: Upload Your Transcript")
-                        gr.Markdown("Upload a PDF of your academic transcript to analyze your courses and GPA.")
+                        gr.Markdown("Upload a PDF or image of your academic transcript to analyze your courses and GPA.")
                         
                         with gr.Group():
                             transcript_file = gr.File(
-                                label="Transcript PDF",
+                                label="Transcript (PDF or Image)",
                                 file_types=ALLOWED_FILE_TYPES,
                                 type="filepath"
                             )
                             upload_btn = gr.Button("Upload & Analyze", variant="primary")
                         
-                        gr.Markdown("**Note**: Your file is processed locally and not stored permanently.")
+                        gr.Markdown("""
+                        **Supported Formats**: PDF, PNG, JPG  
+                        **Note**: Your file is processed locally and not stored permanently.
+                        """)
                     
                     with gr.Column(scale=2):
                         transcript_output = gr.Textbox(
@@ -913,12 +1073,18 @@ def create_interface():
                         gr.Markdown("Verify your information before saving. You can return to previous steps to make changes.")
                         
                         save_btn = gr.Button("Save Profile", variant="primary")
-                        load_profile_dropdown = gr.Dropdown(
-                            label="Or load existing profile",
-                            choices=profile_manager.list_profiles(),
-                            visible=bool(profile_manager.list_profiles())
-                        )
-                        load_btn = gr.Button("Load Profile", visible=bool(profile_manager.list_profiles()))
+                        
+                        # Profile management section
+                        with gr.Group():
+                            load_profile_dropdown = gr.Dropdown(
+                                label="Load Existing Profile",
+                                choices=profile_manager.list_profiles(session_token.value),
+                                visible=bool(profile_manager.list_profiles(session_token.value))
+                            )
+                            with gr.Row():
+                                load_btn = gr.Button("Load", visible=bool(profile_manager.list_profiles(session_token.value)))
+                                delete_btn = gr.Button("Delete", variant="stop", visible=bool(profile_manager.list_profiles(session_token.value)))
+                        
                         clear_btn = gr.Button("Clear Form")
                     
                     with gr.Column(scale=2):
@@ -927,6 +1093,7 @@ def create_interface():
                             label="Profile Summary"
                         )
                 
+                # Save profile
                 save_btn.click(
                     fn=profile_manager.save_profile,
                     inputs=[
@@ -935,14 +1102,55 @@ def create_interface():
                         book, book_reason, character, character_reason, blog_text
                     ],
                     outputs=output_summary
+                ).then(
+                    fn=lambda: profile_manager.list_profiles(session_token.value),
+                    outputs=load_profile_dropdown
+                ).then(
+                    fn=lambda: gr.update(visible=True),
+                    outputs=load_btn
+                ).then(
+                    fn=lambda: gr.update(visible=True),
+                    outputs=delete_btn
                 )
                 
+                # Load profile
                 load_btn.click(
-                    fn=lambda name: profile_manager.load_profile(name),
+                    fn=lambda name: profile_manager.load_profile(name, session_token.value),
                     inputs=load_profile_dropdown,
                     outputs=output_summary
                 )
                 
+                # Delete profile
+                def delete_profile(name, session_token):
+                    if not name:
+                        raise gr.Error("Please select a profile to delete")
+                    try:
+                        profile_path = profile_manager.get_profile_path(name)
+                        if profile_path.exists():
+                            profile_path.unlink()
+                        return "Profile deleted successfully", ""
+                    except Exception as e:
+                        raise gr.Error(f"Error deleting profile: {str(e)}")
+                
+                delete_btn.click(
+                    fn=delete_profile,
+                    inputs=[load_profile_dropdown, session_token],
+                    outputs=[output_summary, load_profile_dropdown]
+                ).then(
+                    fn=lambda: gr.update(
+                        choices=profile_manager.list_profiles(session_token.value),
+                        visible=bool(profile_manager.list_profiles(session_token.value))
+                    ),
+                    outputs=load_profile_dropdown
+                ).then(
+                    fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
+                    outputs=load_btn
+                ).then(
+                    fn=lambda: gr.update(visible=bool(profile_manager.list_profiles(session_token.value))),
+                    outputs=delete_btn
+                )
+                
+                # Clear form
                 clear_btn.click(
                     fn=lambda: [gr.update(value="") for _ in range(12)],
                     outputs=[
@@ -958,8 +1166,9 @@ def create_interface():
                 gr.Markdown("## Your Personalized Learning Assistant")
                 gr.Markdown("Ask me anything about studying, your courses, grades, or learning strategies.")
                 
+                # Chat interface with session token
                 chatbot = gr.ChatInterface(
-                    fn=teaching_assistant.generate_response,
+                    fn=lambda msg, hist: teaching_assistant.generate_response(msg, hist, session_token.value),
                     examples=[
                         "How should I study for my next math test?",
                         "What's my current GPA?",
@@ -967,7 +1176,10 @@ def create_interface():
                         "How can I improve my grades in science?",
                         "What study methods match my learning style?"
                     ],
-                    title=""
+                    title="",
+                    retry_btn=None,
+                    undo_btn=None,
+                    clear_btn="Clear Chat"
                 )
         
         # Tab navigation logic