Upload 5 files

app.py

@@ -0,0 +1,230 @@
+import streamlit as st
+import re
+from components.session_manager import initialize_session_state, clear_session, save_current_to_history, get_or_create_user_id
+from components.ui_components import render_header, render_sidebar
+from components.student_flow import render_student_flow
+from components.tutor_flow import render_tutor_flow
+from components.output_renderer import render_output_section
+from components.feedback_handler import render_feedback_section
+from components.export_handler import render_export_section
+from components.history_page import render_history_page
+
+import base64
+
+# Find where the validation error is coming from
+original_b64decode = base64.b64decode
+
+def debug_b64decode(data, *args, **kwargs):
+    try:
+        return original_b64decode(data, *args, **kwargs)
+    except Exception as e:
+        print(f"🚨 BASE64 DECODE ERROR: {e}")
+        print(f"🚨 Data type: {type(data)}")
+        print(f"🚨 Data length: {len(data) if data else 0}")
+        if data and isinstance(data, str):
+            print(f"🚨 Data preview: {data[:100]}...")
+        import traceback
+        traceback.print_stack()
+        raise
+
+base64.b64decode = debug_b64decode
+
+# Streamlit App Configuration
+st.set_page_config(page_title="TailorED", layout="wide")
+
+def scroll_to_top():
+    """Force scroll to top of page"""
+    st.components.v1.html("""
+    <script>
+        window.scrollTo(0, 0);
+        setTimeout(() => window.scrollTo(0, 0), 100);
+        setTimeout(() => window.scrollTo({top: 0, behavior: 'smooth'}), 200);
+    </script>
+    """, height=0)
+
+def main():
+    
+    try:
+        from db.connection import init_db
+        init_db()
+    except Exception as e:
+        st.error(f"❌ Database initialization failed: {e}")
+        st.stop()
+         
+    # Initialize session state
+    initialize_session_state()
+
+    # Ensure user ID is stored in session
+    if "user_id" not in st.session_state:
+        st.session_state.user_id = get_or_create_user_id()
+
+    # Create a scroll anchor at the top
+    scroll_anchor = st.empty()
+    
+    # Render header with navigation
+    render_header_with_nav()
+
+    # Render sidebar
+    render_sidebar()
+
+    # Handle model regeneration if needed
+    if st.session_state.get("regenerate_with_new_model"):
+        handle_regeneration()
+
+    # Main application logic based on current page
+    handle_page_navigation()
+
+    # Session management
+    handle_session_management()
+
+    # Force scroll to top after content generation
+    if st.session_state.get("generated_output") and not st.session_state.get("scrolled_to_top", False):
+        scroll_to_top()
+        st.session_state.scrolled_to_top = True
+
+def render_header_with_nav():
+    st.title("🧠 TailorED - AI-Powered Educational Content Generator")
+    
+    col1, col2, col3, col4 = st.columns([2, 1, 1, 1])
+    
+    with col1:
+        st.caption("Create, manage, and access your educational content")
+    
+    with col2:
+        if st.button("🔄 New Content", use_container_width=True, key="new_content_btn"):
+            st.session_state.current_page = "generator"
+            clear_session()
+            st.rerun()
+    
+    with col3:
+        if st.button("📚 History", use_container_width=True, key="history_btn"):
+            st.session_state.current_page = "history"
+            # RELOAD HISTORY WHEN NAVIGATING TO HISTORY PAGE
+            from components.session_manager import load_user_history_from_db
+            load_user_history_from_db()
+            st.rerun()
+    
+    with col4:
+        if st.button("🔬 Research", use_container_width=True, key="research_btn"):
+            st.session_state.current_page = "research"
+            st.rerun()
+
+def handle_regeneration():
+    """Handle model regeneration when user switches models"""
+    if st.session_state.get("regenerate_with_new_model"):
+        # Clear the flag first to prevent loops
+        st.session_state.regenerate_with_new_model = False
+        
+        # Show regeneration in progress
+        regeneration_status = st.empty()
+        regeneration_status.info("🔄 Regenerating content with new model...")
+        
+        # Get the preserved context
+        user_type = st.session_state.user_type
+        student_level = st.session_state.student_level
+        
+        # Trigger regeneration based on user type
+        if user_type == "student":
+            from components.student_flow import generate_student_content
+            content_text = st.session_state.get("original_content_text", "")
+            if content_text:
+                generate_student_content(content_text, student_level, "", "regenerated_content.pdf")
+        else:
+            from components.tutor_flow import generate_tutor_content
+            topic = st.session_state.get("original_topic", "")
+            objectives = st.session_state.get("original_objectives", "")
+            content_type = st.session_state.get("tutor_content_type", "Comprehensive Explanation")
+            if topic and objectives:
+                generate_tutor_content(topic, objectives, student_level, content_type, "")
+        
+        regeneration_status.empty()
+        
+def handle_page_navigation():
+    current_page = st.session_state.get("current_page", "generator")
+    
+    if current_page == "history":
+        # ENSURE HISTORY IS LOADED BEFORE RENDERING
+        from components.session_manager import load_user_history_from_db
+        load_user_history_from_db()
+        render_history_page()
+    elif current_page == "research":  
+        try:
+            from components.research_dashboard import render_research_dashboard
+            render_research_dashboard()
+        except ImportError as e:
+            st.error("🔬 Research Dashboard - Import Error")
+            st.code(f"Error: {str(e)}")
+            st.info("""
+            **To fix this:**
+            1. Make sure `components/research_dashboard.py` exists
+            2. Check the file has no syntax errors
+            3. Restart the Streamlit app
+            """)
+        except Exception as e:
+            st.error("🔬 Research Dashboard - Runtime Error")
+            st.code(f"Error: {str(e)}")
+            st.info("The research dashboard encountered an error while running.")
+    else:
+        handle_generator_flow()
+        
+def handle_generator_flow():
+    # DEBUG: Check what's in session state
+    print(f"🔍 DEBUG handle_generator_flow:")
+    print(f"   - generated_output: {bool(st.session_state.get('generated_output'))}")
+    print(f"   - regenerated: {st.session_state.get('regenerated', False)}")
+    print(f"   - feedback_given: {st.session_state.get('feedback_given', False)}")
+    print(f"   - pending_regeneration: {st.session_state.get('pending_regeneration', False)}")
+    
+    # Handle pending regeneration FIRST in the generator flow
+    if st.session_state.get('pending_regeneration'):
+        print("🔄 DEBUG: Handling pending regeneration in generator flow")
+        from components.feedback_handler import handle_pending_regeneration
+        handle_pending_regeneration()
+    
+    # Check if we have content to display - REGARDLESS of regeneration status
+    if st.session_state.get("generated_output"):
+        print("✅ DEBUG: Rendering content sections")
+        render_output_section()
+        render_export_section()
+        render_feedback_section()
+        return
+    
+    # If no content, check if we have a user type selected
+    if not st.session_state.user_type:
+        render_user_selection()
+        return
+    
+    # If user type is selected but no content, render the appropriate flow
+    if st.session_state.user_type == "student":
+        render_student_flow()
+    else:
+        render_tutor_flow()
+
+def render_user_selection():
+    st.header("🎯 Welcome to TailorED!")
+    st.subheader("Are you a Student or Tutor?")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("🎓 I'm a Student", use_container_width=True, key="student_btn"):
+            st.session_state.user_type = "student"
+            st.session_state.scrolled_to_top = False
+            st.rerun()
+
+    with col2:
+        if st.button("👨‍🏫 I'm a Tutor", use_container_width=True, key="tutor_btn"):
+            st.session_state.user_type = "tutor"
+            st.session_state.scrolled_to_top = False
+            st.rerun()
+
+def handle_session_management():
+    # Only show start over if we have content
+    if (st.session_state.get("current_page") == "generator" and 
+        st.session_state.get("generated_output") and
+        st.button("🆕 Start Over", key="start_over_btn")):
+        clear_session()
+        st.rerun()
+
+if __name__ == "__main__":
+    main()

export_training_data_from_db.py

