Upload 4 files

components/output_renderer.py

@@ -0,0 +1,37 @@
+import streamlit as st
+import re
+
+def render_output_section():
+    """Render the generated output section - FIXED for regenerated content"""
+    if st.session_state.generated_output:
+        # ALWAYS render the current content, regardless of regeneration status
+        render_output(st.session_state.generated_output)
+
+def render_output(output):
+    """Render output with LaTeX support"""
+    st.markdown("---")
+    st.markdown("### 📘 Generated Content")
+
+    # Extract and render LaTeX
+    output = render_latex_expressions(output)
+    
+    # Render remaining text
+    st.markdown(output.strip(), unsafe_allow_html=True)
+
+def render_latex_expressions(output):
+    """Extract and render LaTeX expressions from output"""
+    latex_patterns = re.findall(r"\$\$(.+?)\$\$|\\\[(.+?)\\\]|\\\((.+?)\\\)", output, re.DOTALL)
+
+    for groups in latex_patterns:
+        latex_expr = next(filter(None, groups))
+        try:
+            st.latex(latex_expr.strip())
+        except:
+            st.markdown(f"`{latex_expr}`")
+
+        # Clean LaTeX from output for text display
+        for g in groups:
+            if g:
+                output = output.replace(f"$${g}$$", "").replace(f"\\[{g}\\]", "").replace(f"\\({g}\\)", "")
+    
+    return output

components/student_flow.py

