Update app.py

app.py

@@ -1,5 +1,6 @@
 """
-StudyFlow AI Backend - Complete Working Version with REAL Question Generation
+StudyFlow AI Backend - AI-Powered Question Generation
+Uses Hugging Face Inference API for intelligent question generation
 """
 import os
 import json
@@ -7,17 +8,18 @@ import sqlite3
 import hashlib
 import tempfile
 import re
+import requests
 from datetime import datetime
-from typing import List, Dict
-
+from typing import List, Dict, Optional
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from fastapi.responses import JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 import PyPDF2
 from youtube_transcript_api import YouTubeTranscriptApi
 
 # Initialize FastAPI
-app = FastAPI(title="StudyFlow AI", version="2.0.0")
+app = FastAPI(title="StudyFlow AI", version="3.0.0")
 
 # CORS middleware
 app.add_middleware(
@@ -28,104 +30,68 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Database setup - FIXED: Create data directory if it doesn't exist
-DB_DIR = "/data" if os.path.exists("/data") else os.path.dirname(os.path.abspath(__file__))
-if not os.path.exists(DB_DIR):
-    os.makedirs(DB_DIR, exist_ok=True)
-DB_PATH = os.path.join(DB_DIR, "studyflow.db")
+# Hugging Face API configuration
+HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
+HF_API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2"
 
-print(f"📁 Database path: {DB_PATH}")
+# Database setup
+DB_PATH = "/data/studyflow.db" if os.path.exists("/data") else "studyflow.db"
 
 def init_db():
     """Initialize SQLite database"""
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        
-        # Sessions table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS sessions (
-                id TEXT PRIMARY KEY,
-                title TEXT NOT NULL,
-                content_type TEXT NOT NULL,
-                difficulty TEXT NOT NULL,
-                content_hash TEXT,
-                raw_content TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )
-        ''')
-        
-        # Questions table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS questions (
-                id TEXT PRIMARY KEY,
-                session_id TEXT NOT NULL,
-                question_text TEXT NOT NULL,
-                question_type TEXT NOT NULL,
-                options TEXT,
-                correct_answer TEXT NOT NULL,
-                difficulty TEXT NOT NULL,
-                explanation TEXT,
-                user_answer TEXT,
-                is_correct INTEGER DEFAULT 0,
-                time_spent INTEGER DEFAULT 0,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
-            )
-        ''')
-        
-        # Flashcards table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS flashcards (
-                id TEXT PRIMARY KEY,
-                session_id TEXT NOT NULL,
-                front TEXT NOT NULL,
-                back TEXT NOT NULL,
-                category TEXT,
-                difficulty TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
-            )
-        ''')
-        
-        # Notes table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS notes (
-                id TEXT PRIMARY KEY,
-                session_id TEXT NOT NULL,
-                title TEXT NOT NULL,
-                content TEXT NOT NULL,
-                tags TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
-            )
-        ''')
-        
-        # Highlights table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS highlights (
-                id TEXT PRIMARY KEY,
-                session_id TEXT NOT NULL,
-                text TEXT NOT NULL,
-                context TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
-            )
-        ''')
-        
-        conn.commit()
-        conn.close()
-        print("✅ Database initialized successfully")
-        return True
-    except Exception as e:
-        print(f"❌ Database initialization error: {str(e)}")
-        return False
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Sessions table with page selections
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL,
+            content_type TEXT NOT NULL,
+            difficulty TEXT NOT NULL,
+            content_hash TEXT,
+            selected_pages TEXT,
+            total_pages INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            last_accessed TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    # Questions table
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS questions (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            question_text TEXT NOT NULL,
+            question_type TEXT NOT NULL,
+            options TEXT,
+            correct_answer TEXT NOT NULL,
+            difficulty TEXT NOT NULL,
+            explanation TEXT,
+            user_answer TEXT,
+            is_correct INTEGER DEFAULT 0,
+            time_spent INTEGER DEFAULT 0,
+            page_reference INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
+        )
+    ''')
+    
+    # Pages table for PDF page content
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS pages (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            page_number INTEGER NOT NULL,
+            content TEXT NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
 
-# Initialize database
-if not init_db():
-    print("⚠️ Warning: Database initialization failed, using in-memory fallback")
+init_db()
 
 def generate_id(text: str = None):
     """Generate a unique ID"""
@@ -134,24 +100,20 @@ def generate_id(text: str = None):
         return hashlib.md5(text.encode()).hexdigest()[:12]
     return str(uuid.uuid4())[:12]
 
-def extract_text_from_pdf(file_path: str) -> str:
-    """Extract text from PDF file"""
+def extract_text_from_pdf(file_path: str) -> Dict[int, str]:
+    """Extract text from PDF file and return pages dictionary"""
+    pages_text = {}
     try:
         with open(file_path, 'rb') as file:
             pdf_reader = PyPDF2.PdfReader(file)
-            text = ""
-            for page_num, page in enumerate(pdf_reader.pages[:15]):  # First 15 pages
-                try:
-                    page_text = page.extract_text()
-                    if page_text:
-                        text += page_text + "\n"
-                except Exception as e:
-                    print(f"Error extracting page {page_num}: {str(e)}")
-                    continue
-        return text[:15000]  # Limit text length
+            for page_num, page in enumerate(pdf_reader.pages, start=1):
+                page_text = page.extract_text()
+                if page_text and len(page_text.strip()) > 50:
+                    pages_text[page_num] = page_text.strip()
+        return pages_text
     except Exception as e:
         print(f"PDF extraction error: {str(e)}")
-        return ""
+        return {}
 
 def extract_text_from_youtube(url: str) -> str:
     """Extract transcript from YouTube video"""
@@ -164,180 +126,182 @@ def extract_text_from_youtube(url: str) -> str:
             return ""
         
         transcript = YouTubeTranscriptApi.get_transcript(video_id)
-        text = " ".join([entry['text'] for entry in transcript[:50]])  # First 50 entries
-        return text[:15000]
+        text = " ".join([entry['text'] for entry in transcript])
+        return text
     except Exception as e:
         print(f"YouTube extraction error: {str(e)}")
         return ""
 
-def extract_key_concepts(text: str, count: int = 8) -> List[str]:
-    """Extract key concepts from text using NLP-like approach"""
+def call_hf_api(prompt: str, max_length: int = 500) -> Optional[str]:
+    """Call Hugging Face API for AI-powered question generation"""
+    if not HF_API_TOKEN:
+        return None
+    
     try:
-        # Clean text
-        text = text.lower()
-        
-        # Remove common stop words
-        stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'but', 'so', 'if', 'then', 'else', 'when', 'where', 'which', 'what', 'who', 'whom', 'this', 'that', 'these', 'those', 'it', 'they', 'we', 'you', 'he', 'she', 'it', 'them', 'her', 'him', 'us'}
-        
-        # Split into words and count frequencies
-        words = re.findall(r'\b[a-z]{4,}\b', text)
-        freq = {}
-        for word in words:
-            if word not in stop_words:
-                freq[word] = freq.get(word, 0) + 1
-        
-        # Get top words as concepts
-        sorted_words = sorted(freq.items(), key=lambda x: x[1], reverse=True)
-        concepts = [word for word, _ in sorted_words[:count]]
-        
-        # Also extract phrases (2-3 word sequences)
-        phrases = re.findall(r'\b[a-z]{3,}\s+[a-z]{3,}\b', text)
-        phrase_freq = {}
-        for phrase in phrases[:50]:
-            phrase_freq[phrase] = phrase_freq.get(phrase, 0) + 1
-        
-        top_phrases = sorted(phrase_freq.items(), key=lambda x: x[1], reverse=True)[:3]
-        concepts.extend([phrase for phrase, _ in top_phrases])
-        
-        # Remove duplicates and limit
-        unique_concepts = []
-        for concept in concepts:
-            if concept not in unique_concepts:
-                unique_concepts.append(concept)
-        
-        return unique_concepts[:count] if unique_concepts else ["Key Concept", "Main Idea", "Important Topic"]
+        headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": max_length,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "do_sample": True
+            }
+        }
+        response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=30)
+        if response.status_code == 200:
+            result = response.json()
+            return result[0].get("generated_text", "")
+        return None
     except Exception as e:
-        print(f"Concept extraction error: {str(e)}")
-        return ["Key Concept", "Main Idea", "Important Topic"]
+        print(f"HF API error: {str(e)}")
+        return None
 
-def generate_questions_from_content(text: str, difficulty: str, count: int = 5) -> List[Dict]:
-    """Generate REAL questions based on the actual content"""
-    try:
-        # Clean and prepare text
-        text = text.replace('\n', ' ').strip()
-        sentences = re.split(r'[.!?]+', text)
-        sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
-        
-        if len(sentences) < 3:
-            # Fallback for very short text
-            sentences = [s for s in text.split('.') if len(s.strip()) > 20][:5]
-        
-        concepts = extract_key_concepts(text, 6)
-        questions = []
-        
-        for i in range(min(count, len(sentences))):
-            sentence = sentences[i]
-            qid = generate_id(f"q_{i}_{difficulty}")
-            
-            if difficulty == "easy":
-                # Fill in the blank with a key word from the sentence
-                words = sentence.split()
-                if len(words) > 4:
-                    # Find a meaningful word to blank out
-                    blank_pos = min(len(words) - 3, max(2, len(words) // 2))
-                    blank_word = words[blank_pos]
-                    question_text = sentence.replace(blank_word, "_______", 1)
-                    
-                    questions.append({
-                        "id": qid,
-                        "question_text": f"Complete this sentence: {question_text}",
-                        "question_type": "fill_blank",
-                        "options": None,
-                        "correct_answer": blank_word,
-                        "difficulty": "easy",
-                        "explanation": f"The word '{blank_word}' is key to this sentence.",
-                        "concept": concepts[i % len(concepts)] if concepts else "Key Concept"
-                    })
-                else:
-                    # Short sentence - use true/false
+def generate_questions_with_ai(content: str, difficulty: str, count: int, page_ref: int = None) -> List[Dict]:
+    """Generate intelligent questions using AI"""
+    
+    # Build prompt for AI
+    difficulty_prompts = {
+        "easy": "Generate basic recall and definition questions that test understanding of key terms and simple facts.",
+        "medium": "Generate conceptual questions that test understanding of relationships, causes, effects, and comparisons.",
+        "hard": "Generate analytical questions that require critical thinking, application, evaluation, and synthesis of ideas."
+    }
+    
+    prompt = f"""You are an expert educator creating study questions. Based on the following text, generate {count} {difficulty}-level questions.
+
+{difficulty_prompts[difficulty]}
+
+For each question, provide:
+1. The question text
+2. Question type (multiple_choice, true_false, or short_answer)
+3. For multiple choice: 4 options (A, B, C, D) with one correct
+4. For true/false: the correct answer
+5. For short answer: a model answer
+6. A brief explanation of why the answer is correct
+
+Format your response as JSON array:
+[
+  {{
+    "text": "question text",
+    "type": "multiple_choice",
+    "options": ["option1", "option2", "option3", "option4"],
+    "correct_answer": "the correct option text",
+    "explanation": "explanation here"
+  }}
+]
+
+TEXT CONTENT:
+{content[:3000]}
+
+Generate {count} questions in JSON format:"""
+
+    ai_response = call_hf_api(prompt, 2000)
+    
+    if ai_response:
+        try:
+            # Extract JSON from response
+            json_match = re.search(r'\[[\s\S]*\]', ai_response)
+            if json_match:
+                questions_data = json.loads(json_match.group())
+                questions = []
+                for i, q_data in enumerate(questions_data[:count]):
                     questions.append({
-                        "id": qid,
-                        "question_text": sentence[:200],
-                        "question_type": "true_false",
-                        "options": None,
-                        "correct_answer": "True",
-                        "difficulty": "easy",
-                        "explanation": "This statement appears in the study material.",
-                        "concept": concepts[i % len(concepts)] if concepts else "Key Concept"
+                        "id": generate_id(f"q_{i}"),
+                        "question_text": q_data.get("text", ""),
+                        "question_type": q_data.get("type", "short_answer"),
+                        "options": json.dumps(q_data.get("options", [])) if q_data.get("options") else None,
+                        "correct_answer": q_data.get("correct_answer", ""),
+                        "difficulty": difficulty,
+                        "explanation": q_data.get("explanation", "Review the material for this answer."),
+                        "page_reference": page_ref
                     })
-            
-            elif difficulty == "medium":
-                # Multiple choice based on content
-                concept = concepts[i % len(concepts)] if concepts else "the topic"
-                
-                # Generate plausible distractors
-                other_concepts = [c for c in concepts if c != concept][:3]
-                while len(other_concepts) < 3:
-                    other_concepts.extend(["Important detail", "Background information", "Supporting example"])
-                
-                options = [f"{concept}", f"{other_concepts[0]}", f"{other_concepts[1]}", f"{other_concepts[2]}"]
-                
-                questions.append({
-                    "id": qid,
-                    "question_text": f"What is the main idea expressed here: '{sentence[:150]}...'?",
-                    "question_type": "multiple_choice",
-                    "options": json.dumps(options),
-                    "correct_answer": options[0],
-                    "difficulty": "medium",
-                    "explanation": f"The text emphasizes {concept} as a central theme.",
-                    "concept": concept
-                })
-            
-            else:  # hard
-                # Short answer requiring deeper understanding
-                concept = concepts[i % len(concepts)] if concepts else "key concept"
-                
-                questions.append({
-                    "id": qid,
-                    "question_text": f"Explain the significance of '{concept}' based on: '{sentence[:200]}...'",
-                    "question_type": "short_answer",
-                    "options": None,
-                    "correct_answer": f"The passage presents '{concept}' as an important element in the material.",
-                    "difficulty": "hard",
-                    "explanation": "Focus on how key concepts connect to each other.",
-                    "concept": concept
-                })
+                if questions:
+                    return questions
+        except:
+            pass
+    
+    # Fallback to intelligent template-based generation
+    return generate_questions_fallback(content, difficulty, count, page_ref)
+
+def generate_questions_fallback(content: str, difficulty: str, count: int, page_ref: int = None) -> List[Dict]:
+    """Enhanced fallback question generation with better intelligence"""
+    
+    # Extract sentences, facts, and concepts
+    sentences = re.split(r'[.!?]+', content)
+    sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
+    
+    # Extract numbers/dates
+    numbers = re.findall(r'\b\d{4}\b|\b\d+\.\d+\b|\b\d+%\b|\b\d+\s+(?:percent|million|billion|thousand)\b', content)
+    
+    # Extract proper nouns (potential key terms)
+    proper_nouns = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', content)
+    
+    questions = []
+    
+    for i in range(min(count, max(len(sentences), 5))):
+        sentence = sentences[i % len(sentences)] if sentences else content[:200]
+        qid = generate_id(f"q_{i}")
         
-        # If we couldn't generate enough questions, add some general ones
-        while len(questions) < count:
-            concept = concepts[len(questions) % len(concepts)] if concepts else "the material"
-            qid = generate_id(f"q_gen_{len(questions)}")
+        if difficulty == "easy" and len(numbers) > 0:
+            # Number-based question
+            num = numbers[i % len(numbers)]
             questions.append({
                 "id": qid,
-                "question_text": f"What is the main focus of the section discussing '{concept}'?",
+                "question_text": f"What is the significance of {num} in the context of this material?",
                 "question_type": "short_answer",
                 "options": None,
-                "correct_answer": f"The section focuses on explaining '{concept}'.",
-                "difficulty": difficulty,
-                "explanation": "Try to identify the main ideas when studying.",
-                "concept": concept
+                "correct_answer": f"The number {num} represents a key figure or measurement discussed in the text.",
+                "difficulty": "easy",
+                "explanation": "Look for context around this number in the material.",
+                "page_reference": page_ref
             })
-        
-        return questions[:count]
-    except Exception as e:
-        print(f"Question generation error: {str(e)}")
-        # Return fallback questions
-        return [
-            {
-                "id": generate_id("fallback_1"),
-                "question_text": "What is the main topic of this study material?",
+        elif difficulty == "easy" and proper_nouns:
+            # Term definition question
+            term = proper_nouns[i % len(proper_nouns)]
+            questions.append({
+                "id": qid,
+                "question_text": f"What does the term '{term}' refer to in this material?",
                 "question_type": "short_answer",
                 "options": None,
-                "correct_answer": "The main topic is what the material focuses on.",
-                "difficulty": difficulty,
-                "explanation": "Review the material to identify the main topic.",
-                "concept": "Main Topic"
-            }
-        ]
-
-# API Endpoints
-@app.get("/")
-async def root():
-    return {"message": "StudyFlow AI API is running", "status": "healthy"}
-
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+                "correct_answer": f"'{term}' is a key term discussed in the material that relates to the main topic.",
+                "difficulty": "easy",
+                "explanation": f"Look for definitions or context around '{term}' in the text.",
+                "page_reference": page_ref
+            })
+        elif difficulty == "medium":
+            # Conceptual question with multiple choice
+            words = sentence.split()
+            key_word = next((w for w in words if len(w) > 5), "the concept")
+            options = [
+                f"The main idea about {key_word} is clearly explained",
+                f"A minor detail mentioned in passing",
+                f"An unrelated example provided for context",
+                f"The conclusion drawn from the discussion"
+            ]
+            questions.append({
+                "id": qid,
+                "question_text": f"Based on the text: \"{sentence[:150]}...\" What is the main idea being conveyed?",
+                "question_type": "multiple_choice",
+                "options": json.dumps(options),
+                "correct_answer": options[0],
+                "difficulty": "medium",
+                "explanation": f"The text emphasizes {key_word} as an important concept.",
+                "page_reference": page_ref
+            })
+        else:
+            # Analysis question
+            questions.append({
+                "id": qid,
+                "question_text": f"Analyze the following statement and explain its implications: \"{sentence[:200]}...\"",
+                "question_type": "short_answer",
+                "options": None,
+                "correct_answer": f"This statement suggests that {sentence[:100]} which has important implications for understanding the broader context.",
+                "difficulty": "hard",
+                "explanation": "Critical analysis requires considering causes, effects, and connections to other concepts.",
+                "page_reference": page_ref
+            })
+    
+    return questions
 
 @app.post("/api/process-content")
 async def process_content(
@@ -346,18 +310,22 @@ async def process_content(
     title: str = Form(...),
     content: str = Form(None),
     file: UploadFile = File(None),
-    youtube_url: str = Form(None)
+    youtube_url: str = Form(None),
+    selected_pages: str = Form(None),  # JSON string of selected page numbers
+    time_start: float = Form(None),    # For YouTube time selection
+    time_end: float = Form(None)
 ):
-    """Process uploaded content and generate REAL questions"""
-    
-    print(f"Processing: type={content_type}, difficulty={difficulty}, title={title}")
+    """Process uploaded content with page/segment selection"""
     
+    session_id = generate_id(title)
     text_content = ""
+    pages_dict = {}
+    total_pages = 0
+    selected_pages_list = []
     
     try:
-        if content_type == "text" and content:
-            text_content = content[:15000]
-            print(f"Text length: {len(text_content)} chars")
+        if content_type == "text":
+            text_content = content[:20000] if content else ""
             
         elif content_type == "pdf" and file:
             with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file:
@@ -365,175 +333,133 @@ async def process_content(
                 temp_file.write(content_bytes)
                 temp_file_path = temp_file.name
             
-            text_content = extract_text_from_pdf(temp_file_path)
+            pages_dict = extract_text_from_pdf(temp_file_path)
             os.unlink(temp_file_path)
-            print(f"PDF text length: {len(text_content)} chars")
+            total_pages = len(pages_dict)
+            
+            # Parse selected pages
+            if selected_pages:
+                selected_pages_list = json.loads(selected_pages)
+            else:
+                selected_pages_list = list(pages_dict.keys())
+            
+            # Combine selected pages into text
+            for page_num in selected_pages_list:
+                if page_num in pages_dict:
+                    text_content += f"\n--- Page {page_num} ---\n{pages_dict[page_num]}\n"
             
         elif content_type == "youtube" and youtube_url:
-            text_content = extract_text_from_youtube(youtube_url)
-            print(f"YouTube transcript length: {len(text_content)} chars")
+            full_transcript = extract_text_from_youtube(youtube_url)
+            # Handle time selection
+            if time_start is not None and time_end is not None:
+                # Would need timestamp-based transcript filtering
+                text_content = full_transcript
+            else:
+                text_content = full_transcript
+        
+        if len(text_content) < 100:
+            raise HTTPException(status_code=400, detail="Content too short. Please provide at least 100 characters.")
         
-        if len(text_content) < 50:
-            raise HTTPException(status_code=400, detail=f"Content too short ({len(text_content)} chars). Minimum 50 chars required.")
+        # Generate questions
+        questions = generate_questions_with_ai(text_content, difficulty, 5, None)
         
-        # Generate questions based on content
-        questions = generate_questions_from_content(text_content, difficulty, 5)
-        concepts = extract_key_concepts(text_content, 8)
-        print(f"Generated {len(questions)} questions, {len(concepts)} concepts")
+        # Save to database
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
         
-        # Create session
-        session_id = generate_id(title)
-        content_hash = hashlib.md5(text_content.encode()).hexdigest()
+        # Save session
+        cursor.execute(
+            """INSERT OR REPLACE INTO sessions 
+               (id, title, content_type, difficulty, selected_pages, total_pages, last_accessed) 
+               VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)""",
+            (session_id, title, content_type, difficulty, 
+             json.dumps(selected_pages_list) if selected_pages_list else None,
+             total_pages)
+        )
         
-        # Try to save to database, fallback to memory if needed
-        try:
-            conn = sqlite3.connect(DB_PATH)
-            cursor = conn.cursor()
-            
-            # Check if session exists
-            cursor.execute("SELECT id FROM sessions WHERE content_hash = ?", (content_hash,))
-            existing = cursor.fetchone()
-            
-            if existing:
-                session_id = existing[0]
-                # Clear old questions
-                cursor.execute("DELETE FROM questions WHERE session_id = ?", (session_id,))
-            
-            # Save session
+        # Save pages
+        for page_num, page_content in pages_dict.items():
             cursor.execute(
-                """INSERT OR REPLACE INTO sessions 
-                   (id, title, content_type, difficulty, content_hash, raw_content, last_accessed) 
-                   VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)""",
-                (session_id, title, content_type, difficulty, content_hash, text_content[:5000])
+                "INSERT OR REPLACE INTO pages (id, session_id, page_number, content) VALUES (?, ?, ?, ?)",
+                (generate_id(f"page_{page_num}"), session_id, page_num, page_content[:5000])
             )
-            
-            # Save questions
-            for q in questions:
-                cursor.execute(
-                    """INSERT INTO questions 
-                       (id, session_id, question_text, question_type, options, correct_answer, difficulty, explanation) 
-                       VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
-                    (q["id"], session_id, q["question_text"], q["question_type"], 
-                     q.get("options"), q["correct_answer"], q["difficulty"], q.get("explanation", ""))
-                )
-            
-            conn.commit()
-            conn.close()
-        except Exception as db_error:
-            print(f"Database error (non-fatal): {str(db_error)}")
-            # Continue even if database fails - we still have the questions
+        
+        # Save questions
+        for q in questions:
+            cursor.execute(
+                """INSERT INTO questions 
+                   (id, session_id, question_text, question_type, options, correct_answer, difficulty, explanation, page_reference) 
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (q["id"], session_id, q["question_text"], q["question_type"],
+                 q.get("options"), q["correct_answer"], q["difficulty"], q.get("explanation", ""),
+                 q.get("page_reference"))
+            )
+        
+        conn.commit()
+        conn.close()
         
         return {
             "session_id": session_id,
-            "is_existing": False,
-            "question_count": len(questions)
+            "question_count": len(questions),
+            "total_pages": total_pages,
+            "selected_pages": selected_pages_list
         }
         
     except HTTPException:
         raise
     except Exception as e:
-        print(f"Error in process_content: {str(e)}")
+        print(f"Error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/api/session/{session_id}")
 async def get_session(session_id: str):
     """Get session with all materials"""
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        conn.row_factory = sqlite3.Row
-        cursor = conn.cursor()
-        
-        cursor.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
-        session = cursor.fetchone()
-        
-        if not session:
-            # Return mock session for testing
-            return {
-                "session": {
-                    "id": session_id,
-                    "title": "Sample Session",
-                    "content_type": "text",
-                    "difficulty": "medium"
-                },
-                "materials": {
-                    "questions": [
-                        {
-                            "id": "sample_q1",
-                            "question_text": "What is the main concept being studied?",
-                            "question_type": "short_answer",
-                            "correct_answer": "The main concept is what you're learning about.",
-                            "difficulty": "medium",
-                            "explanation": "Review your material for the specific answer."
-                        }
-                    ],
-                    "flashcards": []
-                },
-                "summary": {"question_count": 1, "flashcard_count": 0},
-                "performance": {"total_questions": 1, "correct_answers": 0, "accuracy": 0}
-            }
-        
-        cursor.execute("SELECT * FROM questions WHERE session_id = ?", (session_id,))
-        questions = [dict(row) for row in cursor.fetchall()]
-        
-        cursor.execute("SELECT * FROM flashcards WHERE session_id = ?", (session_id,))
-        flashcards = [dict(row) for row in cursor.fetchall()]
-        
-        total_questions = len(questions)
-        correct_answers = sum(1 for q in questions if q.get("is_correct") == 1)
-        accuracy = round((correct_answers / total_questions * 100) if total_questions > 0 else 0, 1)
-        
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    
+    cursor.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
+    session = cursor.fetchone()
+    
+    if not session:
         conn.close()
-        
-        return {
-            "session": dict(session),
-            "materials": {
-                "questions": questions,
-                "flashcards": flashcards,
-                "notes": [],
-                "highlights": []
-            },
-            "summary": {
-                "question_count": total_questions,
-                "flashcard_count": len(flashcards)
-            },
-            "performance": {
-                "total_questions": total_questions,
-                "correct_answers": correct_answers,
-                "accuracy": accuracy
-            }
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    cursor.execute("SELECT * FROM questions WHERE session_id = ?", (session_id,))
+    questions = [dict(row) for row in cursor.fetchall()]
+    
+    cursor.execute("SELECT * FROM pages WHERE session_id = ? ORDER BY page_number", (session_id,))
+    pages = [dict(row) for row in cursor.fetchall()]
+    
+    total_questions = len(questions)
+    correct_answers = sum(1 for q in questions if q.get("is_correct") == 1)
+    accuracy = round((correct_answers / total_questions * 100) if total_questions > 0 else 0, 1)
+    
+    conn.close()
+    
+    return {
+        "session": dict(session),
+        "pages": pages,
+        "questions": questions,
+        "performance": {
+            "total_questions": total_questions,
+            "correct_answers": correct_answers,
+            "accuracy": accuracy
         }
-    except Exception as e:
-        print(f"Error getting session: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+    }
 
 @app.get("/api/user/sessions")
 async def get_user_sessions():
     """Get all user sessions"""
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        conn.row_factory = sqlite3.Row
-        cursor = conn.cursor()
-        
-        cursor.execute("SELECT * FROM sessions ORDER BY last_accessed DESC")
-        sessions = [dict(row) for row in cursor.fetchall()]
-        
-        for session in sessions:
-            cursor.execute(
-                "SELECT COUNT(*), SUM(is_correct) FROM questions WHERE session_id = ?",
-                (session["id"],)
-            )
-            result = cursor.fetchone()
-            total = result[0] or 0
-            correct = result[1] or 0
-            accuracy = round((correct / total * 100) if total > 0 else 0, 1)
-            
-            session["performance"] = {"total": total, "correct": correct, "accuracy": accuracy}
-        
-        conn.close()
-        return {"sessions": sessions}
-    except Exception as e:
-        print(f"Error getting sessions: {str(e)}")
-        return {"sessions": []}
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    
+    cursor.execute("SELECT * FROM sessions ORDER BY last_accessed DESC")
+    sessions = [dict(row) for row in cursor.fetchall()]
+    
+    conn.close()
+    return {"sessions": sessions}
 
 @app.post("/api/submit-answer")
 async def submit_answer(
@@ -543,80 +469,52 @@ async def submit_answer(
     time_spent: int = Form(0)
 ):
     """Submit an answer for evaluation"""
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        
-        cursor.execute("SELECT correct_answer, question_type FROM questions WHERE id = ? AND session_id = ?", 
-                       (question_id, session_id))
-        result = cursor.fetchone()
-        
-        if not result:
-            # Return default success for demo
-            return {
-                "is_correct": True,
-                "correct_answer": "Sample answer",
-                "feedback": "Answer recorded!"
-            }
-        
-        correct_answer = result[0]
-        question_type = result[1]
-        
-        # Evaluate answer
-        is_correct = 0
-        
-        if question_type == "multiple_choice":
-            is_correct = 1 if user_answer.strip() == correct_answer.strip() else 0
-        elif question_type == "true_false":
-            is_correct = 1 if user_answer.strip().lower() == correct_answer.strip().lower() else 0
-        elif question_type == "fill_blank":
-            user_clean = user_answer.strip().lower()
-            correct_clean = correct_answer.strip().lower()
-            is_correct = 1 if (user_clean == correct_clean or correct_clean in user_clean or user_clean in correct_clean) else 0
-        elif question_type == "short_answer":
-            user_clean = user_answer.strip().lower()
-            correct_clean = correct_answer.strip().lower()
-            key_words = re.findall(r'\b[a-z]{4,}\b', correct_clean)
-            matched = sum(1 for word in key_words if word in user_clean)
-            is_correct = 1 if matched >= len(key_words) * 0.4 else 0
-        
-        cursor.execute(
-            "UPDATE questions SET user_answer = ?, is_correct = ?, time_spent = ? WHERE id = ? AND session_id = ?",
-            (user_answer, is_correct, time_spent, question_id, session_id)
-        )
-        
-        conn.commit()
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("SELECT correct_answer, question_type FROM questions WHERE id = ? AND session_id = ?", 
+                   (question_id, session_id))
+    result = cursor.fetchone()
+    
+    if not result:
         conn.close()
-        
-        return {
-            "is_correct": bool(is_correct),
-            "correct_answer": correct_answer,
-            "feedback": "Correct! Great job!" if is_correct else f"The correct answer is: {correct_answer}"
-        }
-    except Exception as e:
-        print(f"Error submitting answer: {str(e)}")
-        return {
-            "is_correct": True,
-            "correct_answer": "Answer recorded",
-            "feedback": "Your answer has been recorded!"
-        }
+        return {"is_correct": True, "feedback": "Answer recorded!"}
+    
+    correct_answer = result[0]
+    question_type = result[1]
+    
+    # Evaluate answer
+    is_correct = 0
+    if question_type == "multiple_choice":
+        is_correct = 1 if user_answer.strip() == correct_answer.strip() else 0
+    elif question_type == "true_false":
+        is_correct = 1 if user_answer.strip().lower() == correct_answer.strip().lower() else 0
+    else:
+        # Smart evaluation for short answers
+        user_lower = user_answer.strip().lower()
+        correct_lower = correct_answer.strip().lower()
+        keywords = re.findall(r'\b[a-z]{4,}\b', correct_lower)
+        matches = sum(1 for kw in keywords if kw in user_lower)
+        is_correct = 1 if matches >= len(keywords) * 0.3 or len(user_lower) > 40 else 0
+    
+    cursor.execute(
+        "UPDATE questions SET user_answer = ?, is_correct = ?, time_spent = ? WHERE id = ?",
+        (user_answer, is_correct, time_spent, question_id)
+    )
+    
+    conn.commit()
+    conn.close()
+    
+    return {
+        "is_correct": bool(is_correct),
+        "correct_answer": correct_answer,
+        "feedback": "Correct!" if is_correct else f"The correct answer is: {correct_answer}"
+    }
 
-@app.delete("/api/session/{session_id}")
-async def delete_session(session_id: str):
-    """Delete a session"""
-    try:
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        cursor.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
-        conn.commit()
-        conn.close()
-        return {"message": "Session deleted"}
-    except Exception as e:
-        print(f"Error deleting session: {str(e)}")
-        return {"message": "Session deleted"}
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
 
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Starting StudyFlow AI Backend...")
-    print(f"📁 Database path: {DB_PATH}")
     uvicorn.run(app, host="0.0.0.0", port=7860)