@@ -0,0 +1,160 @@
+from db.connection import SessionLocal  
+from db.models import ContentHistory, Feedback
+from sqlalchemy.orm import joinedload
+import os
+import json
+
+MIN_CLARITY = 4
+MIN_DEPTH = 4
+MIN_COMMENT_LENGTH = 25
+
+def is_high_quality(feedback, content_entry):
+    """Check if feedback meets high quality criteria for Groq content (fine-tuning data)"""
+    # Only use Groq content for fine-tuning (the established model)
+    if content_entry.generated_model != "groq":
+        print(f"❌ Skipping - not Groq content: {content_entry.generated_model}")
+        return False
+    
+    # Quality criteria for fine-tuning data
+    if feedback.clarity < MIN_CLARITY:
+        print(f"❌ Clarity too low: {feedback.clarity} < {MIN_CLARITY}")
+        return False
+        
+    if feedback.depth < MIN_DEPTH:
+        print(f"❌ Depth too low: {feedback.depth} < {MIN_DEPTH}")
+        return False
+
+    if feedback.complexity != "Just right":
+        print(f"❌ Complexity not 'Just right': {feedback.complexity}")
+        return False
+
+    comment_text = (feedback.comments or "").strip()
+    if len(comment_text) < MIN_COMMENT_LENGTH:
+        print(f"❌ Comment too short: {len(comment_text)} < {MIN_COMMENT_LENGTH}")
+        return False
+
+    print(f"✅ High-quality Groq feedback for fine-tuning: clarity={feedback.clarity}, depth={feedback.depth}")
+    return True
+
+def format_training_example(entry, feedback):
+    """Format a training example from Groq content and feedback"""
+    if entry.user_type == "student":
+        return {
+            "instruction": f"Simplify the following content for a {entry.student_level} student: {entry.prompt.strip()}",
+            "input": f"Student Level: {entry.student_level}",
+            "output": entry.output.strip(),
+            "metadata": {
+                "user_type": "student",
+                "student_level": entry.student_level,
+                "clarity_score": feedback.clarity,
+                "depth_score": feedback.depth,
+                "complexity": feedback.complexity,
+                "comments": feedback.comments
+            }
+        }
+    elif entry.user_type == "tutor":
+        return {
+            "instruction": f"Create a {entry.content_type} about '{entry.topic}' for {entry.student_level} students.",
+            "input": f"Learning Objectives: {entry.prompt}",
+            "output": entry.output.strip(),
+            "metadata": {
+                "user_type": "tutor", 
+                "content_type": entry.content_type,
+                "topic": entry.topic,
+                "student_level": entry.student_level,
+                "clarity_score": feedback.clarity,
+                "depth_score": feedback.depth,
+                "complexity": feedback.complexity,
+                "comments": feedback.comments
+            }
+        }
+    return None
+
+def export_training_data_from_db(output_file="data/training/phi3_fine_tuning_data.jsonl"):
+    """Export Groq content with high-quality feedback for Phi-3 fine-tuning"""
+    print("🔧 Exporting Groq training data for Phi-3 fine-tuning...")
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    session = SessionLocal()
+    try:
+        # Get all content entries with their feedback
+        entries = session.query(ContentHistory).options(joinedload(ContentHistory.feedback)).all()
+        print(f"📊 Found {len(entries)} total content entries")
+
+        high_quality_groq = []
+        total_groq_feedback = 0
+        total_entries_checked = 0
+        
+        for entry in entries:
+            total_entries_checked += 1
+            feedback_list = entry.feedback
+            print(f"🔍 Checking entry {total_entries_checked}/{len(entries)}: model={entry.generated_model}, user_type={entry.user_type}, feedback_count={len(feedback_list)}")
+            
+            for feedback in feedback_list:
+                # Count all Groq feedback for statistics
+                if entry.generated_model == "groq":
+                    total_groq_feedback += 1
+                    print(f"  📝 Groq Feedback {total_groq_feedback}: clarity={feedback.clarity}, depth={feedback.depth}")
+                
+                # Only export high-quality Groq feedback (for fine-tuning Phi-3)
+                if is_high_quality(feedback, entry):
+                    example = format_training_example(entry, feedback)
+                    if example:
+                        high_quality_groq.append(example)
+                        print(f"  ✅ Added Groq training example")
+
+        print(f"📈 Export Summary:")
+        print(f"   - Total entries checked: {total_entries_checked}")
+        print(f"   - Total Groq feedback: {total_groq_feedback}")
+        print(f"   - High-quality Groq examples: {len(high_quality_groq)}")
+
+        if not high_quality_groq:
+            print("❌ No high-quality Groq training data found.")
+            print("💡 Make sure you have Groq-generated content with high-quality feedback:")
+            print(f"   - Generated by Groq model")
+            print(f"   - Clarity >= {MIN_CLARITY}")
+            print(f"   - Depth >= {MIN_DEPTH}")
+            print(f"   - Complexity = 'Just right'")
+            print(f"   - Comments length >= {MIN_COMMENT_LENGTH} characters")
+            return False
+
+        # Write to JSONL file (without metadata for training)
+        with open(output_file, "w", encoding="utf-8") as f:
+            for item in high_quality_groq:
+                # Remove metadata for actual training
+                training_item = {
+                    "instruction": item["instruction"],
+                    "input": item["input"],
+                    "output": item["output"]
+                }
+                f.write(json.dumps(training_item, ensure_ascii=False) + "\n")
+
+        print(f"✅ Successfully exported {len(high_quality_groq)} Groq training examples to {output_file}")
+        
+        # Show detailed breakdown
+        if high_quality_groq:
+            student_examples = len([e for e in high_quality_groq if "Simplify" in e["instruction"]])
+            tutor_examples = len([e for e in high_quality_groq if "Create a" in e["instruction"]])
+            print(f"📊 Breakdown: {student_examples} student examples, {tutor_examples} tutor examples")
+            
+            print("📝 Sample training example:")
+            sample = high_quality_groq[0]
+            print(json.dumps({
+                "instruction": sample["instruction"][:100] + "...",
+                "input": sample["input"],
+                "output": sample["output"][:100] + "..."
+            }, indent=2, ensure_ascii=False))
+            
+        return True
+
+    except Exception as e:
+        print(f"❌ Error exporting training data: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    finally:
+        session.close()
+
+if __name__ == "__main__":
+    export_training_data_from_db()

feedback.py

@@ -0,0 +1,248 @@
+import json
+import os
+import re
+from datetime import datetime
+from db.helpers import get_research_stats
+
+def save_feedback(prompt, output, clarity, depth, complexity, comments, user_type=None, student_level=None):
+    """
+    Save user feedback to a JSONL file with additional metadata
+    """
+    
+    # Create feedback directory if it doesn't exist
+    os.makedirs("data/feedback", exist_ok=True)
+    
+    feedback_data = {
+        "timestamp": datetime.now().isoformat(),
+        "prompt": prompt,
+        "output": output,
+        "feedback": {
+            "clarity": clarity,
+            "depth": depth,
+            "complexity": complexity,
+            "comments": comments
+        },
+        "metadata": {
+            "user_type": user_type,
+            "student_level": student_level
+        }
+    }
+    
+    # Save to JSONL file
+    feedback_file = "data/feedback/feedback.jsonl"
+    
+    try:
+        with open(feedback_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(feedback_data, ensure_ascii=False) + "\n")
+        
+        print(f"✅ Feedback saved to {feedback_file}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error saving feedback: {e}")
+        return False
+
+def load_feedback_data():
+    """Load all feedback data for analysis"""
+    feedback_file = "data/feedback/feedback.jsonl"
+    
+    if not os.path.exists(feedback_file):
+        return []
+    
+    feedback_data = []
+    try:
+        with open(feedback_file, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    feedback_data.append(json.loads(line.strip()))
+        return feedback_data
+    except Exception as e:
+        print(f"❌ Error loading feedback data: {e}")
+        return []
+
+def get_feedback_stats():
+    """Get basic statistics about collected feedback"""
+    feedback_data = load_feedback_data()
+    
+    if not feedback_data:
+        return {
+            "total_feedback": 0,
+            "average_clarity": 0,
+            "average_depth": 0,
+            "complexity_distribution": {},
+            "user_type_distribution": {}
+        }
+    
+    total = len(feedback_data)
+    clarity_sum = 0
+    depth_sum = 0
+    complexity_counts = {}
+    user_type_counts = {}
+    
+    for entry in feedback_data:
+        clarity_sum += entry["feedback"]["clarity"]
+        depth_sum += entry["feedback"]["depth"]
+        
+        complexity = entry["feedback"]["complexity"]
+        complexity_counts[complexity] = complexity_counts.get(complexity, 0) + 1
+        
+        user_type = entry["metadata"].get("user_type", "unknown")
+        user_type_counts[user_type] = user_type_counts.get(user_type, 0) + 1
+    
+    return {
+        "total_feedback": total,
+        "average_clarity": round(clarity_sum / total, 2) if total > 0 else 0,
+        "average_depth": round(depth_sum / total, 2) if total > 0 else 0,
+        "complexity_distribution": complexity_counts,
+        "user_type_distribution": user_type_counts
+    }
+
+def is_high_quality_feedback(feedback_entry):
+    """
+    SIMPLEST VERSION: Length-based filtering after removing emojis
+    Only uses high-quality, "just right" feedback for training
+    """
+    feedback = feedback_entry["feedback"]
+    
+    # Quality thresholds
+    MIN_CLARITY = 4
+    MIN_DEPTH = 4
+    MIN_COMMENT_LENGTH = 25  # Substantive comments after emoji removal
+    MIN_WORD_COUNT = 4       # Minimum words for substance
+
+    # Check ratings (must be high quality)
+    if feedback["clarity"] < MIN_CLARITY or feedback["depth"] < MIN_DEPTH:
+        return False
+    
+    # Check complexity (we want "Just right" examples to replicate)
+    if feedback["complexity"] != "Just right":
+        return False
+    
+    # Check comments if provided
+    comments = feedback.get("comments", "").strip()
+    
+    if comments:
+        # Remove emojis first, then check length
+        emoji_pattern = re.compile(
+            r'[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF\U0001F680-\U0001F6FF\U0001F1E0-\U0001F1FF\U00002600-\U000027BF\U0001F900-\U0001F9FF\U0001F018-\U0001F270👍👎😊😐😕❤️🔥]',
+            flags=re.UNICODE
+        )
+        text_without_emojis = emoji_pattern.sub('', comments).strip()
+        
+        # Now apply length check on the cleaned text
+        if len(text_without_emojis) < MIN_COMMENT_LENGTH:
+            return False
+            
+        # Check word count for minimal substance
+        word_count = len(text_without_emojis.split())
+        if word_count < MIN_WORD_COUNT:
+            return False
+    
+    return True
+
+def prepare_training_data():
+    """
+    Prepare high-quality feedback for model fine-tuning
+    Returns structured training examples
+    """
+    all_feedback = load_feedback_data()
+    
+    training_examples = []
+    skipped_count = 0
+    
+    for feedback in all_feedback:
+        if is_high_quality_feedback(feedback):
+            # Create training example from high-quality feedback
+            training_example = {
+                "instruction": feedback["prompt"],
+                "input": f"Student Level: {feedback['metadata'].get('student_level', 'Unknown')}",
+                "output": feedback["output"],
+                "metadata": {
+                    "user_type": feedback["metadata"].get("user_type"),
+                    "clarity_score": feedback["feedback"]["clarity"],
+                    "depth_score": feedback["feedback"]["depth"],
+                    "comments": feedback["feedback"].get("comments", "")
+                }
+            }
+            training_examples.append(training_example)
+        else:
+            skipped_count += 1
+    
+    print(f"✅ Prepared {len(training_examples)} training examples (skipped {skipped_count} low-quality)")
+    return training_examples
+
+def get_training_data_stats():
+    """
+    Get statistics about prepared training data
+    """
+    training_data = prepare_training_data()
+    
+    if not training_data:
+        return {
+            "total_training_examples": 0,
+            "user_type_breakdown": {},
+            "average_scores": {"clarity": 0, "depth": 0}
+        }
+    
+    user_type_counts = {}
+    clarity_sum = 0
+    depth_sum = 0
+    
+    for example in training_data:
+        user_type = example["metadata"].get("user_type", "unknown")
+        user_type_counts[user_type] = user_type_counts.get(user_type, 0) + 1
+        
+        clarity_sum += example["metadata"]["clarity_score"]
+        depth_sum += example["metadata"]["depth_score"]
+    
+    return {
+        "total_training_examples": len(training_data),
+        "user_type_breakdown": user_type_counts,
+        "average_scores": {
+            "clarity": round(clarity_sum / len(training_data), 2),
+            "depth": round(depth_sum / len(training_data), 2)
+        }
+    }
+
+def export_training_data(output_file="data/training/training_data.jsonl"):
+    """
+    Export filtered training data to file for fine-tuning
+    """
+    training_data = prepare_training_data()
+    
+    if not training_data:
+        print("❌ No high-quality training data available")
+        return False
+    
+    # Create directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            for example in training_data:
+                # Remove metadata for actual training
+                training_example = {
+                    "instruction": example["instruction"],
+                    "input": example["input"],
+                    "output": example["output"]
+                }
+                f.write(json.dumps(training_example, ensure_ascii=False) + "\n")
+        
+        print(f"✅ Exported {len(training_data)} training examples to {output_file}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error exporting training data: {e}")
+        return False
+
+def get_research_progress():
+    """Fetch research progress from PostgreSQL"""
+    stats = get_research_stats()
+
+    return {
+        "total_feedback": stats["total_feedback"],
+        "high_quality_examples": stats["high_quality_feedback"],
+        "conversion_rate": stats["conversion_rate"],
+        "average_quality": stats["average_scores"],
+        "user_breakdown": stats["user_type_breakdown"]
+    }

generator.py

@@ -0,0 +1,1636 @@
+import os
+import time
+import random
+import requests
+from openai import OpenAI
+from typing import Dict, List, Optional
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def get_api_keys(service_name: str, key_names: List[str]) -> List[str]:
+    """Get API keys from multiple sources with priority for HuggingFace Spaces"""
+    keys = []
+    
+    # 1. HuggingFace Spaces Secrets (Primary)
+    for key_name in key_names:
+        # Try HF-specific naming first
+        hf_key_name = f"HF_{service_name.upper()}_{key_name}"
+        key = os.getenv(hf_key_name)
+        if key and key.strip():
+            keys.append(key.strip())
+            logger.info(f"✅ Found {service_name} key {key_name} in HuggingFace secrets")
+    
+    # 2. Standard Environment Variables
+    for key_name in key_names:
+        key = os.getenv(key_name) or os.getenv(key_name.upper())
+        if key and key.strip() and key not in keys:
+            keys.append(key.strip())
+            logger.info(f"✅ Found {service_name} key {key_name} in environment")
+    
+    # 3. Streamlit Secrets (Backward Compatibility)
+    try:
+        import streamlit as st
+        if hasattr(st, 'secrets') and service_name in st.secrets:
+            secrets = st.secrets[service_name]
+            for key_name in key_names:
+                key = secrets.get(key_name)
+                if key and key.strip() and key not in keys:
+                    keys.append(key.strip())
+                    logger.info(f"✅ Found {service_name} key {key_name} in Streamlit secrets")
+    except (ImportError, AttributeError):
+        pass
+    
+    return keys
+
+def get_groq_api_keys():
+    """Get Groq API keys for all environments"""
+    return get_api_keys("groq", ["api_key", "api_key_1", "api_key_2"])
+
+def get_ollama_url():
+    """Get Ollama URL from multiple sources"""
+    
+    # 1. HuggingFace Spaces
+    hf_url = os.getenv("HF_OLLAMA_URL")
+    if hf_url:
+        logger.info("✅ Found Ollama URL in HuggingFace secrets")
+        return hf_url
+    
+    # 2. Environment Variables
+    env_url = os.getenv("OLLAMA_URL") or os.getenv("MODEL_URL")
+    if env_url:
+        logger.info("✅ Found Ollama URL in environment")
+        return env_url
+    
+    # 3. Streamlit Secrets
+    try:
+        import streamlit as st
+        if hasattr(st, 'secrets') and 'ollama' in st.secrets:
+            url = st.secrets["ollama"].get("url")
+            if url:
+                logger.info("✅ Found Ollama URL in Streamlit secrets")
+                return url
+    except (ImportError, AttributeError):
+        pass
+    
+    logger.warning("⚠️ No Ollama URL configured - local models will not be available")
+    return None
+
+class MultiGroqGenerator:
+    def __init__(self):
+        self.providers = self._initialize_groq_providers()
+        self.models = self._get_best_models()
+        self.max_retries = 3
+        self.retry_delay = 2  # seconds
+        
+    def _initialize_groq_providers(self):
+        """Initialize multiple Groq API providers with different keys"""
+        providers = []
+        
+        # Get all Groq API keys
+        groq_keys = get_groq_api_keys()
+        
+        # Filter out None values and create providers
+        for i, key in enumerate(groq_keys):
+            if key and key.strip():
+                providers.append({
+                    'name': f'Groq-{i+1}',
+                    'client': OpenAI(
+                        api_key=key.strip(),
+                        base_url="https://api.groq.com/openai/v1"
+                    ),
+                    'weight': 10,
+                    'fail_count': 0,
+                    'last_used': 0
+                })
+        
+        if not providers:
+            logger.warning("❌ No Groq API keys found")
+            return []
+            
+        logger.info(f"✅ Initialized {len(providers)} Groq providers")
+        return providers
+    
+    def _get_best_models(self):
+        """Select optimal models for educational content"""
+        return [
+            {
+                'id': 'llama-3.3-70b-versatile',
+                'name': 'Llama 3.3 70B',
+                'weight': 10,
+                'max_tokens': 32768,
+                'description': 'Best for complex explanations'
+            },
+            {
+                'id': 'meta-llama/llama-4-maverick-17b-128e-instruct', 
+                'name': 'Llama 4 Maverick 17B',
+                'weight': 9,
+                'max_tokens': 128000,
+                'description': 'Large context for big documents'
+            },
+            {
+                'id': 'llama-3.1-8b-instant',
+                'name': 'Llama 3.1 8B Instant',
+                'weight': 8,
+                'max_tokens': 32768,
+                'description': 'Fast for most content'
+            },
+        ]
+    
+    def _select_provider(self):
+        """Select provider based on weight and fail history"""
+        if not self.providers:
+            return None
+            
+        available_providers = [
+            p for p in self.providers 
+            if p['fail_count'] < 3 and (time.time() - p['last_used']) > 30
+        ]
+        
+        if not available_providers:
+            available_providers = self.providers
+            for p in available_providers:
+                p['fail_count'] = max(0, p['fail_count'] - 1)
+        
+        weights = [p['weight'] for p in available_providers]
+        selected = random.choices(available_providers, weights=weights, k=1)[0]
+        selected['last_used'] = time.time()
+        return selected
+    
+    def _select_model(self, prompt_length: int):
+        """Select optimal model based on prompt size"""
+        approx_tokens = prompt_length // 4
+        
+        if approx_tokens > 20000:
+            return self.models[1]  # Maverick for huge docs
+        elif approx_tokens > 10000:
+            return self.models[1]  # Maverick for large docs
+        elif approx_tokens > 6000:
+            return self.models[0]  # 70B for medium-large
+        elif approx_tokens > 3000:
+            return self.models[0]  # 70B for quality
+        else:
+            return self.models[2]  # 8B for speed
+    
+    def generate(self, prompt: str) -> str:
+        """Generate content with automatic failover"""
+        if not self.providers:
+            return "❌ Groq Error: No API keys configured. Please set GROQ_API_KEY in HuggingFace secrets or environment variables."
+        
+        last_error = None
+        prompt_length = len(prompt)
+        
+        for attempt in range(self.max_retries + 1):
+            provider = self._select_provider()
+            model = self._select_model(prompt_length)
+            
+            if not provider:
+                return "❌ Groq Error: No available providers"
+            
+            try:
+                logger.info(f"🔄 Attempt {attempt + 1} with {provider['name']} using {model['name']}...")
+                
+                result = self._call_groq(provider, model, prompt)
+                
+                if result and not result.startswith(("[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "[ModelNotFound]")):
+                    logger.info(f"✅ Success with {provider['name']} + {model['name']}")
+                    provider['weight'] = min(20, provider['weight'] + 1)
+                    provider['fail_count'] = max(0, provider['fail_count'] - 1)
+                    return result
+                else:
+                    logger.warning(f"❌ Provider returned: {result}")
+                    if "[ModelNotFound]" in result:
+                        continue
+                    
+            except Exception as e:
+                last_error = str(e)
+                logger.error(f"❌ {provider['name']} + {model['name']} failed: {last_error}")
+                provider['weight'] = max(1, provider['weight'] - 2)
+                provider['fail_count'] += 1
+                
+                if attempt < self.max_retries:
+                    delay = self.retry_delay * (2 ** attempt)
+                    logger.info(f"⏰ Waiting {delay}s before retry...")
+                    time.sleep(delay)
+        
+        return self._fallback_generate(prompt)
+    
+    def generate_large_content(self, prompt: str) -> str:
+        """Handle large content generation for Groq - compatibility method"""
+        logger.info("🔷 Using Groq for large content generation...")
+        
+        # For Groq, we can handle large content directly due to large context windows
+        # Just use the normal generate method with optimized model selection
+        prompt_length = len(prompt)
+        
+        if prompt_length > 20000:  # Very large prompt
+            logger.info("📝 Large prompt detected, optimizing for Groq Maverick...")
+            # Temporarily prioritize Maverick for large contexts
+            original_models = self.models.copy()
+            self.models = [self.models[1]]  # Maverick has 128K context
+            try:
+                result = self.generate(prompt)
+                return result
+            finally:
+                self.models = original_models  # Restore original models
+        else:
+            # Use normal generation
+            return self.generate(prompt)
+    
+    def _fallback_generate(self, prompt: str) -> str:
+        """Fallback generation with simpler model selection"""
+        logger.info("🔄 Trying fallback generation...")
+        
+        fallback_models = [self.models[2], self.models[0]]
+        
+        for model in fallback_models:
+            for provider in self.providers:
+                try:
+                    logger.info(f"🔄 Fallback with {provider['name']} using {model['name']}...")
+                    result = self._call_groq(provider, model, prompt)
+                    
+                    if result and not result.startswith(("[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "[ModelNotFound]")):
+                        logger.info(f"✅ Fallback success with {provider['name']} + {model['name']}")
+                        return result
+                except Exception as e:
+                    logger.error(f"❌ Fallback failed: {e}")
+                    continue
+        
+        return self._get_user_friendly_error("All models failed")
+    
+    def _call_groq(self, provider, model, prompt: str) -> str:
+        """Call Groq API with specific provider and model"""
+        try:
+            prompt_tokens_approx = len(prompt) // 4
+            available_tokens = model['max_tokens'] - prompt_tokens_approx - 500
+            max_response_tokens = max(1000, min(8000, available_tokens))
+            
+            response = provider['client'].chat.completions.create(
+                model=model['id'],
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.7,
+                max_tokens=max_response_tokens,
+                top_p=0.9
+            )
+            
+            if (response and response.choices and len(response.choices) > 0 and 
+                response.choices[0].message and response.choices[0].message.content):
+                
+                content = response.choices[0].message.content.strip()
+                return content if content else "[Empty] No content generated"
+            else:
+                return "[Empty] Invalid response structure"
+                
+        except Exception as e:
+            error_msg = str(e).lower()
+            
+            if "rate limit" in error_msg or "429" in error_msg:
+                return f"[RateLimit] {provider['name']} rate limit exceeded"
+            elif "quota" in error_msg:
+                return f"[Quota] {provider['name']} quota exceeded"
+            elif "authentication" in error_msg:
+                return f"[Auth] {provider['name']} authentication failed"
+            elif "context length" in error_msg:
+                return f"[Length] {provider['name']} content too long"
+            elif "model not found" in error_msg:
+                return f"[ModelNotFound] {provider['name']}: {str(e)}"
+            else:
+                return f"[Error] {provider['name']}: {str(e)}"
+    
+    def _get_user_friendly_error(self, technical_error: str) -> str:
+        """Convert technical errors to user-friendly messages"""
+        error_lower = technical_error.lower()
+        
+        if "rate limit" in error_lower:
+            return "🚫 **Service Busy** - Please wait a few minutes and try again"
+        elif "quota" in error_lower:
+            return "📊 **Daily Limit Reached** - Try again tomorrow"
+        elif "length" in error_lower:
+            return "📝 **Content Too Large** - Please break into smaller sections"
+        else:
+            return "❌ **Temporary Issue** - Please try again shortly"
+
+    def get_service_status(self) -> dict:
+        """Get current status of all providers"""
+        status = {
+            'total_providers': len(self.providers),
+            'healthy_providers': len([p for p in self.providers if p['fail_count'] < 2]),
+            'providers': [],
+            'models': [m['name'] for m in self.models]
+        }
+        
+        for provider in self.providers:
+            if provider['fail_count'] >= 3:
+                status_text = "🔴 Limited"
+            elif provider['fail_count'] >= 1:
+                status_text = "🟡 Slow"
+            else:
+                status_text = "🟢 Good"
+                
+            status['providers'].append({
+                'name': provider['name'],
+                'status': status_text,
+                'failures': provider['fail_count']
+            })
+        
+        return status
+
+
+class HFGenerator:
+    """Phi-3 Generator with Auto-Pull, Smart Chunking, and Context Preservation"""
+    
+    def __init__(self, base_url: str = None):
+        # Use environment variable or Streamlit secret as default
+        self.base_url = base_url or get_ollama_url()
+        self.model = "phi3:mini"
+        self.current_requests = 0
+        self.max_concurrent = 2
+        self.model_available = False
+        
+        # Only try to connect if base_url is provided
+        if self.base_url:
+            self._ensure_model_available()
+        else:
+            logger.warning("⚠️ Ollama URL not configured - Phi-3 will not be available")
+    
+    def _ensure_model_available(self):
+        """Check if model is available and pull if needed"""
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=10)
+            if response.status_code == 200:
+                models = response.json().get('models', [])
+                self.model_available = any(model['name'] == self.model for model in models)
+                
+                if not self.model_available:
+                    logger.info(f"🔄 Model {self.model} not found, pulling...")
+                    self._pull_model()
+                else:
+                    logger.info(f"✅ Model {self.model} is available")
+            else:
+                logger.warning(f"❌ Could not check models: {response.status_code}")
+        except Exception as e:
+            logger.error(f"❌ Error checking models: {e}")
+    
+    def _pull_model(self):
+        """Pull the Phi-3 model if not available"""
+        try:
+            logger.info(f"📥 Pulling {self.model}... This may take a few minutes.")
+            
+            payload = {"name": self.model}
+            response = requests.post(
+                f"{self.base_url}/api/pull", 
+                json=payload, 
+                timeout=300  # 5 minute timeout for pull
+            )
+            
+            if response.status_code == 200:
+                logger.info(f"✅ Successfully pulled {self.model}")
+                self.model_available = True
+                return True
+            else:
+                logger.error(f"❌ Failed to pull model: {response.text}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Error pulling model: {e}")
+            return False
+    
+    def _estimate_tokens(self, text: str) -> int:
+        """Rough token estimation"""
+        return len(text) // 4
+    
+    def _chunk_content(self, content: str, max_tokens: int = 2500) -> list:
+        """Split large content into manageable chunks"""
+        paragraphs = content.split('\n\n')
+        chunks = []
+        current_chunk = ""
+        current_tokens = 0
+        
+        for paragraph in paragraphs:
+            para_tokens = self._estimate_tokens(paragraph)
+            
+            if para_tokens > max_tokens:
+                sentences = paragraph.split('. ')
+                for sentence in sentences:
+                    sent_tokens = self._estimate_tokens(sentence)
+                    if current_tokens + sent_tokens > max_tokens:
+                        if current_chunk:
+                            chunks.append(current_chunk.strip())
+                        current_chunk = sentence
+                        current_tokens = sent_tokens
+                    else:
+                        current_chunk += " " + sentence
+                        current_tokens += sent_tokens
+            else:
+                if current_tokens + para_tokens > max_tokens:
+                    if current_chunk:
+                        chunks.append(current_chunk.strip())
+                    current_chunk = paragraph
+                    current_tokens = para_tokens
+                else:
+                    current_chunk += "\n\n" + paragraph
+                    current_tokens += para_tokens
+        
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+            
+        return chunks
+    
+    def _create_context_summary(self, previous_chunks: list) -> str:
+        """Create a context summary from previous chunks"""
+        if not previous_chunks:
+            return ""
+        
+        context_prompt = f"""
+        Here's a summary of previous sections:
+        {chr(10).join(previous_chunks)}
+        
+        Provide a brief summary (2-3 sentences) of key points to help understand the next section.
+        """
+        
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": "user", "content": context_prompt}],
+                "stream": False,
+                "options": {
+                    "temperature": 0.3,
+                    "top_p": 0.8,
+                    "num_predict": 200
+                }
+            }
+            
+            response = requests.post(f"{self.base_url}/api/chat", json=payload, timeout=30)
+            if response.status_code == 200:
+                return response.json()['message']['content'].strip()
+            return f"Previous sections covered: {', '.join(previous_chunks[:2])}..."
+        except Exception:
+            return f"Context from {len(previous_chunks)} previous sections"
+    
+    def _create_chunk_summary(self, content: str) -> str:
+        """Create a very brief summary of a chunk's content"""
+        try:
+            payload = {
+                "model": self.model,
+                "messages": [{"role": "user", "content": f"Summarize key points in 1-2 sentences: {content}"}],
+                "stream": False,
+                "options": {
+                    "temperature": 0.3,
+                    "top_p": 0.8,
+                    "num_predict": 100
+                }
+            }
+            
+            response = requests.post(f"{self.base_url}/api/chat", json=payload, timeout=20)
+            if response.status_code == 200:
+                return response.json()['message']['content'].strip()
+            return content[:100] + "..."
+        except:
+            return content[:100] + "..."
+    
+    def _call_ollama_with_retry(self, payload: dict, max_retries: int = 2) -> Dict:
+        """Call Ollama API with auto-pull retry"""
+        for attempt in range(max_retries + 1):
+            try:
+                response = requests.post(
+                    f"{self.base_url}/api/chat",
+                    json=payload,
+                    timeout=60
+                )
+                
+                if response.status_code == 200:
+                    return {"success": True, "data": response.json()}
+                elif response.status_code == 404 and "not found" in response.text.lower():
+                    logger.info(f"🔄 Model not found, attempting to pull... (attempt {attempt + 1})")
+                    if self._pull_model():
+                        continue  # Retry after successful pull
+                    else:
+                        return {"success": False, "error": "Failed to pull model"}
+                else:
+                    return {"success": False, "error": f"API error {response.status_code}: {response.text}"}
+                    
+            except requests.exceptions.Timeout:
+                if attempt < max_retries:
+                    logger.info(f"⏰ Timeout, retrying... (attempt {attempt + 1})")
+                    time.sleep(2)
+                else:
+                    return {"success": False, "error": "Request timeout"}
+            except Exception as e:
+                return {"success": False, "error": f"Connection failed: {str(e)}"}
+        
+        return {"success": False, "error": "All retries failed"}
+    
+    def generate(self, prompt: str, user_type: str = "student", 
+                 academic_level: str = "undergraduate", 
+                 content_type: str = "simplified_explanation") -> str:
+        """Generate educational content with auto-pull and smart features"""
+        
+        # Check if Ollama is configured
+        if not self.base_url:
+            return "❌ Phi-3 Error: Ollama URL not configured. Please set MODEL_URL environment variable or add to HuggingFace secrets."
+        
+        # Check if we need to pull model first
+        if not self.model_available:
+            logger.info("🔄 Model not available, pulling before generation...")
+            if not self._pull_model():
+                return f"❌ Phi-3 Error: Phi-3 model is not available and failed to pull. Please check the Ollama server."
+        
+        estimated_tokens = self._estimate_tokens(prompt)
+        
+        # Auto-detect large documents and use chunking
+        if estimated_tokens > 3000:
+            result = self.generate_large_content_with_context(prompt, user_type, academic_level, content_type)
+            if isinstance(result, dict):
+                return result.get("content", f"❌ Phi-3 Error: {result.get('error', 'Unknown error')}")
+            return result
+        
+        # Queue management
+        if self.current_requests >= self.max_concurrent:
+            queue_position = self.current_requests - self.max_concurrent + 1
+            estimated_wait = queue_position * 7
+            return f"❌ Phi-3 Error: Service busy. You're #{queue_position} in queue (~{estimated_wait}s)"
+        
+        self.current_requests += 1
+        try:
+            # FIXED: Increased token allocation for complete responses
+            if estimated_tokens > 2000:
+                max_output_tokens = 2000  # Increased from 500
+            elif estimated_tokens > 1000:
+                max_output_tokens = 2500  # Increased from 800
+            else:
+                max_output_tokens = 3000  # Increased from 1000
+            
+            payload = {
+                "model": self.model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": False,
+                "options": {
+                    "temperature": 0.7,
+                    "top_p": 0.9,
+                    "num_predict": max_output_tokens
+                }
+            }
+            
+            start_time = time.time()
+            result = self._call_ollama_with_retry(payload)
+            inference_time = time.time() - start_time
+            
+            if result["success"]:
+                data = result["data"]
+                content = data['message']['content'].strip()
+                
+                # Check if content was cut off and retry with more tokens if needed
+                if self._is_content_cut_off(content):
+                    logger.info("⚠️ Content appears cut off, retrying with more tokens...")
+                    payload["options"]["num_predict"] = 4000  # Max tokens for Phi-3
+                    retry_result = self._call_ollama_with_retry(payload)
+                    
+                    if retry_result["success"]:
+                        data = retry_result["data"]
+                        content = data['message']['content'].strip()
+                
+                return content
+            else:
+                return f"❌ Phi-3 Error: {result['error']}"
+                
+        except Exception as e:
+            return f"❌ Phi-3 Error: {str(e)}"
+        finally:
+            self.current_requests -= 1
+
+    def _is_content_cut_off(self, content: str) -> bool:
+        """Check if content appears to be cut off mid-sentence"""
+        if not content or len(content.strip()) < 100:
+            return True
+        
+        # Check if it ends with proper punctuation
+        if content.strip().endswith(('.', '!', '?', '."', '!"', '?"')):
+            return False
+        
+        # Check if it ends with incomplete sentence markers
+        if any(content.strip().endswith(marker) for marker in [',', ';', ':', '-', '–', '—']):
+            return True
+        
+        # Check if it ends with an incomplete word or thought
+        last_paragraph = content.strip().split('\n')[-1]
+        if len(last_paragraph.split()) < 5:  # Very short last paragraph
+            return True
+        
+        return False
+    
+    def generate_large_content_with_context(self, prompt: str, user_type: str = "student", 
+                                          academic_level: str = "undergraduate", 
+                                          content_type: str = "simplified_explanation") -> str:
+        """Handle large documents with context preservation"""
+        
+        estimated_tokens = self._estimate_tokens(prompt)
+        
+        if estimated_tokens <= 3000:
+            return self.generate(prompt, user_type, academic_level, content_type)
+        
+        chunks = self._chunk_content(prompt, max_tokens=2500)
+        
+        if len(chunks) > 6:
+            return f"❌ Phi-3 Error: Document too large ({estimated_tokens} tokens, {len(chunks)} chunks). Please use Groq or break into smaller sections."
+        
+        all_results = []
+        previous_summaries = []
+        
+        for i, chunk in enumerate(chunks):
+            logger.info(f"🔄 Processing chunk {i+1}/{len(chunks)} with context...")
+            
+            context_summary = self._create_context_summary(previous_summaries)
+            
+            if context_summary:
+                chunk_prompt = f"""Part {i+1} of {len(chunks)} - Building on previous context:
+
+**PREVIOUS CONTEXT:**
+{context_summary}
+
+**CURRENT SECTION:**
+{chunk}
+
+Analyze this section while connecting to the overall context."""
+            else:
+                chunk_prompt = f"""Part {i+1} of {len(chunks)}:
+
+**CONTENT:**
+{chunk}
+
+Please analyze this section."""
+            
+            chunk_result = self.generate(chunk_prompt, user_type, academic_level, content_type)
+            
+            if "❌ Phi-3 Error:" not in chunk_result:
+                chunk_summary = self._create_chunk_summary(chunk_result)
+                previous_summaries.append(chunk_summary)
+                
+                all_results.append({
+                    "chunk_number": i+1,
+                    "content": chunk_result,
+                    "context_used": bool(context_summary)
+                })
+            else:
+                return f"❌ Phi-3 Error: Failed to process chunk {i+1}: {chunk_result}"
+            
+            if i < len(chunks) - 1:
+                time.sleep(1)
+        
+        # Combine results
+        combined_content = "\n\n".join([f"## Part {r['chunk_number']}\n{r['content']}" for r in all_results])
+        
+        return combined_content
+    
+    def health_check(self) -> Dict:
+        """Comprehensive health check"""
+        if not self.base_url:
+            return {
+                "server_healthy": False,
+                "model_available": False,
+                "error": "Ollama URL not configured"
+            }
+            
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=10)
+            if response.status_code == 200:
+                models = response.json().get('models', [])
+                model_available = any(model['name'] == self.model for model in models)
+                
+                return {
+                    "server_healthy": True,
+                    "model_available": model_available,
+                    "available_models": [model['name'] for model in models],
+                    "model_required": self.model
+                }
+            else:
+                return {
+                    "server_healthy": False,
+                    "model_available": False,
+                    "error": f"Server returned {response.status_code}"
+                }
+        except Exception as e:
+            return {
+                "server_healthy": False,
+                "model_available": False,
+                "error": str(e)
+            }
+    
+    def get_available_models(self):
+        """Get list of available models"""
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=10)
+            if response.status_code == 200:
+                return [model['name'] for model in response.json().get('models', [])]
+            return []
+        except:
+            return []
+    
+    def get_queue_status(self):
+        """Get current queue status"""
+        return {
+            "current_requests": self.current_requests,
+            "max_concurrent": self.max_concurrent,
+            "available_slots": max(0, self.max_concurrent - self.current_requests)
+        }
+
+
+# Backward compatibility
+class GroqGenerator(MultiGroqGenerator):
+    def __init__(self, model="llama-3.3-70b-versatile"):
+        super().__init__()
+
+
+class ModelManager:
+    """Unified model manager that handles both Groq and Phi-3 models"""
+    
+    def __init__(self):
+        self.groq_generator = MultiGroqGenerator()
+        self.phi3_generator = HFGenerator()
+    
+    def generate(self, prompt: str, model_choice: str = "phi3", **kwargs) -> str:
+        """Generate content using selected model"""
+        logger.info(f"🎯 Using model: {model_choice}")
+        
+        if model_choice == "phi3":
+            # Handle Phi-3 generation
+            user_type = kwargs.get('user_type', 'student')
+            academic_level = kwargs.get('student_level', 'undergraduate')
+            content_type = kwargs.get('content_type', 'simplified_explanation')
+            
+            result = self.phi3_generator.generate(prompt, user_type, academic_level, content_type)
+            return result
+        else:
+            # Use Groq for comparison - check if this is a large content request
+            is_large_content = len(prompt) > 8000
+            
+            if is_large_content:
+                return self.groq_generator.generate_large_content(prompt)
+            else:
+                return self.groq_generator.generate(prompt)
+    
+    def get_service_status(self) -> dict:
+        """Get clean research-focused status"""
+        groq_status = self.groq_generator.get_service_status()
+        phi3_health = self.phi3_generator.health_check()
+        
+        # Clean Groq status
+        clean_groq_status = {
+            'healthy_providers': groq_status['healthy_providers'],
+            'total_providers': groq_status['total_providers'],
+            'providers': [
+                {
+                    'name': provider['name'],
+                    'failures': provider['failures']
+                }
+                for provider in groq_status['providers']
+            ]
+        }
+        
+        # Enhanced Phi-3 status
+        enhanced_phi3_status = {
+            'server_healthy': phi3_health['server_healthy'],
+            'model_available': phi3_health['model_available'],
+            'available_models': phi3_health['available_models'],
+            'model_required': phi3_health['model_required']
+        }
+        
+        return {
+            "groq": clean_groq_status,
+            "phi3": enhanced_phi3_status
+        }
+
+
+# Global model manager instance
+model_manager = ModelManager()
+
+
+# Setup function for your Streamlit app
+def setup_generators():
+    """Setup both generators with health checks"""
+    logger.info("🔧 Setting up generators...")
+    
+    groq_generator = MultiGroqGenerator()
+    
+    phi3_generator = HFGenerator()
+    phi3_health = phi3_generator.health_check()
+    
+    logger.info(f"🏥 Phi-3 Health: {phi3_health}")
+    
+    if not phi3_health["server_healthy"]:
+        logger.error("❌ Phi-3 server is not accessible")
+    elif not phi3_health["model_available"]:
+        logger.info("🔄 Phi-3 model needs to be pulled on first use")
+    
+    return {
+        "groq": groq_generator,
+        "phi3": phi3_generator
+    }
+
+
+# Test function
+def test_generators():
+    """Test both generators"""
+    logger.info("🧪 Testing Generators...")
+    
+    generators = setup_generators()
+    
+    # Test Groq
+    logger.info("🔷 Testing Groq...")
+    groq_result = generators["groq"].generate("Explain photosynthesis briefly")
+    if not groq_result.startswith("["):
+        logger.info("✅ Groq working")
+    else:
+        logger.error(f"❌ Groq failed: {groq_result}")
+    
+    # Test Phi-3
+    logger.info("🔶 Testing Phi-3...")
+    phi3_result = generators["phi3"].generate("Explain photosynthesis briefly")
+    if "❌ Phi-3 Error:" not in phi3_result:
+        logger.info("✅ Phi-3 working")
+    else:
+        logger.error(f"❌ Phi-3 failed: {phi3_result}")
+    
+    # Test health
+    logger.info("🏥 Health Check:")
+    logger.info(f"Groq providers: {len(generators['groq'].providers)}")
+    logger.info(f"Phi-3 healthy: {generators['phi3'].health_check()}")
+
+
+if __name__ == "__main__":
+    test_generators()
+
+# import os
+# import time
+# import random
+# import requests
+# from openai import OpenAI
+# from dotenv import load_dotenv
+# from typing import Dict, List
+
+# # Load environment variables once at module level
+# load_dotenv()
+
+# class MultiGroqGenerator:
+#     def __init__(self):
+#         self.providers = self._initialize_groq_providers()
+#         self.models = self._get_best_models()
+#         self.max_retries = 3
+#         self.retry_delay = 2  # seconds
+        
+#     def _initialize_groq_providers(self):
+#         """Initialize multiple Groq API providers with different keys"""
+#         providers = []
+        
+#         # Get all Groq API keys from environment
+#         groq_keys = [
+#             os.getenv("GROQ_API_KEY_1"),
+#             os.getenv("GROQ_API_KEY_2"), 
+#         ]
+        
+#         # Filter out None values and create providers
+#         for i, key in enumerate(groq_keys):
+#             if key and key.strip():
+#                 providers.append({
+#                     'name': f'Groq-{i+1}',
+#                     'client': OpenAI(
+#                         api_key=key.strip(),
+#                         base_url="https://api.groq.com/openai/v1"
+#                     ),
+#                     'weight': 10,
+#                     'fail_count': 0,
+#                     'last_used': 0
+#                 })
+        
+#         if not providers:
+#             raise ValueError("No Groq API keys found. Please set GROQ_API_KEY_1, GROQ_API_KEY_2, etc.")
+            
+#         print(f"✅ Initialized {len(providers)} Groq providers")
+#         return providers
+    
+#     def _get_best_models(self):
+#         """Select optimal models for educational content"""
+#         return [
+#             {
+#                 'id': 'llama-3.3-70b-versatile',
+#                 'name': 'Llama 3.3 70B',
+#                 'weight': 10,
+#                 'max_tokens': 32768,
+#                 'description': 'Best for complex explanations'
+#             },
+#             {
+#                 'id': 'meta-llama/llama-4-maverick-17b-128e-instruct', 
+#                 'name': 'Llama 4 Maverick 17B',
+#                 'weight': 9,
+#                 'max_tokens': 128000,
+#                 'description': 'Large context for big documents'
+#             },
+#             {
+#                 'id': 'llama-3.1-8b-instant',
+#                 'name': 'Llama 3.1 8B Instant',
+#                 'weight': 8,
+#                 'max_tokens': 32768,
+#                 'description': 'Fast for most content'
+#             },
+#         ]
+    
+#     def _select_provider(self):
+#         """Select provider based on weight and fail history"""
+#         available_providers = [
+#             p for p in self.providers 
+#             if p['fail_count'] < 3 and (time.time() - p['last_used']) > 30
+#         ]
+        
+#         if not available_providers:
+#             available_providers = self.providers
+#             for p in available_providers:
+#                 p['fail_count'] = max(0, p['fail_count'] - 1)
+        
+#         weights = [p['weight'] for p in available_providers]
+#         selected = random.choices(available_providers, weights=weights, k=1)[0]
+#         selected['last_used'] = time.time()
+#         return selected
+    
+#     def _select_model(self, prompt_length: int):
+#         """Select optimal model based on prompt size"""
+#         approx_tokens = prompt_length // 4
+        
+#         if approx_tokens > 20000:
+#             return self.models[1]  # Maverick for huge docs
+#         elif approx_tokens > 10000:
+#             return self.models[1]  # Maverick for large docs
+#         elif approx_tokens > 6000:
+#             return self.models[0]  # 70B for medium-large
+#         elif approx_tokens > 3000:
+#             return self.models[0]  # 70B for quality
+#         else:
+#             return self.models[2]  # 8B for speed
+    
+#     def generate(self, prompt: str) -> str:
+#         """Generate content with automatic failover"""
+#         last_error = None
+#         prompt_length = len(prompt)
+        
+#         for attempt in range(self.max_retries + 1):
+#             provider = self._select_provider()
+#             model = self._select_model(prompt_length)
+            
+#             try:
+#                 print(f"🔄 Attempt {attempt + 1} with {provider['name']} using {model['name']}...")
+                
+#                 result = self._call_groq(provider, model, prompt)
+                
+#                 if result and not result.startswith(("[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "[ModelNotFound]")):
+#                     print(f"✅ Success with {provider['name']} + {model['name']}")
+#                     provider['weight'] = min(20, provider['weight'] + 1)
+#                     provider['fail_count'] = max(0, provider['fail_count'] - 1)
+#                     return result
+#                 else:
+#                     print(f"❌ Provider returned: {result}")
+#                     if "[ModelNotFound]" in result:
+#                         continue
+                    
+#             except Exception as e:
+#                 last_error = str(e)
+#                 print(f"❌ {provider['name']} + {model['name']} failed: {last_error}")
+#                 provider['weight'] = max(1, provider['weight'] - 2)
+#                 provider['fail_count'] += 1
+                
+#                 if attempt < self.max_retries:
+#                     delay = self.retry_delay * (2 ** attempt)
+#                     print(f"⏰ Waiting {delay}s before retry...")
+#                     time.sleep(delay)
+        
+#         return self._fallback_generate(prompt)
+    
+#     def generate_large_content(self, prompt: str) -> str:
+#         """Handle large content generation for Groq - compatibility method"""
+#         print("🔷 Using Groq for large content generation...")
+        
+#         # For Groq, we can handle large content directly due to large context windows
+#         # Just use the normal generate method with optimized model selection
+#         prompt_length = len(prompt)
+        
+#         if prompt_length > 20000:  # Very large prompt
+#             print("📝 Large prompt detected, optimizing for Groq Maverick...")
+#             # Temporarily prioritize Maverick for large contexts
+#             original_models = self.models.copy()
+#             self.models = [self.models[1]]  # Maverick has 128K context
+#             try:
+#                 result = self.generate(prompt)
+#                 return result
+#             finally:
+#                 self.models = original_models  # Restore original models
+#         else:
+#             # Use normal generation
+#             return self.generate(prompt)
+    
+#     def _fallback_generate(self, prompt: str) -> str:
+#         """Fallback generation with simpler model selection"""
+#         print("🔄 Trying fallback generation...")
+        
+#         fallback_models = [self.models[2], self.models[0]]
+        
+#         for model in fallback_models:
+#             for provider in self.providers:
+#                 try:
+#                     print(f"🔄 Fallback with {provider['name']} using {model['name']}...")
+#                     result = self._call_groq(provider, model, prompt)
+                    
+#                     if result and not result.startswith(("[Error", "[RateLimit]", "[Quota]", "[Auth]", "[Empty]", "[ModelNotFound]")):
+#                         print(f"✅ Fallback success with {provider['name']} + {model['name']}")
+#                         return result
+#                 except Exception as e:
+#                     print(f"❌ Fallback failed: {e}")
+#                     continue
+        
+#         return self._get_user_friendly_error("All models failed")
+    
+#     def _call_groq(self, provider, model, prompt: str) -> str:
+#         """Call Groq API with specific provider and model"""
+#         try:
+#             prompt_tokens_approx = len(prompt) // 4
+#             available_tokens = model['max_tokens'] - prompt_tokens_approx - 500
+#             max_response_tokens = max(1000, min(8000, available_tokens))
+            
+#             response = provider['client'].chat.completions.create(
+#                 model=model['id'],
+#                 messages=[{"role": "user", "content": prompt}],
+#                 temperature=0.7,
+#                 max_tokens=max_response_tokens,
+#                 top_p=0.9
+#             )
+            
+#             if (response and response.choices and len(response.choices) > 0 and 
+#                 response.choices[0].message and response.choices[0].message.content):
+                
+#                 content = response.choices[0].message.content.strip()
+#                 return content if content else "[Empty] No content generated"
+#             else:
+#                 return "[Empty] Invalid response structure"
+                
+#         except Exception as e:
+#             error_msg = str(e).lower()
+            
+#             if "rate limit" in error_msg or "429" in error_msg:
+#                 return f"[RateLimit] {provider['name']} rate limit exceeded"
+#             elif "quota" in error_msg:
+#                 return f"[Quota] {provider['name']} quota exceeded"
+#             elif "authentication" in error_msg:
+#                 return f"[Auth] {provider['name']} authentication failed"
+#             elif "context length" in error_msg:
+#                 return f"[Length] {provider['name']} content too long"
+#             elif "model not found" in error_msg:
+#                 return f"[ModelNotFound] {provider['name']}: {str(e)}"
+#             else:
+#                 return f"[Error] {provider['name']}: {str(e)}"
+    
+#     def _get_user_friendly_error(self, technical_error: str) -> str:
+#         """Convert technical errors to user-friendly messages"""
+#         error_lower = technical_error.lower()
+        
+#         if "rate limit" in error_lower:
+#             return "🚫 **Service Busy** - Please wait a few minutes and try again"
+#         elif "quota" in error_lower:
+#             return "📊 **Daily Limit Reached** - Try again tomorrow"
+#         elif "length" in error_lower:
+#             return "📝 **Content Too Large** - Please break into smaller sections"
+#         else:
+#             return "❌ **Temporary Issue** - Please try again shortly"
+
+#     def get_service_status(self) -> dict:
+#         """Get current status of all providers"""
+#         status = {
+#             'total_providers': len(self.providers),
+#             'healthy_providers': len([p for p in self.providers if p['fail_count'] < 2]),
+#             'providers': [],
+#             'models': [m['name'] for m in self.models]
+#         }
+        
+#         for provider in self.providers:
+#             if provider['fail_count'] >= 3:
+#                 status_text = "🔴 Limited"
+#             elif provider['fail_count'] >= 1:
+#                 status_text = "🟡 Slow"
+#             else:
+#                 status_text = "🟢 Good"
+                
+#             status['providers'].append({
+#                 'name': provider['name'],
+#                 'status': status_text,
+#                 'failures': provider['fail_count']
+#             })
+        
+#         return status
+
+
+# class HFGenerator:
+#     """Phi-3 Generator with Auto-Pull, Smart Chunking, and Context Preservation"""
+    
+#     def __init__(self, base_url: str = None):
+#         # Use environment variable as default if no base_url provided
+#         self.base_url = base_url or os.getenv("MODEL_URL")
+#         self.model = "phi3:mini"
+#         self.current_requests = 0
+#         self.max_concurrent = 2
+#         self.model_available = False
+#         self._ensure_model_available()
+    
+#     def _ensure_model_available(self):
+#         """Check if model is available and pull if needed"""
+#         try:
+#             response = requests.get(f"{self.base_url}/api/tags", timeout=10)
+#             if response.status_code == 200:
+#                 models = response.json().get('models', [])
+#                 self.model_available = any(model['name'] == self.model for model in models)
+                
+#                 if not self.model_available:
+#                     print(f"🔄 Model {self.model} not found, pulling...")
+#                     self._pull_model()
+#                 else:
+#                     print(f"✅ Model {self.model} is available")
+#             else:
+#                 print(f"❌ Could not check models: {response.status_code}")
+#         except Exception as e:
+#             print(f"❌ Error checking models: {e}")
+    
+#     def _pull_model(self):
+#         """Pull the Phi-3 model if not available"""
+#         try:
+#             print(f"📥 Pulling {self.model}... This may take a few minutes.")
+            
+#             payload = {"name": self.model}
+#             response = requests.post(
+#                 f"{self.base_url}/api/pull", 
+#                 json=payload, 
+#                 timeout=300  # 5 minute timeout for pull
+#             )
+            
+#             if response.status_code == 200:
+#                 print(f"✅ Successfully pulled {self.model}")
+#                 self.model_available = True
+#                 return True
+#             else:
+#                 print(f"❌ Failed to pull model: {response.text}")
+#                 return False
+                
+#         except Exception as e:
+#             print(f"❌ Error pulling model: {e}")
+#             return False
+    
+#     def _estimate_tokens(self, text: str) -> int:
+#         """Rough token estimation"""
+#         return len(text) // 4
+    
+#     def _chunk_content(self, content: str, max_tokens: int = 2500) -> list:
+#         """Split large content into manageable chunks"""
+#         paragraphs = content.split('\n\n')
+#         chunks = []
+#         current_chunk = ""
+#         current_tokens = 0
+        
+#         for paragraph in paragraphs:
+#             para_tokens = self._estimate_tokens(paragraph)
+            
+#             if para_tokens > max_tokens:
+#                 sentences = paragraph.split('. ')
+#                 for sentence in sentences:
+#                     sent_tokens = self._estimate_tokens(sentence)
+#                     if current_tokens + sent_tokens > max_tokens:
+#                         if current_chunk:
+#                             chunks.append(current_chunk.strip())
+#                         current_chunk = sentence
+#                         current_tokens = sent_tokens
+#                     else:
+#                         current_chunk += " " + sentence
+#                         current_tokens += sent_tokens
+#             else:
+#                 if current_tokens + para_tokens > max_tokens:
+#                     if current_chunk:
+#                         chunks.append(current_chunk.strip())
+#                     current_chunk = paragraph
+#                     current_tokens = para_tokens
+#                 else:
+#                     current_chunk += "\n\n" + paragraph
+#                     current_tokens += para_tokens
+        
+#         if current_chunk:
+#             chunks.append(current_chunk.strip())
+            
+#         return chunks
+    
+#     def _create_context_summary(self, previous_chunks: list) -> str:
+#         """Create a context summary from previous chunks"""
+#         if not previous_chunks:
+#             return ""
+        
+#         context_prompt = f"""
+#         Here's a summary of previous sections:
+#         {chr(10).join(previous_chunks)}
+        
+#         Provide a brief summary (2-3 sentences) of key points to help understand the next section.
+#         """
+        
+#         try:
+#             payload = {
+#                 "model": self.model,
+#                 "messages": [{"role": "user", "content": context_prompt}],
+#                 "stream": False,
+#                 "options": {
+#                     "temperature": 0.3,
+#                     "top_p": 0.8,
+#                     "num_predict": 200
+#                 }
+#             }
+            
+#             response = requests.post(f"{self.base_url}/api/chat", json=payload, timeout=30)
+#             if response.status_code == 200:
+#                 return response.json()['message']['content'].strip()
+#             return f"Previous sections covered: {', '.join(previous_chunks[:2])}..."
+#         except Exception:
+#             return f"Context from {len(previous_chunks)} previous sections"
+    
+#     def _create_chunk_summary(self, content: str) -> str:
+#         """Create a very brief summary of a chunk's content"""
+#         try:
+#             payload = {
+#                 "model": self.model,
+#                 "messages": [{"role": "user", "content": f"Summarize key points in 1-2 sentences: {content}"}],
+#                 "stream": False,
+#                 "options": {
+#                     "temperature": 0.3,
+#                     "top_p": 0.8,
+#                     "num_predict": 100
+#                 }
+#             }
+            
+#             response = requests.post(f"{self.base_url}/api/chat", json=payload, timeout=20)
+#             if response.status_code == 200:
+#                 return response.json()['message']['content'].strip()
+#             return content[:100] + "..."
+#         except:
+#             return content[:100] + "..."
+    
+#     def _call_ollama_with_retry(self, payload: dict, max_retries: int = 2) -> Dict:
+#         """Call Ollama API with auto-pull retry"""
+#         for attempt in range(max_retries + 1):
+#             try:
+#                 response = requests.post(
+#                     f"{self.base_url}/api/chat",
+#                     json=payload,
+#                     timeout=60
+#                 )
+                
+#                 if response.status_code == 200:
+#                     return {"success": True, "data": response.json()}
+#                 elif response.status_code == 404 and "not found" in response.text.lower():
+#                     print(f"🔄 Model not found, attempting to pull... (attempt {attempt + 1})")
+#                     if self._pull_model():
+#                         continue  # Retry after successful pull
+#                     else:
+#                         return {"success": False, "error": "Failed to pull model"}
+#                 else:
+#                     return {"success": False, "error": f"API error {response.status_code}: {response.text}"}
+                    
+#             except requests.exceptions.Timeout:
+#                 if attempt < max_retries:
+#                     print(f"⏰ Timeout, retrying... (attempt {attempt + 1})")
+#                     time.sleep(2)
+#                 else:
+#                     return {"success": False, "error": "Request timeout"}
+#             except Exception as e:
+#                 return {"success": False, "error": f"Connection failed: {str(e)}"}
+        
+#         return {"success": False, "error": "All retries failed"}
+    
+#     def generate(self, prompt: str, user_type: str = "student", 
+#                  academic_level: str = "undergraduate", 
+#                  content_type: str = "simplified_explanation") -> str:
+#         """Generate educational content with auto-pull and smart features - FIXED to return string"""
+        
+#         # Check if we need to pull model first
+#         if not self.model_available:
+#             print("🔄 Model not available, pulling before generation...")
+#             if not self._pull_model():
+#                 return f"❌ Phi-3 Error: Phi-3 model is not available and failed to pull. Please check the Ollama server."
+        
+#         estimated_tokens = self._estimate_tokens(prompt)
+        
+#         # Auto-detect large documents and use chunking
+#         if estimated_tokens > 3000:
+#             result = self.generate_large_content_with_context(prompt, user_type, academic_level, content_type)
+#             if isinstance(result, dict):
+#                 return result.get("content", f"❌ Phi-3 Error: {result.get('error', 'Unknown error')}")
+#             return result
+        
+#         # Queue management
+#         if self.current_requests >= self.max_concurrent:
+#             queue_position = self.current_requests - self.max_concurrent + 1
+#             estimated_wait = queue_position * 7
+#             return f"❌ Phi-3 Error: Service busy. You're #{queue_position} in queue (~{estimated_wait}s)"
+        
+#         self.current_requests += 1
+#         try:
+#             # Use the prompt directly without adding instructional wrapper
+#             # The prompts from tutor_flow and student_flow now tell it to generate content directly
+            
+#             # FIXED: Increased token allocation for complete responses
+#             if estimated_tokens > 2000:
+#                 max_output_tokens = 2000  # Increased from 500
+#             elif estimated_tokens > 1000:
+#                 max_output_tokens = 2500  # Increased from 800
+#             else:
+#                 max_output_tokens = 3000  # Increased from 1000
+            
+#             payload = {
+#                 "model": self.model,
+#                 "messages": [{"role": "user", "content": prompt}],
+#                 "stream": False,
+#                 "options": {
+#                     "temperature": 0.7,
+#                     "top_p": 0.9,
+#                     "num_predict": max_output_tokens
+#                 }
+#             }
+            
+#             start_time = time.time()
+#             result = self._call_ollama_with_retry(payload)
+#             inference_time = time.time() - start_time
+            
+#             if result["success"]:
+#                 data = result["data"]
+#                 content = data['message']['content'].strip()
+                
+#                 # Check if content was cut off and retry with more tokens if needed
+#                 if self._is_content_cut_off(content):
+#                     print("⚠️ Content appears cut off, retrying with more tokens...")
+#                     payload["options"]["num_predict"] = 4000  # Max tokens for Phi-3
+#                     retry_result = self._call_ollama_with_retry(payload)
+                    
+#                     if retry_result["success"]:
+#                         data = retry_result["data"]
+#                         content = data['message']['content'].strip()
+                
+#                 return content
+#             else:
+#                 return f"❌ Phi-3 Error: {result['error']}"
+                
+#         except Exception as e:
+#             return f"❌ Phi-3 Error: {str(e)}"
+#         finally:
+#             self.current_requests -= 1
+
+#     def _is_content_cut_off(self, content: str) -> bool:
+#         """Check if content appears to be cut off mid-sentence"""
+#         if not content or len(content.strip()) < 100:
+#             return True
+        
+#         # Check if it ends with proper punctuation
+#         if content.strip().endswith(('.', '!', '?', '."', '!"', '?"')):
+#             return False
+        
+#         # Check if it ends with incomplete sentence markers
+#         if any(content.strip().endswith(marker) for marker in [',', ';', ':', '-', '–', '—']):
+#             return True
+        
+#         # Check if it ends with an incomplete word or thought
+#         last_paragraph = content.strip().split('\n')[-1]
+#         if len(last_paragraph.split()) < 5:  # Very short last paragraph
+#             return True
+        
+#         return False
+    
+#     def generate_large_content_with_context(self, prompt: str, user_type: str = "student", 
+#                                           academic_level: str = "undergraduate", 
+#                                           content_type: str = "simplified_explanation") -> str:
+#         """Handle large documents with context preservation - FIXED to return string"""
+        
+#         estimated_tokens = self._estimate_tokens(prompt)
+        
+#         if estimated_tokens <= 3000:
+#             return self.generate(prompt, user_type, academic_level, content_type)
+        
+#         chunks = self._chunk_content(prompt, max_tokens=2500)
+        
+#         if len(chunks) > 6:
+#             return f"❌ Phi-3 Error: Document too large ({estimated_tokens} tokens, {len(chunks)} chunks). Please use Groq or break into smaller sections."
+        
+#         all_results = []
+#         previous_summaries = []
+        
+#         for i, chunk in enumerate(chunks):
+#             print(f"🔄 Processing chunk {i+1}/{len(chunks)} with context...")
+            
+#             context_summary = self._create_context_summary(previous_summaries)
+            
+#             if context_summary:
+#                 chunk_prompt = f"""Part {i+1} of {len(chunks)} - Building on previous context:
+
+# **PREVIOUS CONTEXT:**
+# {context_summary}
+
+# **CURRENT SECTION:**
+# {chunk}
+
+# Analyze this section while connecting to the overall context."""
+#             else:
+#                 chunk_prompt = f"""Part {i+1} of {len(chunks)}:
+
+# **CONTENT:**
+# {chunk}
+
+# Please analyze this section."""
+            
+#             chunk_result = self.generate(chunk_prompt, user_type, academic_level, content_type)
+            
+#             if "❌ Phi-3 Error:" not in chunk_result:
+#                 chunk_summary = self._create_chunk_summary(chunk_result)
+#                 previous_summaries.append(chunk_summary)
+                
+#                 all_results.append({
+#                     "chunk_number": i+1,
+#                     "content": chunk_result,
+#                     "context_used": bool(context_summary)
+#                 })
+#             else:
+#                 return f"❌ Phi-3 Error: Failed to process chunk {i+1}: {chunk_result}"
+            
+#             if i < len(chunks) - 1:
+#                 time.sleep(1)
+        
+#         # Combine results
+#         combined_content = "\n\n".join([f"## Part {r['chunk_number']}\n{r['content']}" for r in all_results])
+        
+#         return combined_content
+    
+#     def health_check(self) -> Dict:
+#         """Comprehensive health check"""
+#         try:
+#             response = requests.get(f"{self.base_url}/api/tags", timeout=10)
+#             if response.status_code == 200:
+#                 models = response.json().get('models', [])
+#                 model_available = any(model['name'] == self.model for model in models)
+                
+#                 return {
+#                     "server_healthy": True,
+#                     "model_available": model_available,
+#                     "available_models": [model['name'] for model in models],
+#                     "model_required": self.model
+#                 }
+#             else:
+#                 return {
+#                     "server_healthy": False,
+#                     "model_available": False,
+#                     "error": f"Server returned {response.status_code}"
+#                 }
+#         except Exception as e:
+#             return {
+#                 "server_healthy": False,
+#                 "model_available": False,
+#                 "error": str(e)
+#             }
+    
+#     def get_available_models(self):
+#         """Get list of available models"""
+#         try:
+#             response = requests.get(f"{self.base_url}/api/tags", timeout=10)
+#             if response.status_code == 200:
+#                 return [model['name'] for model in response.json().get('models', [])]
+#             return []
+#         except:
+#             return []
+    
+#     def get_queue_status(self):
+#         """Get current queue status"""
+#         return {
+#             "current_requests": self.current_requests,
+#             "max_concurrent": self.max_concurrent,
+#             "available_slots": max(0, self.max_concurrent - self.current_requests)
+#         }
+
+
+# # Backward compatibility
+# class GroqGenerator(MultiGroqGenerator):
+#     def __init__(self, model="llama-3.3-70b-versatile"):
+#         super().__init__()
+
+
+# class ModelManager:
+#     """Unified model manager that handles both Groq and Phi-3 models"""
+    
+#     def __init__(self):
+#         self.groq_generator = MultiGroqGenerator()
+#         self.phi3_generator = HFGenerator()
+    
+#     def generate(self, prompt: str, model_choice: str = "phi3", **kwargs) -> str:
+#         """Generate content using selected model"""
+#         print(f"🎯 Using model: {model_choice}")
+        
+#         if model_choice == "phi3":
+#             # Handle Phi-3 generation - FIXED: Now returns string directly
+#             user_type = kwargs.get('user_type', 'student')
+#             academic_level = kwargs.get('student_level', 'undergraduate')
+#             content_type = kwargs.get('content_type', 'simplified_explanation')
+            
+#             result = self.phi3_generator.generate(prompt, user_type, academic_level, content_type)
+#             return result
+#         else:
+#             # Use Groq for comparison - check if this is a large content request
+#             is_large_content = len(prompt) > 8000  # You can adjust this threshold
+            
+#             if is_large_content:
+#                 return self.groq_generator.generate_large_content(prompt)
+#             else:
+#                 return self.groq_generator.generate(prompt)
+    
+#     def get_service_status(self) -> dict:
+#         """Get clean research-focused status"""
+#         groq_status = self.groq_generator.get_service_status()
+#         phi3_health = self.phi3_generator.health_check()
+        
+#         # Clean Groq status - remove model names, focus on providers
+#         clean_groq_status = {
+#             'healthy_providers': groq_status['healthy_providers'],
+#             'total_providers': groq_status['total_providers'],
+#             'providers': [
+#                 {
+#                     'name': provider['name'],
+#                     'failures': provider['failures']
+#                 }
+#                 for provider in groq_status['providers']
+#             ]
+#         }
+        
+#         # Enhanced Phi-3 status
+#         enhanced_phi3_status = {
+#             'server_healthy': phi3_health['server_healthy'],
+#             'model_available': phi3_health['model_available'],
+#             'available_models': phi3_health['available_models'],
+#             'model_required': phi3_health['model_required']
+#         }
+        
+#         return {
+#             "groq": clean_groq_status,
+#             "phi3": enhanced_phi3_status
+#         }
+
+
+# # Global model manager instance
+# model_manager = ModelManager()
+
+
+# # Setup function for your Streamlit app
+# def setup_generators():
+#     """Setup both generators with health checks"""
+#     print("🔧 Setting up generators...")
+    
+#     groq_generator = MultiGroqGenerator()
+    
+#     phi3_generator = HFGenerator()
+#     phi3_health = phi3_generator.health_check()
+    
+#     print(f"🏥 Phi-3 Health: {phi3_health}")
+    
+#     if not phi3_health["server_healthy"]:
+#         print("❌ Phi-3 server is not accessible")
+#     elif not phi3_health["model_available"]:
+#         print("🔄 Phi-3 model needs to be pulled on first use")
+    
+#     return {
+#         "groq": groq_generator,
+#         "phi3": phi3_generator
+#     }
+
+
+# # Test function
+# def test_generators():
+#     """Test both generators"""
+#     print("🧪 Testing Generators...")
+    
+#     generators = setup_generators()
+    
+#     # Test Groq
+#     print("\n🔷 Testing Groq...")
+#     groq_result = generators["groq"].generate("Explain photosynthesis briefly")
+#     if not groq_result.startswith("["):
+#         print("✅ Groq working")
+#     else:
+#         print("❌ Groq failed:", groq_result)
+    
+#     # Test Phi-3
+#     print("\n🔶 Testing Phi-3...")
+#     phi3_result = generators["phi3"].generate("Explain photosynthesis briefly")
+#     if "❌ Phi-3 Error:" not in phi3_result:
+#         print("✅ Phi-3 working")
+#     else:
+#         print("❌ Phi-3 failed:", phi3_result)
+    
+#     # Test health
+#     print("\n🏥 Health Check:")
+#     print(f"Groq providers: {len(generators['groq'].providers)}")
+#     print(f"Phi-3 healthy: {generators['phi3'].health_check()}")
+
+
+# if __name__ == "__main__":
+#     test_generators()

simulate_adapt.py

@@ -0,0 +1,116 @@
+def adjust_prompt(original_prompt, complexity=None, clarity=None, depth=None, user_type=None, student_level=None, comments=""):
+    """
+    Enhanced prompt adjustment based on user feedback
+    """
+    
+    adjustments = []
+    new_prompt = original_prompt
+    
+    # Priority 1: Complexity adjustments (most impactful)
+    if complexity == "Too complex":
+        adjustments.append("simplified language and added analogies")
+        if user_type == "student":
+            new_prompt = f"Explain this in simpler, more beginner-friendly terms with practical examples and everyday analogies: {original_prompt}"
+        else:
+            new_prompt = f"Create a more accessible version suitable for {student_level} students with clear examples: {original_prompt}"
+            
+    elif complexity == "Too simple":
+        adjustments.append("added technical depth and advanced concepts")
+        new_prompt = f"Expand this with more technical details, deeper insights, and advanced applications while maintaining clarity: {original_prompt}"
+
+    # Priority 2: Use specific comments if available (most targeted)
+    elif comments and len(comments.strip()) > 10:
+        # Extract key requests from user comments
+        user_requests = extract_requests_from_comments(comments)
+        if user_requests:
+            adjustments.append(f"addressed: {', '.join(user_requests)}")
+            new_prompt = f"{original_prompt}. Specifically: {', '.join(user_requests)}"
+    
+    # Priority 3: Clarity adjustments
+    elif clarity and clarity <= 2:
+        adjustments.append("improved structure and clarity")
+        new_prompt = f"Make this extremely clear and well-structured with step-by-step explanation and better organization: {original_prompt}"
+    
+    # Priority 4: Depth adjustments  
+    elif depth and depth <= 2:
+        adjustments.append("added foundational content")
+        new_prompt = f"Provide more basic foundation, introductory content, and build up gradually: {original_prompt}"
+    
+    elif depth and depth >= 4:
+        adjustments.append("included advanced insights")
+        new_prompt = f"Include more advanced insights, real-world applications, case studies, and deeper analysis: {original_prompt}"
+    
+    # Priority 5: General improvement fallback
+    elif complexity or clarity or depth:
+        adjustments.append("general improvements based on feedback")
+        new_prompt = f"Improve this content to be more effective for learning: {original_prompt}"
+    
+    # Always add learning level context
+    if student_level and student_level != "Unknown":
+        if "suitable for" not in new_prompt and f"for {student_level}" not in new_prompt:
+            new_prompt = f"{new_prompt} - Tailor specifically for {student_level} level understanding"
+    
+    print(f"🔄 Adaptation applied: {adjustments}")
+    return new_prompt
+
+def extract_requests_from_comments(comments):
+    """Extract specific requests from user comments"""
+    requests = []
+    comment_lower = comments.lower()
+    
+    # Look for specific requests in comments
+    if any(word in comment_lower for word in ['example', 'examples']):
+        requests.append("more practical examples")
+    
+    if any(word in comment_lower for word in ['confusing', 'unclear', 'hard to understand']):
+        requests.append("clearer explanations")
+    
+    if any(word in comment_lower for word in ['analogy', 'metaphor', 'comparison']):
+        requests.append("better analogies")
+    
+    if any(word in comment_lower for word in ['step by step', 'step-by-step', 'break down']):
+        requests.append("step-by-step breakdown")
+    
+    if any(word in comment_lower for word in ['real world', 'real-world', 'practical']):
+        requests.append("real-world applications")
+    
+    if any(word in comment_lower for word in ['visual', 'diagram', 'chart']):
+        requests.append("visual explanations")
+    
+    return requests
+
+def get_adaptation_explanation(complexity, clarity, depth, comments=""):
+    """Generate a user-friendly explanation of what adaptations were made"""
+    explanations = []
+    
+    # Use comments for most specific explanations
+    if comments and len(comments.strip()) > 10:
+        user_requests = extract_requests_from_comments(comments)
+        if user_requests:
+            explanations.append(f"• Addressed your specific requests: {', '.join(user_requests)}")
+    
+    # Fall back to rating-based explanations
+    if not explanations:
+        if complexity == "Too complex":
+            explanations.append("• Simplified language and added everyday analogies")
+        elif complexity == "Too simple":
+            explanations.append("• Added more technical depth and advanced concepts")
+        
+        if clarity and clarity <= 2:
+            explanations.append("• Improved structure with step-by-step explanations")
+        elif clarity and clarity >= 4:
+            explanations.append("• Maintained the clear structure you liked")
+        
+        if depth and depth <= 2:
+            explanations.append("• Added more foundational content and basics")
+        elif depth and depth >= 4:
+            explanations.append("• Included advanced insights and applications")
+    
+    # Final fallback
+    if not explanations:
+        if comments:
+            explanations.append("• Incorporated your detailed feedback")
+        else:
+            explanations.append("• Made general improvements based on your ratings")
+    
+    return "\n".join(explanations)