@@ -0,0 +1,439 @@
+import streamlit as st
+import re
+from generator import model_manager
+from components.file_processor import get_student_content_input
+from components.export_handler import generate_pdf
+from components.session_manager import update_session_state
+
+def render_student_flow():
+    """Render the student content generation flow"""
+    st.header("🎓 Student Learning Assistant")
+    render_student_info()
+    
+    # Check if we need to regenerate with a different model
+    if st.session_state.get("regenerate_with_new_model") and st.session_state.get("original_content_text"):
+        handle_student_regeneration()
+        return
+    
+    content_text, filename = get_student_content_input()
+    student_level = get_student_level()
+    specific_help = get_student_context()
+    
+    if content_text and st.button("🚀 Simplify This Content", type="primary", key="generate_student_content"):
+        generate_student_content(content_text, student_level, specific_help, filename)
+
+def handle_student_regeneration():
+    """Handle student content regeneration with new model"""
+    st.header("🎓 Student Learning Assistant")
+    render_student_info()
+    
+    # Show we're regenerating
+    st.info("🔄 Regenerating your content with the new model...")
+    
+    # Get preserved inputs
+    content_text = st.session_state.original_content_text
+    student_level = st.session_state.student_level
+    specific_help = st.session_state.get("original_specific_help", "")
+    filename = st.session_state.get("original_filename", "regenerated_content.pdf")
+    
+    # Show original inputs for context
+    with st.expander("📋 Original Inputs (Read-only)", expanded=True):
+        st.write(f"**Student Level:** {student_level}")
+        st.write(f"**Content Length:** {len(content_text)} characters")
+        if specific_help:
+            st.write(f"**Specific Help Requested:** {specific_help}")
+    
+    # Regenerate the content
+    generate_student_content(content_text, student_level, specific_help, filename)
+
+def render_student_info():
+    """Render student flow information"""
+    st.info("""
+    **How this works:** 
+    Upload your course material or paste difficult content, and I'll generate a simplified, 
+    easy-to-understand version tailored to your level.
+    """)
+
+def get_student_level():
+    """Get student's academic level"""
+    st.subheader("🎯 Your Learning Level")
+    return st.selectbox(
+        "What's your current academic level?",
+        ["High School", "Undergraduate (1st-2nd year)", "Undergraduate (3rd-4th year)", "Masters", "PhD"],
+        help="This helps me tailor the explanation to your level",
+        key="student_level_select"
+    )
+
+def get_student_context():
+    """Get additional context from student"""
+    st.subheader("💡 Additional Context (Optional)")
+    return st.text_area(
+        "What specifically are you struggling with?",
+        placeholder="e.g., 'I don't understand backpropagation' or 'The math notation is confusing'",
+        help="Tell me what's confusing you for better help",
+        key="student_context_input"
+    )
+
+def generate_student_content(content_text, student_level, specific_help, filename):
+    """Generate content for student with optimized content handling"""
+    # STORE ORIGINAL CONTENT FOR REGENERATION
+    st.session_state.original_content_text = content_text
+    st.session_state.original_specific_help = specific_help
+    st.session_state.original_filename = filename
+    
+    if len(content_text) > 15000:
+        st.info("📝 Your content is quite comprehensive. I'll process it in sections for optimal quality...")
+        generate_chunked_content(content_text, student_level, specific_help, filename)
+    elif len(content_text) > 8000:
+        st.info("📝 Processing your content with optimized models...")
+        generate_single_large_content(content_text, student_level, specific_help, filename)
+    else:
+        generate_single_content(content_text, student_level, specific_help, filename)
+
+def generate_single_content(content_text, student_level, specific_help, filename):
+    """Generate content for normal-sized inputs"""
+    with st.spinner("✍️ Creating student-friendly explanation..."):
+        selected_model = st.session_state.get("selected_model", "groq")
+        
+        # Use Phi-3 specific prompts if Phi-3 is selected
+        if selected_model == "phi3":
+            prompt = build_phi3_student_prompt(content_text, student_level, specific_help)
+        else:
+            prompt = build_groq_student_prompt(content_text, student_level, specific_help)
+        
+        try:
+            output = model_manager.generate(
+                prompt, 
+                selected_model,
+                user_type="student",
+                student_level=student_level,
+                content_type="simplified_explanation"
+            )
+            
+            if output is None:
+                st.error("❌ AI service returned no response")
+                return
+            
+            # Clean the output for Phi-3 specifically
+            if selected_model == "phi3":
+                output = clean_phi3_output(output)
+            
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(output)
+                return
+            
+            # Generate PDF first
+            pdf_data = generate_pdf(output, "student", level=student_level)
+            
+            # Update session state
+            update_session_state(
+                original_prompt=prompt,
+                generated_output=output,
+                feedback_given=False,
+                regenerated=False,
+                content_source="student",
+                student_level=student_level,
+                original_filename=filename,
+                pdf_export_data=pdf_data,
+                saved_to_history=False,
+                current_history_id=None,
+                generated_model=selected_model
+            )
+            
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"❌ Generation failed: {str(e)}")
+
+def generate_single_large_content(content_text, student_level, specific_help, filename):
+    """Generate content for large but manageable inputs using high-capacity models"""
+    with st.spinner("✍️ Creating comprehensive explanation..."):
+        selected_model = st.session_state.get("selected_model", "groq")
+        
+        # Use Phi-3 specific prompts if Phi-3 is selected
+        if selected_model == "phi3":
+            prompt = build_phi3_student_prompt(content_text, student_level, specific_help)
+        else:
+            prompt = build_groq_student_prompt(content_text, student_level, specific_help)
+        
+        try:
+            if selected_model == "phi3":
+                output = model_manager.generate(
+                    prompt, 
+                    selected_model,
+                    user_type="student",
+                    student_level=student_level,
+                    content_type="simplified_explanation"
+                )
+                output = clean_phi3_output(output)
+            else:
+                output = model_manager.groq_generator.generate_large_content(prompt)
+            
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(output)
+                return
+            
+            # Generate PDF and update session state
+            pdf_data = generate_pdf(output, "student", level=student_level)
+            
+            update_session_state(
+                original_prompt=prompt,
+                generated_output=output,
+                feedback_given=False,
+                regenerated=False,
+                content_source="student",
+                student_level=student_level,
+                original_filename=filename,
+                pdf_export_data=pdf_data,
+                saved_to_history=False,
+                current_history_id=None,
+                generated_model=selected_model
+            )
+            
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"❌ Generation failed: {str(e)}")
+
+def generate_chunked_content(content_text, student_level, specific_help, filename):
+    """Generate content for very large inputs by chunking"""
+    chunks = chunk_content(content_text, max_chunk_size=8000)
+    
+    if not chunks:
+        st.error("❌ Unable to process this content. Please try with shorter text.")
+        return
+    
+    all_outputs = []
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    selected_model = st.session_state.get("selected_model", "groq")
+    
+    for i, chunk in enumerate(chunks):
+        status_text.text(f"📖 Processing section {i+1}/{len(chunks)}...")
+        progress_bar.progress((i) / len(chunks))
+        
+        # Use Phi-3 specific prompts if Phi-3 is selected
+        if selected_model == "phi3":
+            prompt = build_phi3_chunk_prompt(chunk, student_level, specific_help, i+1, len(chunks))
+        else:
+            prompt = build_groq_chunk_prompt(chunk, student_level, specific_help, i+1, len(chunks))
+        
+        try:
+            output = model_manager.generate(
+                prompt, 
+                selected_model,
+                user_type="student", 
+                student_level=student_level,
+                content_type="simplified_explanation"
+            )
+            
+            if selected_model == "phi3":
+                output = clean_phi3_output(output)
+            
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(f"❌ Failed to process section {i+1}: {output}")
+                return
+            
+            all_outputs.append(output)
+            
+        except Exception as e:
+            st.error(f"❌ Failed to process section {i+1}: {str(e)}")
+            return
+    
+    # Update progress to complete
+    progress_bar.progress(1.0)
+    status_text.text("✅ All sections processed! Combining results...")
+    
+    # Combine all outputs
+    final_output = combine_chunk_outputs(all_outputs, student_level)
+    
+    # Generate PDF and update session state
+    pdf_data = generate_pdf(final_output, "student", level=student_level)
+    
+    update_session_state(
+        original_prompt=f"Simplified content for {student_level} level",
+        generated_output=final_output,
+        feedback_given=False,
+        regenerated=False,
+        content_source="student", 
+        student_level=student_level,
+        original_filename=filename,
+        pdf_export_data=pdf_data,
+        saved_to_history=False,
+        current_history_id=None,
+        generated_model=selected_model
+    )
+    
+    status_text.text("✅ Content generation complete!")
+    st.rerun()
+
+def chunk_content(content, max_chunk_size=8000):
+    """Split content into manageable chunks based on new limits"""
+    paragraphs = re.split(r'\n\s*\n', content)
+    chunks = []
+    current_chunk = ""
+    
+    for paragraph in paragraphs:
+        if len(current_chunk) + len(paragraph) < max_chunk_size:
+            current_chunk += paragraph + "\n\n"
+        else:
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+            current_chunk = paragraph + "\n\n"
+    
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+    
+    return chunks
+
+def build_phi3_chunk_prompt(chunk, student_level, specific_help, chunk_num, total_chunks):
+    """Build Phi-3 specific prompt for a single chunk - STRICTER VERSION"""
+    prompt = f"""TASK: Write the actual simplified explanation for this content section.
+
+CONTENT SECTION {chunk_num}/{total_chunks}:
+{chunk}
+
+STUDENT: {student_level}
+"""
+    if specific_help:
+        prompt += f"\nSTUDENT'S REQUEST: {specific_help}"
+    
+    prompt += f"""
+
+DIRECTIVES:
+- WRITE THE ACTUAL EXPLANATION ONLY
+- Use simple, clear language for {student_level}
+- Break complex ideas into basic concepts
+- Use everyday examples and analogies
+- Define technical terms in simple words
+- Structure with clear headings
+
+STRICT PROHIBITIONS:
+- NO instructional language (no "I will explain", "This section describes")
+- NO meta-commentary about the explanation
+- NO learning objectives or activities
+- NO phrases like "students will understand"
+- NO references to yourself as AI/assistant
+
+BEGIN EXPLANATION NOW:
+
+"""
+    return prompt
+
+def build_groq_chunk_prompt(chunk, student_level, specific_help, chunk_num, total_chunks):
+    """Build Groq prompt for a single chunk"""
+    prompt = f"""Simplify this content for {student_level} students:
+
+CONTENT SECTION {chunk_num}/{total_chunks}:
+{chunk}
+
+STUDENT LEVEL: {student_level}
+"""
+    if specific_help:
+        prompt += f"\nSPECIFIC CONFUSION: {specific_help}"
+    
+    prompt += f"""
+
+Create a clear, simplified explanation of this content.
+"""
+    return prompt
+
+def combine_chunk_outputs(outputs, student_level):
+    """Combine chunk outputs into a cohesive document"""
+    combined = f"# Simplified Content for {student_level} Level\n\n"
+    
+    for i, output in enumerate(outputs):
+        # Clean up any remaining instructional language
+        clean_output = clean_phi3_output(output)
+        combined += f"## Part {i+1}\n\n{clean_output.strip()}\n\n---\n\n"
+    
+    return combined
+
+def build_phi3_student_prompt(content_text, student_level, specific_help):
+    """Build Phi-3 specific prompt for student content generation - STRICTER VERSION"""
+    prompt = f"""TASK: Write the actual simplified explanation for this content.
+
+ORIGINAL CONTENT:
+{content_text}
+
+STUDENT: {student_level}
+"""
+    if specific_help:
+        prompt += f"\nSTUDENT'S SPECIFIC REQUEST: {specific_help}"
+    
+    prompt += f"""
+
+DIRECTIVES:
+- WRITE THE ACTUAL EXPLANATION ONLY
+- Use simple, clear language appropriate for {student_level}
+- Break down complex concepts into basic building blocks
+- Use everyday analogies and concrete examples
+- Define all technical terms when first used
+- Structure logically with clear headings
+- Make it engaging and conversational
+
+STRICT PROHIBITIONS:
+- NO instructional language (no "I will explain", "Let me break this down")
+- NO meta-commentary about the explanation process
+- NO learning objectives, activities, or assessments
+- NO phrases like "students will learn" or "this explains"
+- NO lesson plans or educational frameworks
+- NO references to yourself as AI, assistant, or teacher
+
+BEGIN SIMPLIFIED EXPLANATION NOW:
+
+"""
+    return prompt
+
+def build_groq_student_prompt(content_text, student_level, specific_help):
+    """Build Groq prompt for student content generation"""
+    prompt = f"""Create a simplified explanation of this content for {student_level} students:
+
+CONTENT TO SIMPLIFY:
+{content_text}
+
+STUDENT LEVEL: {student_level}
+"""
+    if specific_help:
+        prompt += f"\nSPECIFIC CONFUSION: {specific_help}"
+    
+    prompt += f"""
+
+Provide a clear, easy-to-understand explanation that:
+- Breaks down complex concepts into simple terms
+- Uses analogies and examples appropriate for {student_level}
+- Defines technical terminology clearly
+- Structures the content for easy learning
+- Focuses on the most important concepts
+
+Make the explanation engaging and accessible.
+"""
+    return prompt
+
+def clean_phi3_output(output):
+    """Clean Phi-3 output to remove instructional language and meta-commentary"""
+    # Remove common instructional phrases
+    patterns_to_remove = [
+        r'Here is.*?explanation:',
+        r'I will.*?now:',
+        r'Let me.*?concept:',
+        r'This section.*?content:',
+        r'Below is.*?explanation:',
+        r'Here\'s.*?breakdown:',
+        r'In this.*?we will',
+        r'Students will.*?understand',
+        r'We can.*?explain',
+        r'The following.*?explains',
+        r'This content.*?describes',
+        r'As an AI.*?assistant',
+    ]
+    
+    cleaned = output
+    for pattern in patterns_to_remove:
+        cleaned = re.sub(pattern, '', cleaned, flags=re.IGNORECASE)
+    
+    # Remove any empty lines at the start
+    cleaned = re.sub(r'^\s*\n+', '', cleaned)
+    
+    return cleaned.strip()

components/tutor_flow.py

@@ -0,0 +1,804 @@
+import streamlit as st
+import re
+from generator import model_manager
+from components.export_handler import generate_pdf
+from components.session_manager import update_session_state
+from components.file_processor import process_uploaded_file  # ADD THIS IMPORT
+
+def render_tutor_flow():
+    """Render the tutor content generation flow"""
+    st.header("👨‍🏫 Tutor Content Creator")
+    render_tutor_info()
+    
+    # Check if we need to regenerate with a different model
+    if st.session_state.get("regenerate_with_new_model") and st.session_state.get("original_topic"):
+        handle_tutor_regeneration()
+        return
+    
+    # GET INPUT METHOD FIRST
+    input_method = get_tutor_input_method()
+    
+    if input_method == "Upload Document":
+        topic, objectives, student_level, content_type, additional_req, document_text, filename = get_tutor_inputs_from_document()
+        if topic and document_text and st.button("🚀 Generate from Document", type="primary", key="generate_from_document"):
+            generate_tutor_content_from_document(topic, objectives, student_level, content_type, additional_req, document_text, filename)
+    else:
+        topic, objectives, student_level, content_type, additional_req = get_tutor_inputs_manual()
+        if topic and objectives and st.button("🚀 Create Teaching Content", type="primary", key="generate_tutor_content"):
+            generate_tutor_content(topic, objectives, student_level, content_type, additional_req)
+
+def get_tutor_input_method():
+    """Let tutor choose between manual input or document upload"""
+    st.subheader("📥 Input Method")
+    return st.radio(
+        "How would you like to provide the content?",
+        ["Describe Topic & Objectives", "Upload Document"],
+        help="Choose to either describe what you need or upload existing materials to transform"
+    )
+
+def get_tutor_inputs_from_document():
+    """Get inputs from tutor when uploading a document"""
+    st.subheader("📄 Upload Your Document")
+    
+    uploaded_file = st.file_uploader(
+        "Upload your educational document", 
+        type=["pdf", "pptx", "docx", "txt"],
+        help="Upload lesson plans, curriculum materials, textbook chapters, or any educational content"
+    )
+    
+    document_text = ""
+    filename = "content.pdf"
+    
+    if uploaded_file:
+        with st.spinner("📖 Reading your document..."):
+            document_text, error = process_uploaded_file(uploaded_file)
+        if error:
+            st.error(f"❌ {error}")
+        else:
+            st.success("✅ Document processed successfully!")
+            filename = uploaded_file.name
+            
+            # Show document preview
+            with st.expander("📋 Document Preview", expanded=False):
+                st.text_area("Extracted Text", document_text[:1000] + "..." if len(document_text) > 1000 else document_text, height=200, key="doc_preview")
+    
+    st.subheader("🎯 Transformation Instructions")
+    
+    topic = st.text_input(
+        "What topic is this document about?",
+        placeholder="e.g., Neural Networks, French Revolution, Calculus Basics",
+        help="Briefly describe the main topic of the document"
+    )
+    
+    content_type = st.selectbox(
+        "What would you like me to create from this document?",
+        ["Lecture Notes", "Study Guide", "Interactive Activity", "Lesson Plan", "Comprehensive Explanation", "Assessment Questions"],
+        help="Choose the format you want me to generate based on your document"
+    )
+    
+    student_level = st.selectbox(
+        "What level should the content be adapted for?",
+        ["Elementary School", "Middle School", "High School", "Undergraduate", "Graduate", "Professional Development"],
+        help="Select the target student level for the generated content"
+    )
+    
+    additional_req = st.text_area(
+        "Any specific transformation requirements?",
+        placeholder="e.g., 'Make it more interactive', 'Simplify the language', 'Add real-world examples', 'Focus on key concepts'",
+        help="Specify how you want the content transformed"
+    )
+    
+    # For document-based generation, objectives are optional since they can be extracted
+    objectives = st.text_area(
+        "Learning Objectives (Optional)",
+        placeholder="e.g., 'Students should understand X, apply Y, analyze Z'",
+        help="Optional: Specify what students should learn. If empty, I'll infer from the document."
+    )
+    
+    return topic, objectives, student_level, content_type, additional_req, document_text, filename
+
+def get_tutor_inputs_manual():
+    """Get all inputs from tutor (original manual method)"""
+    st.subheader("📖 Teaching Topic")
+    topic = st.text_area(
+        "What topic do you want to teach?",
+        placeholder="e.g., Neural Networks, Quantum Computing, Calculus Fundamentals, French Revolution",
+        help="Be specific about the topic or concept",
+        key="tutor_topic_input"
+    )
+    
+    st.subheader("🎯 Learning Objectives")
+    objectives = st.text_area(
+        "What should students learn from this?",
+        placeholder="e.g., 'Understand backpropagation', 'Apply gradient descent', 'Explain the causes of WWI'",
+        help="List the key learning outcomes for students",
+        key="tutor_objectives_input"
+    )
+    
+    st.subheader("👥 Student Level")
+    student_level = st.selectbox(
+        "What level are your students?",
+        ["Elementary School", "Middle School", "High School", "Undergraduate", "Graduate", "Professional Development"],
+        help="Select the appropriate level for your students",
+        key="tutor_student_level"
+    )
+    
+    st.subheader("📝 Content Format")
+    content_type = st.selectbox(
+        "What type of content do you need?",
+        ["Lesson Plan", "Study Guide", "Lecture Notes", "Interactive Activity", "Comprehensive Explanation"],
+        help="Choose the format that best suits your teaching needs",
+        key="tutor_content_type_select"
+    )
+    
+    st.subheader("⚡ Additional Requirements (Optional)")
+    additional_req = st.text_area(
+        "Any specific requirements?",
+        placeholder="e.g., 'Include code examples', 'Use historical primary sources', 'Focus on practical applications'",
+        help="Specify any particular focus or requirements",
+        key="tutor_additional_req"
+    )
+    
+    return topic, objectives, student_level, content_type, additional_req
+
+def generate_tutor_content_from_document(topic, objectives, student_level, content_type, additional_req, document_text, filename):
+    """Generate content for tutor based on uploaded document"""
+    # STORE ORIGINAL INPUTS FOR REGENERATION
+    st.session_state.original_topic = topic
+    st.session_state.original_objectives = objectives
+    st.session_state.original_additional_req = additional_req
+    st.session_state.original_document_text = document_text
+    st.session_state.original_filename = filename
+    
+    with st.spinner("📝 Transforming your document into new content..."):
+        selected_model = st.session_state.get("selected_model", "groq")
+        
+        # Build document-based prompt
+        if selected_model == "phi3":
+            prompt = build_phi3_document_prompt(topic, objectives, student_level, content_type, additional_req, document_text)
+        else:
+            prompt = build_groq_document_prompt(topic, objectives, student_level, content_type, additional_req, document_text)
+        
+        try:
+            output = model_manager.generate(
+                prompt,
+                selected_model,
+                user_type="tutor", 
+                student_level=student_level, 
+                content_type=content_type
+            )
+            
+            # Check if it's an error message
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(output)
+                return
+            
+            # Generate PDF
+            pdf_data = generate_pdf(
+                output, 
+                "tutor", 
+                level=student_level,
+                topic=topic,
+                content_type=f"{content_type} from Document",
+                objectives=objectives or "Derived from uploaded document"
+            )
+            
+            # Update session state
+            update_session_state(
+                original_prompt=prompt,
+                generated_output=output,
+                feedback_given=False,
+                regenerated=False,
+                content_source="tutor_document",
+                student_level=student_level,
+                tutor_topic=topic,
+                tutor_content_type=content_type,
+                pdf_export_data=pdf_data,
+                saved_to_history=False,
+                current_history_id=None,
+                generated_model=selected_model
+            )
+            
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"❌ Generation failed: {str(e)}")
+
+def build_phi3_document_prompt(topic, objectives, student_level, content_type, additional_req, document_text):
+    """Build Phi-3 prompt for document-based content generation"""
+    
+    content_descriptions = {
+        "Lecture Notes": "detailed lecture notes suitable for classroom teaching",
+        "Study Guide": "comprehensive study guide for student self-study",
+        "Interactive Activity": "engaging interactive learning activities for students",
+        "Lesson Plan": "structured lesson plan with timing and activities", 
+        "Comprehensive Explanation": "thorough explanatory document",
+        "Assessment Questions": "quiz questions, exercises, or assessment materials"
+    }
+    
+    description = content_descriptions.get(content_type, "educational content")
+    
+    prompt = f"""Transform the provided educational document into {description}.
+
+ORIGINAL DOCUMENT CONTENT:
+{document_text}
+
+TOPIC: {topic}
+"""
+    if objectives:
+        prompt += f"\nLEARNING OBJECTIVES: {objectives}"
+    
+    prompt += f"""
+TARGET AUDIENCE: {student_level} students
+OUTPUT FORMAT: {content_type}
+"""
+    if additional_req:
+        prompt += f"\nSPECIFIC REQUIREMENTS: {additional_req}"
+    
+    prompt += f"""
+
+TRANSFORMATION INSTRUCTIONS:
+- Create {content_type.lower()} based on the original document content
+- Adapt the material for {student_level} students
+- Maintain the core educational concepts but reformat for the new purpose
+- Use appropriate language and examples for the target level
+- Structure the content effectively for {content_type.lower()}
+
+FORBIDDEN:
+- Do not simply copy the original content
+- Do not use phrases like "based on the document" or "the original content says"
+- Do not refer to yourself as an AI or assistant
+- Do not include meta-commentary about the transformation process
+
+BEGIN {content_type.upper()}:
+
+"""
+    return prompt
+
+def build_groq_document_prompt(topic, objectives, student_level, content_type, additional_req, document_text):
+    """Build Groq prompt for document-based content generation"""
+    
+    prompt = f"""Create {content_type.lower()} based on the following document:
+
+DOCUMENT CONTENT:
+{document_text}
+
+TOPIC: {topic}
+"""
+    if objectives:
+        prompt += f"\nLEARNING OBJECTIVES: {objectives}"
+    
+    prompt += f"""
+STUDENT LEVEL: {student_level}
+CONTENT TYPE: {content_type}
+"""
+    if additional_req:
+        prompt += f"\nADDITIONAL REQUIREMENTS: {additional_req}"
+    
+    prompt += f"""
+
+Transform the document content into effective {content_type.lower()} suitable for {student_level} students.
+"""
+    return prompt
+
+def handle_tutor_regeneration():
+    """Handle tutor content regeneration with new model"""
+    st.header("👨‍🏫 Tutor Content Creator")
+    render_tutor_info()
+    
+    # Show we're regenerating
+    st.info("🔄 Regenerating your content with the new model...")
+    
+    # Check if this was document-based content
+    if st.session_state.get("content_source") == "tutor_document" and st.session_state.get("original_document_text"):
+        # Document-based regeneration
+        topic = st.session_state.original_topic
+        objectives = st.session_state.original_objectives  
+        student_level = st.session_state.student_level
+        content_type = st.session_state.tutor_content_type
+        additional_req = st.session_state.get("original_additional_req", "")
+        document_text = st.session_state.original_document_text
+        filename = st.session_state.get("original_filename", "content.pdf")
+        
+        # Show original inputs for context
+        with st.expander("📋 Original Inputs (Read-only)", expanded=True):
+            st.write(f"**Source Document:** {filename}")
+            st.write(f"**Topic:** {topic}")
+            st.write(f"**Student Level:** {student_level}")
+            st.write(f"**Content Type:** {content_type}")
+            if objectives:
+                st.write(f"**Learning Objectives:** {objectives}")
+            if additional_req:
+                st.write(f"**Transformation Requirements:** {additional_req}")
+        
+        # Regenerate from document
+        generate_tutor_content_from_document(topic, objectives, student_level, content_type, additional_req, document_text, filename)
+    else:
+        # Manual input regeneration (existing code)
+        topic = st.session_state.original_topic
+        objectives = st.session_state.original_objectives
+        student_level = st.session_state.student_level
+        content_type = st.session_state.tutor_content_type
+        additional_req = st.session_state.get("original_additional_req", "")
+        
+        # Show original inputs for context
+        with st.expander("📋 Original Inputs (Read-only)", expanded=True):
+            st.write(f"**Topic:** {topic}")
+            st.write(f"**Student Level:** {student_level}")
+            st.write(f"**Content Type:** {content_type}")
+            st.write(f"**Learning Objectives:** {objectives}")
+            if additional_req:
+                st.write(f"**Additional Requirements:** {additional_req}")
+        
+        # Regenerate the content
+        generate_tutor_content(topic, objectives, student_level, content_type, additional_req)
+
+def render_tutor_info():
+    """Render tutor flow information"""
+    st.info("""
+    **How this works:** 
+    - **Describe Topic & Objectives**: Tell me what you want to teach, and I'll generate educational content from scratch
+    - **Upload Document**: Upload existing materials (lesson plans, textbooks, etc.) and I'll transform them into new formats like lecture notes, study guides, or interactive activities
+    
+    **Perfect for**: Converting lesson plans to lecture notes, textbook chapters to study guides, curriculum materials to interactive activities
+    """)
+
+def generate_tutor_content(topic, objectives, student_level, content_type, additional_req):
+    """Generate content for tutor with optimized content handling"""
+    # STORE ORIGINAL INPUTS FOR REGENERATION
+    st.session_state.original_topic = topic
+    st.session_state.original_objectives = objectives
+    st.session_state.original_additional_req = additional_req
+    
+    total_content_size = len(topic) + len(objectives) + len(additional_req)
+    
+    if total_content_size > 15000:
+        st.info("📝 Creating comprehensive content with detailed sections...")
+        generate_chunked_tutor_content(topic, objectives, student_level, content_type, additional_req)
+    elif total_content_size > 8000:
+        st.info("📝 Processing your comprehensive teaching content...")
+        generate_single_large_tutor_content(topic, objectives, student_level, content_type, additional_req)
+    else:
+        generate_single_tutor_content(topic, objectives, student_level, content_type, additional_req)
+
+def generate_single_tutor_content(topic, objectives, student_level, content_type, additional_req):
+    """Generate content for normal-sized tutor requests"""
+    with st.spinner("✍️ Generating educational content..."):
+        selected_model = st.session_state.get("selected_model", "groq")
+        
+        # Use Phi-3 specific prompts if Phi-3 is selected
+        if selected_model == "phi3":
+            prompt = build_phi3_tutor_prompt(topic, objectives, student_level, content_type, additional_req)
+        else:
+            prompt = build_groq_tutor_prompt(topic, objectives, student_level, content_type, additional_req)
+        
+        try:
+            output = model_manager.generate(
+                prompt,
+                selected_model,
+                user_type="tutor", 
+                student_level=student_level, 
+                content_type=content_type
+            )
+            
+            # Check if it's an error message
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(output)
+                return
+            
+            # Generate PDF
+            pdf_data = generate_pdf(
+                output, 
+                "tutor", 
+                level=student_level,
+                topic=topic,
+                content_type=content_type,
+                objectives=objectives
+            )
+            
+            # Update session state
+            update_session_state(
+                original_prompt=prompt,
+                generated_output=output,
+                feedback_given=False,
+                regenerated=False,
+                content_source="tutor",
+                student_level=student_level,
+                tutor_topic=topic,
+                tutor_content_type=content_type,
+                pdf_export_data=pdf_data,
+                saved_to_history=False,
+                current_history_id=None,
+                generated_model=selected_model
+            )
+            
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"❌ Generation failed: {str(e)}")
+
+def generate_single_large_tutor_content(topic, objectives, student_level, content_type, additional_req):
+    """Generate content for large tutor requests using high-capacity models"""
+    with st.spinner("✍️ Generating comprehensive educational content..."):
+        selected_model = st.session_state.get("selected_model", "groq")
+        
+        # Use Phi-3 specific prompts if Phi-3 is selected
+        if selected_model == "phi3":
+            prompt = build_phi3_tutor_prompt(topic, objectives, student_level, content_type, additional_req)
+        else:
+            prompt = build_groq_tutor_prompt(topic, objectives, student_level, content_type, additional_req)
+        
+        try:
+            if selected_model == "phi3":
+                output = model_manager.generate(
+                    prompt,
+                    selected_model,
+                    user_type="tutor",
+                    student_level=student_level,
+                    content_type=content_type
+                )
+            else:
+                output = model_manager.groq_generator.generate_large_content(prompt)
+            
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(output)
+                return
+            
+            # Generate PDF
+            pdf_data = generate_pdf(
+                output, 
+                "tutor", 
+                level=student_level,
+                topic=topic,
+                content_type=content_type,
+                objectives=objectives
+            )
+            
+            # Update session state
+            update_session_state(
+                original_prompt=prompt,
+                generated_output=output,
+                feedback_given=False,
+                regenerated=False,
+                content_source="tutor",
+                student_level=student_level,
+                tutor_topic=topic,
+                tutor_content_type=content_type,
+                pdf_export_data=pdf_data,
+                saved_to_history=False,
+                current_history_id=None,
+                generated_model=selected_model
+            )
+            
+            st.rerun()
+            
+        except Exception as e:
+            st.error(f"❌ Generation failed: {str(e)}")
+
+def generate_chunked_tutor_content(topic, objectives, student_level, content_type, additional_req):
+    """Generate comprehensive tutor content by breaking down objectives"""
+    objective_chunks = chunk_objectives(objectives, max_chunk_size=4000)
+    
+    if not objective_chunks:
+        generate_single_large_tutor_content(topic, objectives, student_level, content_type, additional_req)
+        return
+    
+    all_outputs = []
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    selected_model = st.session_state.get("selected_model", "groq")
+    
+    for i, objective_chunk in enumerate(objective_chunks):
+        status_text.text(f"📖 Creating content for learning objective {i+1}/{len(objective_chunks)}...")
+        progress_bar.progress((i) / len(objective_chunks))
+        
+        # Use Phi-3 specific prompts if Phi-3 is selected
+        if selected_model == "phi3":
+            prompt = build_phi3_tutor_chunk_prompt(topic, objective_chunk, student_level, content_type, additional_req, i+1, len(objective_chunks))
+        else:
+            prompt = build_groq_tutor_chunk_prompt(topic, objective_chunk, student_level, content_type, additional_req, i+1, len(objective_chunks))
+        
+        try:
+            output = model_manager.generate(
+                prompt,
+                selected_model,
+                user_type="tutor",
+                student_level=student_level,
+                content_type=content_type
+            )
+            
+            if any(msg in output for msg in ["🚫", "📊", "❌", "[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "❌ Phi-3 Error:"]):
+                st.error(f"❌ Failed to process objective {i+1}: {output}")
+                return
+            
+            all_outputs.append(output)
+            
+        except Exception as e:
+            st.error(f"❌ Failed to process objective {i+1}: {str(e)}")
+            return
+    
+    # Update progress to complete
+    progress_bar.progress(1.0)
+    status_text.text("✅ All sections processed! Combining results...")
+    
+    # Combine all outputs
+    final_output = combine_tutor_outputs(all_outputs, topic, student_level, content_type)
+    
+    # Generate PDF and update session state
+    pdf_data = generate_pdf(
+        final_output, 
+        "tutor", 
+        level=student_level,
+        topic=topic,
+        content_type=content_type,
+        objectives=objectives
+    )
+    
+    update_session_state(
+        original_prompt=f"{content_type} for {topic} - {student_level} level",
+        generated_output=final_output,
+        feedback_given=False,
+        regenerated=False,
+        content_source="tutor",
+        student_level=student_level,
+        tutor_topic=topic,
+        tutor_content_type=content_type,
+        pdf_export_data=pdf_data,
+        saved_to_history=False,
+        current_history_id=None,
+        generated_model=selected_model
+    )
+    
+    status_text.text("✅ Content generation complete!")
+    st.rerun()
+
+def chunk_objectives(objectives, max_chunk_size=4000):
+    """Split objectives into manageable chunks with increased size"""
+    objective_items = re.split(r'[\n•\-]', objectives)
+    objective_items = [item.strip() for item in objective_items if item.strip()]
+    
+    chunks = []
+    current_chunk = ""
+    
+    for item in objective_items:
+        if len(current_chunk) + len(item) < max_chunk_size:
+            if current_chunk:
+                current_chunk += "\n• " + item
+            else:
+                current_chunk = "• " + item
+        else:
+            if current_chunk:
+                chunks.append(current_chunk)
+            current_chunk = "• " + item
+    
+    if current_chunk:
+        chunks.append(current_chunk)
+    
+    if len(chunks) > 5 and max_chunk_size < 6000:
+        return chunk_objectives(objectives, max_chunk_size + 1000)
+    
+    return chunks
+
+def build_phi3_tutor_chunk_prompt(topic, objective_chunk, student_level, content_type, additional_req, chunk_num, total_chunks):
+    """Build Phi-3 specific prompt for a single tutor chunk"""
+    prompt = f"""You are creating educational content. Write the actual content that teaches these concepts.
+
+TOPIC: {topic}
+
+CONCEPTS TO EXPLAIN:
+{objective_chunk}
+
+AUDIENCE: {student_level} students
+FORMAT: {content_type}
+"""
+    if additional_req:
+        prompt += f"\nSPECIFIC FOCUS: {additional_req}"
+    
+    prompt += f"""
+
+CONTENT REQUIREMENTS:
+- Write the actual educational material, not a lesson plan
+- Explain concepts clearly with examples
+- Use appropriate language for {student_level}
+- Include definitions and key information
+- Structure the content for learning
+
+FORBIDDEN: Do not include timing, activities, assessments, or teaching instructions.
+FORBIDDEN: Do not use phrases like "students will learn" or "this section will cover".
+
+BEGIN CONTENT:
+
+"""
+    return prompt
+
+def build_groq_tutor_chunk_prompt(topic, objective_chunk, student_level, content_type, additional_req, chunk_num, total_chunks):
+    """Build Groq prompt for a single tutor chunk"""
+    prompt = f"""Create educational content for the following:
+
+TOPIC: {topic}
+
+LEARNING OBJECTIVES:
+{objective_chunk}
+
+STUDENT LEVEL: {student_level}
+CONTENT TYPE: {content_type}
+"""
+    if additional_req:
+        prompt += f"\nADDITIONAL REQUIREMENTS: {additional_req}"
+    
+    prompt += f"""
+
+Generate comprehensive educational content that directly teaches these concepts.
+"""
+    return prompt
+
+def combine_tutor_outputs(outputs, topic, student_level, content_type):
+    """Combine tutor chunk outputs into a cohesive document"""
+    combined = f"# {content_type}: {topic}\n\n"
+    combined += f"**Target Level:** {student_level}\n\n"
+    
+    for i, output in enumerate(outputs):
+        # Clean up any instructional language
+        clean_output = re.sub(r'(?:Here is|I will|This section|Students will|We will).*?(?=\n\n|\n#|\n##|$)', '', output, flags=re.IGNORECASE | re.DOTALL)
+        section_title = f"## Part {i+1}\n\n"
+        combined += section_title + clean_output.strip() + "\n\n---\n\n"
+    
+    return combined
+
+def build_phi3_tutor_prompt(topic, objectives, student_level, content_type, additional_req):
+    """Build Phi-3 specific prompt for tutor content generation"""
+    
+    # Define content type requirements
+    content_requirements = {
+        "Lesson Plan": {
+            "description": "Create a structured lesson plan with timing, activities, and assessments",
+            "requirements": [
+                "Include learning objectives and outcomes",
+                "Provide a timed lesson structure with activities",
+                "Include teaching methods and student activities", 
+                "Add assessment methods and homework if applicable",
+                "Use appropriate pedagogical approaches"
+            ],
+            "forbidden": []
+        },
+        "Study Guide": {
+            "description": "Create a comprehensive study guide for students",
+            "requirements": [
+                "Include key concepts and definitions",
+                "Provide summaries and review questions",
+                "Add practice problems or exercises",
+                "Include study tips and strategies",
+                "Structure for easy review and self-testing"
+            ],
+            "forbidden": [
+                "Do not include timing or classroom management instructions"
+            ]
+        },
+        "Lecture Notes": {
+            "description": "Create detailed lecture notes for teaching",
+            "requirements": [
+                "Include comprehensive explanations",
+                "Provide examples and case studies", 
+                "Add key points and summaries",
+                "Include relevant diagrams or frameworks if needed",
+                "Structure for clear presentation delivery"
+            ],
+            "forbidden": [
+                "Do not include student activities or assessments"
+            ]
+        },
+        "Interactive Activity": {
+            "description": "Create engaging interactive learning activities",
+            "requirements": [
+                "Design hands-on or group activities",
+                "Include clear instructions for students",
+                "Provide learning objectives for each activity",
+                "Add discussion questions or prompts",
+                "Include facilitation guidelines if needed"
+            ],
+            "forbidden": [
+                "Do not include lengthy theoretical explanations"
+            ]
+        },
+        "Comprehensive Explanation": {
+            "description": "Create a thorough explanatory document",
+            "requirements": [
+                "Provide in-depth conceptual explanations",
+                "Use analogies and real-world examples",
+                "Include step-by-step breakdowns of complex ideas",
+                "Add visual descriptions or mental models",
+                "Structure from basic to advanced concepts"
+            ],
+            "forbidden": [
+                "Do not include activities, assessments, or teaching instructions"
+            ]
+        }
+    }
+    
+    # Get requirements for the specific content type
+    content_spec = content_requirements.get(content_type, content_requirements["Comprehensive Explanation"])
+    
+    prompt = f"""You are creating educational content for {content_type.lower()}. Write the actual content.
+
+TOPIC: {topic}
+
+LEARNING GOALS:
+{objectives}
+
+AUDIENCE: {student_level} students
+CONTENT TYPE: {content_type} - {content_spec['description']}
+"""
+    if additional_req:
+        prompt += f"\nSPECIFIC FOCUS: {additional_req}"
+    
+    prompt += f"""
+
+CONTENT REQUIREMENTS:
+- Write the actual educational material
+- Explain concepts clearly with examples appropriate for {student_level}
+- Use appropriate language and terminology for the audience
+- Structure the content logically for learning
+"""
+    
+    # Add content-specific requirements
+    for requirement in content_spec['requirements']:
+        prompt += f"- {requirement}\n"
+    
+    # Add content-specific forbidden items
+    if content_spec['forbidden']:
+        prompt += "\nFORBIDDEN:\n"
+        for forbidden in content_spec['forbidden']:
+            prompt += f"- {forbidden}\n"
+    else:
+        # Default forbidden items for content types that need more flexibility
+        prompt += "\nFORBIDDEN:\n- Do not use generic phrases like 'this section will cover'\n- Do not create content that is not directly educational\n"
+    
+    # Add universal forbidden items that apply to all content types
+    universal_forbidden = [
+        "Do not use phrases like 'students will learn' or 'this teaches'",
+        "Do not refer to yourself as an AI or assistant",
+        "Do not add meta-commentary about the content"
+    ]
+    
+    for forbidden in universal_forbidden:
+        prompt += f"- {forbidden}\n"
+    
+    prompt += f"""
+
+BEGIN {content_type.upper()} CONTENT:
+
+"""
+    return prompt
+
+def build_groq_tutor_prompt(topic, objectives, student_level, content_type, additional_req):
+    """Build Groq prompt for tutor content generation"""
+    
+    content_descriptions = {
+        "Lesson Plan": "structured lesson plan with timing, activities, and assessments",
+        "Study Guide": "comprehensive study guide with key concepts and practice questions", 
+        "Lecture Notes": "detailed lecture notes for teaching delivery",
+        "Interactive Activity": "engaging interactive learning activities",
+        "Comprehensive Explanation": "thorough explanatory document"
+    }
+    
+    description = content_descriptions.get(content_type, "educational content")
+    
+    prompt = f"""Create {description} for teaching:
+
+TOPIC: {topic}
+
+LEARNING OBJECTIVES:
+{objectives}
+
+STUDENT LEVEL: {student_level}
+CONTENT TYPE: {content_type}
+"""
+    if additional_req:
+        prompt += f"\nADDITIONAL REQUIREMENTS: {additional_req}"
+    
+    prompt += f"""
+
+Generate detailed {content_type.lower()} that achieves the learning objectives.
+"""
+    return prompt

components/ui_components.py

@@ -0,0 +1,313 @@
+import streamlit as st
+from db.helpers import get_research_stats
+from generator import model_manager
+from export_training_data_from_db import export_training_data_from_db
+
+def render_header():
+    st.title("🧠 TailorED - AI-Powered Educational Content Generator")
+
+def render_sidebar():
+    with st.sidebar:
+        # === RESEARCH MODEL SELECTION ===
+        st.subheader("🔬 Research Model Selection")
+        
+        # Initialize model choice if not exists
+        if "selected_model" not in st.session_state:
+            st.session_state.selected_model = "groq"
+        
+        # Check if we have existing content and need to show regeneration prompt
+        if (st.session_state.get("generated_output") and 
+            st.session_state.get("current_page") == "generator" and
+            not st.session_state.get("showing_regeneration_prompt", False)):
+            
+            # Store current model before potential change
+            previous_model = st.session_state.selected_model
+            
+            # Model selection with regeneration logic
+            model_choice = st.radio(
+                "Select AI Model:",
+                options=[
+                    "🧪 Phi-3 (Research Model)", 
+                    "📊 Groq (Training Data)"
+                ],
+                index=0 if st.session_state.selected_model == "phi3" else 1,
+                key="research_model_selection"
+            )
+            
+            # Determine new model selection
+            new_model = "phi3" if model_choice == "🧪 Phi-3 (Research Model)" else "groq"
+            
+            # If model changed and we have content, show regeneration prompt
+            if new_model != previous_model:
+                st.session_state.pending_model_switch = new_model
+                st.session_state.previous_model = previous_model
+                st.session_state.showing_regeneration_prompt = True
+                st.rerun()
+                
+        else:
+            # Normal model selection (no content or prompt already shown)
+            model_choice = st.radio(
+                "Select AI Model:",
+                options=[
+                    "🧪 Phi-3 (Research Model)", 
+                    "📊 Groq (Training Data)"
+                ],
+                index=0 if st.session_state.selected_model == "phi3" else 1,
+                key="research_model_selection"
+            )
+            
+            # Update model selection
+            new_model = "phi3" if model_choice == "🧪 Phi-3 (Research Model)" else "groq"
+            if new_model != st.session_state.selected_model:
+                st.session_state.selected_model = new_model
+                if not st.session_state.get("generated_output"):
+                    st.success(f"✅ Switched to {new_model.upper()} model")
+        
+        # Show current model status
+        current_model = st.session_state.selected_model
+        if current_model == "phi3":
+            st.info("🧪 **Testing Phi-3** - Research model being evaluated")
+        else:
+            st.success("📊 **Generating Training Data** - Groq outputs will train Phi-3")
+        
+        # Render regeneration prompt if needed
+        if st.session_state.get("showing_regeneration_prompt", False):
+            render_regeneration_prompt()
+        
+        # Research context
+        st.markdown("---")
+        st.markdown("### 🎯 Research Mission")
+        st.markdown("""
+        We're **fine-tuning Phi-3 Mini** using Groq's high-quality outputs.
+        
+        **Your Role:** Compare both models to help improve Phi-3!
+        - Use **Groq** to create training examples
+        - Use **Phi-3** to test research progress  
+        - Switch models to compare outputs on the same content
+        """)
+        
+        st.markdown("---")
+        
+        st.header("🎓 Research Progress")
+        st.write("**Your feedback trains better educational AI**")
+
+        try:
+            stats = get_research_stats()
+            render_progress_metrics(stats)
+            render_quality_indicators(stats)
+            render_research_status(stats)
+            render_service_status()
+        except Exception as e:
+            st.error(f"Sidebar failed: {e}")
+            render_default_sidebar()
+
+def render_regeneration_prompt():
+    """Show prompt to regenerate content with new model"""
+    st.markdown("---")
+    st.warning("🔄 **Model Changed!**")
+    
+    previous_model = st.session_state.previous_model
+    new_model = st.session_state.pending_model_switch
+    
+    st.write(f"You switched from **{previous_model.upper()}** to **{new_model.upper()}**.")
+    st.write("Would you like to regenerate the same content with the new model?")
+    
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    with col1:
+        if st.button("✅ Yes, Regenerate", use_container_width=True, key="confirm_regenerate"):
+            # Trigger regeneration with new model
+            st.session_state.selected_model = new_model
+            st.session_state.regenerate_with_new_model = True
+            st.session_state.showing_regeneration_prompt = False
+            st.session_state.pending_model_switch = None
+            st.session_state.previous_model = None
+            st.rerun()
+    
+    with col2:
+        if st.button("❌ No, Keep Current", use_container_width=True, key="keep_current"):
+            # Revert to previous model and keep current content
+            st.session_state.selected_model = st.session_state.previous_model
+            st.session_state.showing_regeneration_prompt = False
+            st.session_state.pending_model_switch = None
+            st.session_state.previous_model = None
+            st.rerun()
+    
+    with col3:
+        if st.button("🏠 Go to Home", use_container_width=True, key="go_home"):
+            # Clear content and go to home
+            from components.session_manager import clear_session
+            clear_session()
+            st.session_state.showing_regeneration_prompt = False
+            st.session_state.pending_model_switch = None
+            st.session_state.previous_model = None
+            st.rerun()
+
+def render_progress_metrics(stats):
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric("Total Feedback", stats.get("total_feedback", 0))
+    
+    with col2:
+        st.metric("Content Generated", stats.get("total_content", 0))
+
+    if stats.get("total_feedback", 0) > 0:
+        render_progress_bar(stats)
+
+def render_progress_bar(stats):
+    """Render progress bar towards research goal"""
+    st.subheader("📈 Our Progress")
+    target_feedback = 100
+    total_feedback = stats.get("total_feedback", 0)
+    progress_percent = min((total_feedback / target_feedback) * 100, 100)
+    st.progress(progress_percent / 100)
+    st.caption(f"Goal: 100 feedback points • {total_feedback}/100")
+    
+    if total_feedback >= target_feedback:
+        st.balloons()
+        st.success("🎉 Amazing! We've reached our research goal!")
+
+def render_quality_indicators(stats):
+    st.subheader("✨ Model Quality Comparison")
+    
+    # Safely get model scores with fallbacks
+    groq_scores = stats.get("groq_scores", {})
+    phi3_scores = stats.get("phi3_scores", {})
+    
+    groq_clarity = groq_scores.get("clarity", 0)
+    groq_depth = groq_scores.get("depth", 0)
+    phi3_clarity = phi3_scores.get("clarity", 0)
+    phi3_depth = phi3_scores.get("depth", 0)
+    
+    # Groq metrics
+    st.markdown("**📊 Groq (Training Data)**")
+    col1, col2 = st.columns(2)
+    with col1:
+        # Show delta if we have both scores
+        delta_clarity = None
+        if groq_clarity > 0 and phi3_clarity > 0:
+            delta_clarity = f"+{groq_clarity - phi3_clarity:.1f}"
+        st.metric("Avg Clarity", f"{groq_clarity}/5", delta=delta_clarity)
+    with col2:
+        delta_depth = None
+        if groq_depth > 0 and phi3_depth > 0:
+            delta_depth = f"+{groq_depth - phi3_depth:.1f}"
+        st.metric("Avg Depth", f"{groq_depth}/5", delta=delta_depth)
+    
+    # Phi-3 metrics
+    st.markdown("**🧪 Phi-3 (Research Model)**")
+    col3, col4 = st.columns(2)
+    with col3:
+        delta_clarity_phi3 = None
+        if phi3_clarity > 0 and groq_clarity > 0:
+            delta_clarity_phi3 = f"{phi3_clarity - groq_clarity:.1f}"
+        st.metric("Avg Clarity", f"{phi3_clarity}/5", delta=delta_clarity_phi3)
+    with col4:
+        delta_depth_phi3 = None
+        if phi3_depth > 0 and groq_depth > 0:
+            delta_depth_phi3 = f"{phi3_depth - groq_depth:.1f}"
+        st.metric("Avg Depth", f"{phi3_depth}/5", delta=delta_depth_phi3)
+    
+    # Show quality gap analysis
+    if groq_clarity > 0 and phi3_clarity > 0:
+        clarity_gap = groq_clarity - phi3_clarity
+        depth_gap = groq_depth - phi3_depth
+        
+        if clarity_gap > 0 or depth_gap > 0:
+            st.caption(f"🔍 Quality gap: Clarity +{clarity_gap:.1f}, Depth +{depth_gap:.1f}")
+        elif clarity_gap < 0 or depth_gap < 0:
+            st.caption(f"🎉 Phi-3 leads: Clarity {abs(clarity_gap):.1f}, Depth {abs(depth_gap):.1f}")
+        else:
+            st.caption("⚖️ Models performing equally")
+
+def render_research_status(stats):
+    st.subheader("🔬 Research Progress")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric("Groq Data", stats.get("groq_feedback_count", 0))
+        st.caption("For fine-tuning")
+    
+    with col2:
+        st.metric("High-Quality Groq", stats.get("high_quality_groq", 0))
+        st.caption("Fine-tuning ready")
+    
+    with col3:
+        st.metric("Phi-3 Data", stats.get("phi3_feedback_count", 0))
+        st.caption("For comparison")
+    
+    # Fine-tuning readiness
+    target_examples = 50
+    high_quality_groq = stats.get("high_quality_groq", 0)
+    
+    if high_quality_groq >= target_examples:
+        st.success("🎉 Ready to fine-tune Phi-3 with Groq data!")
+        if st.button("🚀 Export Fine-tuning Data", use_container_width=True, type="primary"):
+            from export_training_data_from_db import export_training_data_from_db
+            if export_training_data_from_db():
+                st.success("✅ Groq data exported for Phi-3 fine-tuning!")
+            else:
+                st.error("Export failed")
+    else:
+        needed = target_examples - high_quality_groq
+        st.info(f"📊 Need {needed} more high-quality Groq examples")
+        progress = high_quality_groq / target_examples if target_examples > 0 else 0
+        st.progress(progress)
+        st.caption(f"Progress: {high_quality_groq}/{target_examples} examples")
+
+def render_service_status():
+    st.markdown("---")
+    st.subheader("🛜 Platform Status")
+    
+    try:
+        status = model_manager.get_service_status()
+        
+        # Create status columns
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Phi-3 Status
+            phi3_status = status["phi3"]
+            if phi3_status["server_healthy"] and phi3_status["model_available"]:
+                st.success("🧪 Phi-3 Mini")
+                st.caption("Research Model • Ready")
+            elif phi3_status["server_healthy"]:
+                st.warning("🧪 Phi-3 Mini") 
+                st.caption("Research Model • Needs Setup")
+            else:
+                st.error("🧪 Phi-3 Mini")
+                st.caption("Research Model • Offline")
+        
+        with col2:
+            # Groq Status
+            groq_status = status["groq"]
+            healthy_count = groq_status['healthy_providers']
+            total_providers = groq_status['total_providers']
+            
+            if healthy_count == total_providers:
+                st.success("📊 Groq API")
+                st.caption("Training Data • Fully Operational")
+            elif healthy_count > 0:
+                st.warning("📊 Groq API")
+                st.caption(f"Training Data • {healthy_count}/{total_providers} providers")
+            else:
+                st.error("📊 Groq API")
+                st.caption("Training Data • Offline")
+        
+        # Quick health indicator
+        if status["phi3"]["server_healthy"] and groq_status['healthy_providers'] > 0:
+            st.caption("💡 All systems operational - research ready!")
+        else:
+            st.caption("⚠️ Some services limited - research may be affected")
+                
+    except Exception as e:
+        st.error("❌ Status check failed")
+        st.caption("Research platform may have issues")
+
+def render_default_sidebar():
+    st.info("🌟 Start generating content to contribute to our research!")
+    st.caption("Your feedback on Groq content will train Phi-3 to become a better educational AI")
+    if st.button("🔄 Refresh Progress", use_container_width=True, key="refresh_progress"):
+        st.rerun()