Update app.py

app.py

@@ -1,33 +1,26 @@
 """
-StudyFlow AI Professional Backend
-Complete with storage, personalization, and enhanced features
+StudyFlow AI Backend - Lightweight Version for Hugging Face Spaces
 """
+import os
+import json
+import sqlite3
+import hashlib
+import tempfile
+from datetime import datetime
+from pathlib import Path
 
-from fastapi import FastAPI, File, UploadFile, Form, HTTPException, BackgroundTasks, Request
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import JSONResponse, FileResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from datetime import datetime, timedelta
-import json
+from fastapi.staticfiles import StaticFiles
 import PyPDF2
-import io
-import re
-from typing import List, Dict, Any, Optional
-import os
-import uuid
-import sqlite3
-from contextlib import contextmanager
-import requests
 from youtube_transcript_api import YouTubeTranscriptApi
-from collections import defaultdict
-import hashlib
+import requests
 
-app = FastAPI(
-    title="StudyFlow AI Professional",
-    description="Complete AI learning assistant with persistent storage",
-    version="2.5.0"
-)
+# Initialize FastAPI
+app = FastAPI(title="StudyFlow AI", version="1.0.0")
 
-# Enable CORS
+# CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -41,1134 +34,634 @@ DB_PATH = "/data/studyflow.db" if os.path.exists("/data") else "studyflow.db"
 
 def init_db():
     """Initialize SQLite database"""
-    with get_db() as conn:
-        cursor = conn.cursor()
-        
-        # Sessions table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS sessions (
-                id TEXT PRIMARY KEY,
-                user_id TEXT,
-                title TEXT,
-                filename TEXT,
-                content_type TEXT,
-                content_hash TEXT,
-                difficulty TEXT,
-                created_at TIMESTAMP,
-                updated_at TIMESTAMP,
-                study_time INTEGER DEFAULT 0,
-                is_active INTEGER DEFAULT 1
-            )
-        ''')
-        
-        # Questions table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS questions (
-                id TEXT PRIMARY KEY,
-                session_id TEXT,
-                question_type TEXT,
-                question_text TEXT,
-                options TEXT,
-                correct_answer TEXT,
-                explanation TEXT,
-                difficulty TEXT,
-                concept TEXT,
-                tags TEXT,
-                created_at TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions(id)
-            )
-        ''')
-        
-        # User answers table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS user_answers (
-                id TEXT PRIMARY KEY,
-                session_id TEXT,
-                question_id TEXT,
-                user_answer TEXT,
-                is_correct INTEGER,
-                time_spent INTEGER,
-                created_at TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions(id),
-                FOREIGN KEY (question_id) REFERENCES questions(id)
-            )
-        ''')
-        
-        # Flashcards table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS flashcards (
-                id TEXT PRIMARY KEY,
-                session_id TEXT,
-                front TEXT,
-                back TEXT,
-                category TEXT,
-                difficulty TEXT,
-                ease_factor REAL DEFAULT 2.5,
-                last_reviewed TIMESTAMP,
-                next_review TIMESTAMP,
-                created_at TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions(id)
-            )
-        ''')
-        
-        # Notes table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS notes (
-                id TEXT PRIMARY KEY,
-                session_id TEXT,
-                title TEXT,
-                content TEXT,
-                tags TEXT,
-                created_at TIMESTAMP,
-                updated_at TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions(id)
-            )
-        ''')
-        
-        # User profiles table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS user_profiles (
-                user_id TEXT PRIMARY KEY,
-                preferences TEXT,
-                strengths TEXT,
-                weaknesses TEXT,
-                learning_patterns TEXT,
-                created_at TIMESTAMP,
-                updated_at TIMESTAMP
-            )
-        ''')
-        
-        # Highlights table
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS highlights (
-                id TEXT PRIMARY KEY,
-                session_id TEXT,
-                user_id TEXT,
-                text TEXT,
-                context TEXT,
-                note TEXT,
-                created_at TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions(id)
-            )
-        ''')
-        
-        conn.commit()
-
-@contextmanager
-def get_db():
-    """Database connection context manager"""
     conn = sqlite3.connect(DB_PATH)
-    conn.row_factory = sqlite3.Row
-    try:
-        yield conn
-    finally:
-        conn.close()
+    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,
+            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
+        )
+    ''')
+    
+    # User profile table
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS user_profile (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            total_questions INTEGER DEFAULT 0,
+            correct_answers INTEGER DEFAULT 0,
+            total_study_time INTEGER DEFAULT 0,
+            weak_areas TEXT,
+            strengths TEXT,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
 
 # Initialize database
 init_db()
 
-# Enhanced vocabulary with internet fallback
-ENHANCED_VOCABULARY = {
-    "algorithm": {
-        "definition": "A set of step-by-step instructions to solve a problem or accomplish a task",
-        "example": "Search algorithms like binary search help find data efficiently in sorted arrays",
-        "contexts": ["computer science", "mathematics", "problem solving", "data structures"],
-        "difficulty": "intermediate",
-        "related": ["data structure", "complexity", "optimization"]
-    },
-    "hypothesis": {
-        "definition": "A proposed explanation made on limited evidence as a starting point for further investigation",
-        "example": "Scientists test their hypothesis through controlled experiments and observation",
-        "contexts": ["science", "research", "statistics", "experimental design"],
-        "difficulty": "basic",
-        "related": ["theory", "experiment", "conclusion", "research"]
-    },
-    # Add more comprehensive vocabulary
-}
+# Helper functions
+def generate_id(text: str = None):
+    """Generate a unique ID"""
+    import uuid
+    if text:
+        return hashlib.md5(text.encode()).hexdigest()[:12]
+    return str(uuid.uuid4())[:12]
 
-def get_internet_definition(word: str) -> Optional[Dict[str, Any]]:
-    """Get definition from internet (fallback)"""
+def extract_text_from_pdf(file_path: str) -> str:
+    """Extract text from PDF file"""
     try:
-        # Try Dictionary API
-        response = requests.get(f"https://api.dictionaryapi.dev/api/v2/entries/en/{word}", timeout=5)
-        if response.status_code == 200:
-            data = response.json()
-            if data and isinstance(data, list):
-                first_entry = data[0]
-                meanings = first_entry.get('meanings', [])
-                if meanings:
-                    first_meaning = meanings[0]
-                    definitions = first_meaning.get('definitions', [])
-                    if definitions:
-                        return {
-                            "definition": definitions[0].get('definition', 'No definition found'),
-                            "example": definitions[0].get('example', ''),
-                            "source": "dictionaryapi.dev",
-                            "phonetic": first_entry.get('phonetic', '')
-                        }
-    except:
-        pass
-    
-    return None
-
-def generate_content_hash(content: str) -> str:
-    """Generate hash for content to avoid duplicates"""
-    return hashlib.md5(content.encode()).hexdigest()
-
-def extract_youtube_id(url: str) -> Optional[str]:
-    """Extract YouTube video ID from URL"""
-    patterns = [
-        r'(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([a-zA-Z0-9_-]{11})',
-        r'youtube\.com\/watch\?.+&v=([a-zA-Z0-9_-]{11})'
-    ]
-    
-    for pattern in patterns:
-        match = re.search(pattern, url)
-        if match:
-            return match.group(1)
-    return None
+        with open(file_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text() + "\n"
+        return text
+    except Exception as e:
+        return f"Error extracting PDF: {str(e)}"
 
-def get_youtube_transcript(video_id: str) -> Optional[str]:
-    """Get transcript from YouTube video"""
+def extract_text_from_youtube(url: str) -> str:
+    """Extract transcript from YouTube video"""
     try:
-        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
-        transcript = " ".join([entry['text'] for entry in transcript_list])
-        return transcript
+        video_id = url.split("v=")[-1].split("&")[0]
+        transcript = YouTubeTranscriptApi.get_transcript(video_id)
+        text = " ".join([entry['text'] for entry in transcript])
+        return text
     except Exception as e:
-        print(f"Error getting transcript: {e}")
-        return None
+        return f"Error extracting YouTube transcript: {str(e)}"
 
-def extract_key_concepts(text: str, max_concepts: int = 15) -> List[Dict[str, Any]]:
-    """Extract key concepts with context and importance"""
-    # Find capitalized words and phrases
-    words = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', text)
-    word_freq = {}
-    
-    for word in words:
-        if len(word) > 3:
-            word_freq[word] = word_freq.get(word, 0) + 1
-    
-    # Get context for each concept
-    concepts = []
-    for concept, freq in sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:max_concepts]:
-        # Find sentences containing the concept
-        sentences = re.findall(r'[^.!?]*\b' + re.escape(concept) + r'\b[^.!?]*[.!?]', text)
-        
-        # Calculate importance based on frequency and position
-        importance = min(100, freq * 8)
-        
-        concepts.append({
-            "concept": concept,
-            "frequency": freq,
-            "context": sentences[0] if sentences else "",
-            "importance": importance,
-            "sentences": sentences[:3]  # First 3 sentences
-        })
-    
-    return concepts
-
-def generate_enhanced_questions(text: str, difficulty: str, session_id: str, user_id: str = "default") -> List[Dict[str, Any]]:
-    """Generate enhanced questions with personalization"""
-    concepts = extract_key_concepts(text, 8)
-    
-    # Get user's weak areas from database
-    weak_areas = get_user_weak_areas(user_id)
+def generate_questions(text: str, difficulty: str, count: int = 5) -> list:
+    """Generate questions from text (simplified for demo)"""
+    sentences = [s.strip() for s in text.split('.') if len(s.strip()) > 50]
+    sentences = sentences[:10]  # Take first 10 meaningful sentences
     
     questions = []
-    
-    # Multiple Choice Questions
-    for i, concept in enumerate(concepts[:4]):
-        # Check if this concept is a weak area
-        is_weak_area = any(weak in concept["concept"].lower() for weak in weak_areas)
-        
-        question_id = str(uuid.uuid4())
-        options = [
-            f"It represents a core principle discussed in the text",
-            f"It's a technical term requiring specialized knowledge",
-            f"It's mentioned briefly but not central to the argument",
-            f"It contradicts other concepts presented"
-        ]
-        
-        # Adjust difficulty
-        if difficulty == "easy":
-            correct_idx = 0
-        elif difficulty == "hard":
-            correct_idx = 2 if is_weak_area else 1
+    for i, sentence in enumerate(sentences[:count]):
+        qid = generate_id(f"q_{i}_{sentence[:20]}")
+        
+        # Simple question generation logic
+        words = sentence.split()
+        if len(words) > 8:
+            # Create a fill-in-the-blank question
+            blank_word = words[len(words)//2]
+            question_text = sentence.replace(blank_word, "_____")
+            questions.append({
+                "id": qid,
+                "question_text": question_text,
+                "question_type": "fill_blank",
+                "correct_answer": blank_word,
+                "difficulty": difficulty,
+                "explanation": f"The missing word is '{blank_word}', which fits grammatically and contextually."
+            })
         else:
-            correct_idx = 1 if is_weak_area else 0
-        
-        questions.append({
-            "id": question_id,
-            "type": "multiple_choice",
-            "question": f"Based on the text, what is the role of '{concept['concept']}'?",
-            "options": options,
-            "correct_answer": correct_idx,
-            "explanation": f"This concept appears {concept['frequency']} times. Context: {concept['context'][:150]}",
-            "difficulty": difficulty,
-            "concept": concept["concept"],
-            "tags": ["comprehension", "analysis", "concept"],
-            "is_weak_area": is_weak_area
-        })
-        
-        # Store question in database
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO questions (id, session_id, question_type, question_text, options, 
-                                     correct_answer, explanation, difficulty, concept, tags, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                question_id, session_id, "multiple_choice", questions[-1]["question"],
-                json.dumps(options), str(correct_idx), questions[-1]["explanation"],
-                difficulty, concept["concept"], json.dumps(questions[-1]["tags"]), datetime.now().isoformat()
-            ))
-            conn.commit()
-    
-    # True/False Questions
-    for i in range(3):
-        question_id = str(uuid.uuid4())
-        is_true = i % 2 == 0
-        
-        questions.append({
-            "id": question_id,
-            "type": "true_false",
-            "question": f"The text primarily focuses on practical applications rather than theoretical concepts.",
-            "options": ["True", "False"],
-            "correct_answer": 0 if is_true else 1,
-            "explanation": "This assesses understanding of the text's orientation and focus.",
-            "difficulty": "medium",
-            "tags": ["comprehension", "critical_thinking"],
-            "is_weak_area": False
-        })
-        
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO questions (id, session_id, question_type, question_text, options, 
-                                     correct_answer, explanation, difficulty, concept, tags, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                question_id, session_id, "true_false", questions[-1]["question"],
-                json.dumps(["True", "False"]), str(questions[-1]["correct_answer"]),
-                questions[-1]["explanation"], "medium", "General", 
-                json.dumps(questions[-1]["tags"]), datetime.now().isoformat()
-            ))
-            conn.commit()
-    
-    # Fill in the Blank
-    if len(text) > 100:
-        sentences = re.findall(r'[^.!?]{50,150}[.!?]', text)
-        for i, sentence in enumerate(sentences[:2]):
-            words = sentence.split()
-            if len(words) > 5:
-                blank_idx = random.randint(2, len(words)-3)
-                blank_word = words[blank_idx]
-                words[blank_idx] = "______"
-                blank_sentence = " ".join(words)
-                
-                question_id = str(uuid.uuid4())
-                
-                questions.append({
-                    "id": question_id,
-                    "type": "fill_blank",
-                    "question": f"Complete the sentence: '{blank_sentence}'",
-                    "correct_answer": blank_word,
-                    "explanation": f"The missing word '{blank_word}' completes the meaning based on context.",
-                    "difficulty": difficulty,
-                    "tags": ["vocabulary", "context"],
-                    "is_weak_area": False
-                })
-                
-                with get_db() as conn:
-                    cursor = conn.cursor()
-                    cursor.execute('''
-                        INSERT INTO questions (id, session_id, question_type, question_text, options, 
-                                             correct_answer, explanation, difficulty, concept, tags, created_at)
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                    ''', (
-                        question_id, session_id, "fill_blank", questions[-1]["question"],
-                        json.dumps([]), blank_word, questions[-1]["explanation"],
-                        difficulty, "Context Completion", 
-                        json.dumps(questions[-1]["tags"]), datetime.now().isoformat()
-                    ))
-                    conn.commit()
+            # Create a multiple choice question
+            question_text = f"What is the main idea of: '{sentence[:100]}...'?"
+            options = [
+                "It describes a process",
+                "It states a fact",
+                "It presents an argument",
+                "It asks a question"
+            ]
+            questions.append({
+                "id": qid,
+                "question_text": question_text,
+                "question_type": "multiple_choice",
+                "options": json.dumps(options),
+                "correct_answer": "0",  # Default to first option
+                "difficulty": difficulty,
+                "explanation": "This sentence appears to describe a process or sequence of events."
+            })
     
     return questions
 
-def get_user_weak_areas(user_id: str) -> List[str]:
-    """Get user's weak areas from database"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT question_id, is_correct FROM user_answers 
-                WHERE EXISTS (
-                    SELECT 1 FROM questions q 
-                    WHERE q.id = user_answers.question_id 
-                    AND q.session_id IN (
-                        SELECT id FROM sessions WHERE user_id = ?
-                    )
-                )
-                ORDER BY created_at DESC LIMIT 50
-            ''', (user_id,))
-            
-            results = cursor.fetchall()
-            
-            # Get concepts from incorrect answers
-            weak_concepts = []
-            for row in results:
-                if row['is_correct'] == 0:  # Incorrect answer
-                    cursor.execute('SELECT concept FROM questions WHERE id = ?', (row['question_id'],))
-                    question = cursor.fetchone()
-                    if question and question['concept']:
-                        weak_concepts.append(question['concept'].lower())
-            
-            return list(set(weak_concepts[:10]))  # Return unique weak areas
-    except:
-        return []
-
-def update_user_profile(user_id: str, question_id: str, is_correct: bool, concept: str):
-    """Update user profile based on performance"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            
-            # Check if profile exists
-            cursor.execute('SELECT * FROM user_profiles WHERE user_id = ?', (user_id,))
-            profile = cursor.fetchone()
-            
-            if profile:
-                # Update existing profile
-                preferences = json.loads(profile['preferences']) if profile['preferences'] else {}
-                strengths = json.loads(profile['strengths']) if profile['strengths'] else []
-                weaknesses = json.loads(profile['weaknesses']) if profile['weaknesses'] else []
-                patterns = json.loads(profile['learning_patterns']) if profile['learning_patterns'] else {}
-                
-                # Update based on performance
-                if is_correct:
-                    if concept not in strengths:
-                        strengths.append(concept)
-                    if concept in weaknesses:
-                        weaknesses.remove(concept)
-                else:
-                    if concept not in weaknesses:
-                        weaknesses.append(concept)
-                    if concept in strengths:
-                        strengths.remove(concept)
-                
-                # Update patterns
-                today = datetime.now().strftime("%Y-%m-%d")
-                if today not in patterns:
-                    patterns[today] = {"correct": 0, "total": 0}
-                patterns[today]["total"] += 1
-                if is_correct:
-                    patterns[today]["correct"] += 1
-                
-                cursor.execute('''
-                    UPDATE user_profiles 
-                    SET strengths = ?, weaknesses = ?, learning_patterns = ?, updated_at = ?
-                    WHERE user_id = ?
-                ''', (
-                    json.dumps(strengths[:50]),
-                    json.dumps(weaknesses[:50]),
-                    json.dumps(patterns),
-                    datetime.now().isoformat(),
-                    user_id
-                ))
-            else:
-                # Create new profile
-                strengths = [concept] if is_correct else []
-                weaknesses = [] if is_correct else [concept]
-                patterns = {
-                    datetime.now().strftime("%Y-%m-%d"): {
-                        "correct": 1 if is_correct else 0,
-                        "total": 1
-                    }
-                }
-                
-                cursor.execute('''
-                    INSERT INTO user_profiles (user_id, strengths, weaknesses, learning_patterns, created_at, updated_at)
-                    VALUES (?, ?, ?, ?, ?, ?)
-                ''', (
-                    user_id,
-                    json.dumps(strengths),
-                    json.dumps(weaknesses),
-                    json.dumps(patterns),
-                    datetime.now().isoformat(),
-                    datetime.now().isoformat()
-                ))
-            
-            conn.commit()
-    except Exception as e:
-        print(f"Error updating user profile: {e}")
+def generate_flashcards(text: str, count: int = 3) -> list:
+    """Generate flashcards from text"""
+    sentences = [s.strip() for s in text.split('.') if len(s.strip()) > 30]
+    sentences = sentences[:count * 2]  # Take pairs for front/back
+    
+    flashcards = []
+    for i in range(0, min(len(sentences), count * 2), 2):
+        if i + 1 < len(sentences):
+            fcid = generate_id(f"fc_{i}")
+            flashcards.append({
+                "id": fcid,
+                "front": sentences[i][:100],
+                "back": sentences[i + 1][:200],
+                "category": "General",
+                "difficulty": "medium"
+            })
+    
+    return flashcards
 
+# API Endpoints
 @app.post("/api/process-content")
 async def process_content(
-    request: Request,
     content_type: str = Form(...),
+    difficulty: str = Form(...),
+    title: str = Form(...),
     content: str = Form(None),
     file: UploadFile = File(None),
-    youtube_url: str = Form(None),
-    difficulty: str = Form("medium"),
-    title: str = Form(None)
+    youtube_url: str = Form(None)
 ):
-    """Process any type of content and create a new session"""
-    try:
-        # Get user ID from request (for now, use IP as user ID)
-        user_id = request.client.host if request.client else "anonymous"
-        
-        extracted_text = ""
-        metadata = {}
-        
-        if content_type == "text" and content:
-            extracted_text = content
-            metadata = {"type": "text", "length": len(content)}
-            
-        elif content_type == "pdf" and file:
-            contents = await file.read()
-            pdf_file = io.BytesIO(contents)
-            pdf_reader = PyPDF2.PdfReader(pdf_file)
-            
-            text = ""
-            for i in range(min(20, len(pdf_reader.pages))):
-                page_text = pdf_reader.pages[i].extract_text()
-                if page_text:
-                    text += page_text + "\n\n"
-            
-            extracted_text = text
-            metadata = {
-                "type": "pdf",
-                "filename": file.filename,
-                "pages": len(pdf_reader.pages),
-                "extracted_pages": min(20, len(pdf_reader.pages))
-            }
-            
-        elif content_type == "youtube" and youtube_url:
-            video_id = extract_youtube_id(youtube_url)
-            if not video_id:
-                raise HTTPException(status_code=400, detail="Invalid YouTube URL")
-            
-            transcript = get_youtube_transcript(video_id)
-            if not transcript:
-                raise HTTPException(status_code=400, detail="Could not extract transcript")
-            
-            extracted_text = transcript
-            metadata = {
-                "type": "youtube",
-                "video_id": video_id,
-                "url": youtube_url
-            }
-        
-        if not extracted_text or len(extracted_text.strip()) < 100:
-            raise HTTPException(status_code=400, detail="Insufficient content (minimum 100 characters)")
-        
-        # Generate content hash
-        content_hash = generate_content_hash(extracted_text)
-        
-        # Check for existing session with same content
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT id, title FROM sessions 
-                WHERE content_hash = ? AND user_id = ? AND is_active = 1
-                ORDER BY created_at DESC LIMIT 1
-            ''', (content_hash, user_id))
-            
-            existing = cursor.fetchone()
-            if existing:
-                return {
-                    "success": True,
-                    "message": "Session already exists",
-                    "session_id": existing['id'],
-                    "title": existing['title'],
-                    "is_existing": True
-                }
-        
-        # Create new session
-        session_id = str(uuid.uuid4())
-        session_title = title or metadata.get("filename", "Untitled Session")
-        
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO sessions (id, user_id, title, filename, content_type, 
-                                     content_hash, difficulty, created_at, updated_at, is_active)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                session_id,
-                user_id,
-                session_title,
-                metadata.get("filename", ""),
-                content_type,
-                content_hash,
-                difficulty,
-                datetime.now().isoformat(),
-                datetime.now().isoformat(),
-                1
-            ))
-            conn.commit()
-        
-        # Generate materials in background
-        background_tasks = BackgroundTasks()
-        background_tasks.add_task(
-            generate_session_materials,
-            session_id,
-            user_id,
-            extracted_text,
-            difficulty,
-            metadata
+    """Process uploaded content and create study materials"""
+    
+    # Extract text based on content type
+    text_content = ""
+    if content_type == "text" and content:
+        text_content = content
+    elif content_type == "pdf" and file:
+        # Save uploaded file temporarily
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+        content_bytes = await file.read()
+        temp_file.write(content_bytes)
+        temp_file.close()
+        text_content = extract_text_from_pdf(temp_file.name)
+        os.unlink(temp_file.name)
+    elif content_type == "youtube" and youtube_url:
+        text_content = extract_text_from_youtube(youtube_url)
+    else:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Invalid content type or missing content"}
         )
-        
+    
+    if len(text_content) < 100:
         return JSONResponse(
-            content={
-                "success": True,
-                "session_id": session_id,
-                "title": session_title,
-                "message": "Session created. Materials are being generated...",
-                "metadata": metadata,
-                "is_existing": False
-            },
-            background=background_tasks
+            status_code=400,
+            content={"error": "Content too short (minimum 100 characters)"}
         )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
-
-async def generate_session_materials(session_id: str, user_id: str, text: str, difficulty: str, metadata: Dict):
-    """Generate all study materials for a session"""
-    try:
-        # Generate questions
-        questions = generate_enhanced_questions(text, difficulty, session_id, user_id)
-        
-        # Generate flashcards
-        concepts = extract_key_concepts(text, 20)
-        flashcards = []
-        
-        for concept in concepts[:15]:
-            flashcard_id = str(uuid.uuid4())
-            flashcards.append({
-                "id": flashcard_id,
-                "front": f"What is '{concept['concept']}'?",
-                "back": f"A key concept appearing {concept['frequency']} times.\n\nContext: {concept['context'][:200]}",
-                "category": "Key Concepts",
-                "difficulty": "medium",
-                "importance": concept['importance']
-            })
-            
-            # Store in database
-            with get_db() as conn:
-                cursor = conn.cursor()
-                cursor.execute('''
-                    INSERT INTO flashcards (id, session_id, front, back, category, 
-                                          difficulty, created_at)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                ''', (
-                    flashcard_id,
-                    session_id,
-                    flashcards[-1]["front"],
-                    flashcards[-1]["back"],
-                    flashcards[-1]["category"],
-                    flashcards[-1]["difficulty"],
-                    datetime.now().isoformat()
-                ))
-                conn.commit()
-        
-        # Update session to mark as ready
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                UPDATE sessions SET updated_at = ? WHERE id = ?
-            ''', (datetime.now().isoformat(), session_id))
-            conn.commit()
-            
-    except Exception as e:
-        print(f"Error generating materials: {e}")
+    
+    # Generate content hash
+    content_hash = hashlib.md5(text_content.encode()).hexdigest()
+    
+    # Check if session already exists
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute(
+        "SELECT id FROM sessions WHERE content_hash = ?",
+        (content_hash,)
+    )
+    existing = cursor.fetchone()
+    
+    if existing:
+        conn.close()
+        return JSONResponse({
+            "message": "Session already exists",
+            "session_id": existing[0],
+            "is_existing": True
+        })
+    
+    # Create new session
+    session_id = generate_id(text_content[:100])
+    
+    cursor.execute('''
+        INSERT INTO sessions (id, title, content_type, difficulty, content_hash)
+        VALUES (?, ?, ?, ?, ?)
+    ''', (session_id, title, content_type, difficulty, content_hash))
+    
+    # Generate study materials
+    questions = generate_questions(text_content, difficulty, 5)
+    flashcards = generate_flashcards(text_content, 3)
+    
+    # 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")
+        ))
+    
+    # Save flashcards
+    for fc in flashcards:
+        cursor.execute('''
+            INSERT INTO flashcards (id, session_id, front, back, category, difficulty)
+            VALUES (?, ?, ?, ?, ?, ?)
+        ''', (
+            fc["id"], session_id, fc["front"], fc["back"],
+            fc["category"], fc["difficulty"]
+        ))
+    
+    # Create initial notes
+    cursor.execute('''
+        INSERT INTO notes (id, session_id, title, content)
+        VALUES (?, ?, ?, ?)
+    ''', (
+        generate_id("note1"),
+        session_id,
+        "Key Concepts",
+        "Here are the key concepts from your study material..."
+    ))
+    
+    conn.commit()
+    conn.close()
+    
+    return JSONResponse({
+        "message": "Session created successfully",
+        "session_id": session_id,
+        "is_existing": False,
+        "question_count": len(questions),
+        "flashcard_count": len(flashcards)
+    })
 
-@app.post("/api/analyze-text")
-async def analyze_text(
-    text: str = Form(...),
-    session_id: str = Form(None),
-    user_id: str = Form("anonymous")
-):
-    """Analyze selected text and provide explanations"""
-    try:
-        # Clean and prepare text
-        text = text.strip()
-        if len(text) < 2 or len(text) > 500:
-            raise HTTPException(status_code=400, detail="Text must be between 2 and 500 characters")
-        
-        # Extract potential terms
-        words = re.findall(r'\b[a-zA-Z]{4,}\b', text)
-        
-        # Get definitions
-        definitions = []
-        for word in set(words[:5]):  # Limit to 5 unique words
-            word_lower = word.lower()
-            
-            # Check enhanced vocabulary first
-            if word_lower in ENHANCED_VOCABULARY:
-                definition = ENHANCED_VOCABULARY[word_lower]
-                definition["word"] = word
-                definition["source"] = "enhanced_vocabulary"
-                definitions.append(definition)
-            else:
-                # Try internet
-                internet_def = get_internet_definition(word_lower)
-                if internet_def:
-                    internet_def["word"] = word
-                    definitions.append(internet_def)
-                else:
-                    # Generate contextual definition
-                    definitions.append({
-                        "word": word,
-                        "definition": f"In this context, '{word}' likely refers to a concept or term mentioned in the material.",
-                        "example": f"The word '{word}' appears in your selected text.",
-                        "source": "contextual",
-                        "contexts": ["general"]
-                    })
-        
-        # Store highlight if session exists
-        if session_id:
-            with get_db() as conn:
-                cursor = conn.cursor()
-                highlight_id = str(uuid.uuid4())
-                cursor.execute('''
-                    INSERT INTO highlights (id, session_id, user_id, text, context, created_at)
-                    VALUES (?, ?, ?, ?, ?, ?)
-                ''', (
-                    highlight_id,
-                    session_id,
-                    user_id,
-                    text,
-                    json.dumps(definitions),
-                    datetime.now().isoformat()
-                ))
-                conn.commit()
-        
-        # Generate explanation
-        explanation = generate_text_explanation(text, definitions)
-        
-        return {
-            "success": True,
-            "text": text,
-            "definitions": definitions,
-            "explanation": explanation,
-            "word_count": len(words),
-            "suggested_actions": [
-                "Add to vocabulary list",
-                "Create flashcard",
-                "Search for more examples"
-            ]
+@app.get("/api/session/{session_id}")
+async def get_session(session_id: str):
+    """Get session with all materials"""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    
+    # Get session info
+    cursor.execute("SELECT * FROM sessions WHERE id = ?", (session_id,))
+    session = cursor.fetchone()
+    
+    if not session:
+        conn.close()
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    # Get questions
+    cursor.execute("SELECT * FROM questions WHERE session_id = ?", (session_id,))
+    questions = [dict(row) for row in cursor.fetchall()]
+    
+    # Get flashcards
+    cursor.execute("SELECT * FROM flashcards WHERE session_id = ?", (session_id,))
+    flashcards = [dict(row) for row in cursor.fetchall()]
+    
+    # Get notes
+    cursor.execute("SELECT * FROM notes WHERE session_id = ?", (session_id,))
+    notes = [dict(row) for row in cursor.fetchall()]
+    
+    # Get highlights
+    cursor.execute("SELECT * FROM highlights WHERE session_id = ?", (session_id,))
+    highlights = [dict(row) for row in cursor.fetchall()]
+    
+    # Calculate performance
+    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)
+    avg_time_spent = round(sum(q.get("time_spent", 0) for q in questions) / total_questions if total_questions > 0 else 0, 1)
+    
+    conn.close()
+    
+    return JSONResponse({
+        "session": dict(session),
+        "materials": {
+            "questions": questions,
+            "flashcards": flashcards,
+            "notes": notes,
+            "highlights": highlights
+        },
+        "summary": {
+            "question_count": total_questions,
+            "flashcard_count": len(flashcards),
+            "note_count": len(notes),
+            "highlight_count": len(highlights)
+        },
+        "performance": {
+            "total_questions": total_questions,
+            "correct_answers": correct_answers,
+            "accuracy": accuracy,
+            "avg_time_spent": avg_time_spent
         }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Text analysis error: {str(e)}")
+    })
 
-def generate_text_explanation(text: str, definitions: List[Dict]) -> str:
-    """Generate comprehensive explanation for selected text"""
-    if not definitions:
-        return f"The selected text '{text[:50]}...' appears to be a passage from your material. Consider looking up individual terms for more detailed explanations."
-    
-    # Build explanation
-    explanation_parts = ["**Analysis of Selected Text:**\n\n"]
-    
-    for def_item in definitions[:3]:  # Limit to 3 definitions
-        word = def_item.get("word", "")
-        definition = def_item.get("definition", "")
-        example = def_item.get("example", "")
-        source = def_item.get("source", "unknown")
-        
-        explanation_parts.append(f"**{word}**: {definition}")
-        if example:
-            explanation_parts.append(f"  *Example*: {example}")
-        if source != "contextual":
-            explanation_parts.append(f"  *Source*: {source}")
-        explanation_parts.append("")
-    
-    explanation_parts.append("\n**Learning Suggestions:**")
-    explanation_parts.append("1. Review these terms in context")
-    explanation_parts.append("2. Create flashcards for retention")
-    explanation_parts.append("3. Look for related concepts in your material")
-    
-    return "\n".join(explanation_parts)
+@app.get("/api/user/sessions")
+async def get_user_sessions():
+    """Get all user 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()]
+    
+    # Add performance stats to each session
+    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 JSONResponse({"sessions": sessions})
 
 @app.post("/api/submit-answer")
 async def submit_answer(
     session_id: str = Form(...),
     question_id: str = Form(...),
     user_answer: str = Form(...),
-    time_spent: int = Form(0),
-    user_id: str = Form("anonymous")
+    time_spent: int = Form(0)
 ):
-    """Submit and evaluate an answer"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            
-            # Get question details
-            cursor.execute('SELECT * FROM questions WHERE id = ?', (question_id,))
-            question = cursor.fetchone()
-            
-            if not question:
-                raise HTTPException(status_code=404, detail="Question not found")
-            
-            # Evaluate answer
-            is_correct = False
-            if question['question_type'] == 'multiple_choice':
-                is_correct = str(user_answer) == question['correct_answer']
-            elif question['question_type'] == 'true_false':
-                is_correct = str(user_answer) == question['correct_answer']
-            elif question['question_type'] == 'fill_blank':
-                # Simple text comparison for fill blank
-                correct_lower = question['correct_answer'].lower().strip()
-                user_lower = user_answer.lower().strip()
-                is_correct = correct_lower == user_lower or correct_lower in user_lower
-            
-            # Store answer
-            answer_id = str(uuid.uuid4())
-            cursor.execute('''
-                INSERT INTO user_answers (id, session_id, question_id, user_answer, 
-                                         is_correct, time_spent, created_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                answer_id,
-                session_id,
-                question_id,
-                user_answer,
-                1 if is_correct else 0,
-                time_spent,
-                datetime.now().isoformat()
-            ))
-            
-            # Update user profile
-            update_user_profile(
-                user_id,
-                question_id,
-                is_correct,
-                question['concept'] or "General"
-            )
-            
-            conn.commit()
-            
-            # Get explanation
-            explanation = question['explanation'] or "No explanation available."
-            
-            # Get personalized feedback based on performance
-            weak_areas = get_user_weak_areas(user_id)
-            concept = question['concept'] or "this concept"
-            
-            personalized_feedback = ""
-            if is_correct:
-                if concept.lower() in [w.lower() for w in weak_areas]:
-                    personalized_feedback = f"Great improvement on {concept}, which was previously a weak area!"
-                else:
-                    personalized_feedback = f"Good understanding of {concept}!"
-            else:
-                if concept.lower() in [w.lower() for w in weak_areas]:
-                    personalized_feedback = f"{concept} continues to be challenging. Focus on reviewing related materials."
-                else:
-                    personalized_feedback = f"{concept} may need more attention. Consider reviewing the relevant section."
-            
-            return {
-                "success": True,
-                "is_correct": is_correct,
-                "correct_answer": question['correct_answer'],
-                "explanation": explanation,
-                "personalized_feedback": personalized_feedback,
-                "concept": concept,
-                "answer_id": answer_id
-            }
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Answer submission error: {str(e)}")
+    """Submit an answer to a question"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    # Get correct answer
+    cursor.execute(
+        "SELECT correct_answer FROM questions WHERE id = ? AND session_id = ?",
+        (question_id, session_id)
+    )
+    result = cursor.fetchone()
+    
+    if not result:
+        conn.close()
+        raise HTTPException(status_code=404, detail="Question not found")
+    
+    correct_answer = result[0]
+    is_correct = 1 if str(user_answer).strip().lower() == str(correct_answer).strip().lower() else 0
+    
+    # Update question with user answer
+    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))
+    
+    # Update user profile stats
+    cursor.execute('''
+        INSERT OR REPLACE INTO user_profile (id, total_questions, correct_answers, updated_at)
+        VALUES (
+            1,
+            COALESCE((SELECT total_questions FROM user_profile WHERE id = 1), 0) + 1,
+            COALESCE((SELECT correct_answers FROM user_profile WHERE id = 1), 0) + ?,
+            CURRENT_TIMESTAMP
+        )
+    ''', (is_correct,))
+    
+    conn.commit()
+    conn.close()
+    
+    return JSONResponse({
+        "is_correct": bool(is_correct),
+        "correct_answer": correct_answer,
+        "message": "Correct!" if is_correct else "Incorrect, try again!"
+    })
 
-@app.get("/api/session/{session_id}")
-async def get_session(session_id: str):
-    """Get session details and materials"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            
-            # Get session
-            cursor.execute('SELECT * FROM sessions WHERE id = ?', (session_id,))
-            session = cursor.fetchone()
-            
-            if not session:
-                raise HTTPException(status_code=404, detail="Session not found")
-            
-            # Get questions
-            cursor.execute('SELECT * FROM questions WHERE session_id = ? ORDER BY created_at', (session_id,))
-            questions = [dict(row) for row in cursor.fetchall()]
-            
-            # Get flashcards
-            cursor.execute('SELECT * FROM flashcards WHERE session_id = ? ORDER BY created_at', (session_id,))
-            flashcards = [dict(row) for row in cursor.fetchall()]
-            
-            # Get notes
-            cursor.execute('SELECT * FROM notes WHERE session_id = ? ORDER BY updated_at DESC', (session_id,))
-            notes = [dict(row) for row in cursor.fetchall()]
-            
-            # Get highlights
-            cursor.execute('SELECT * FROM highlights WHERE session_id = ? ORDER BY created_at DESC', (session_id,))
-            highlights = [dict(row) for row in cursor.fetchall()]
-            
-            # Get performance statistics
-            cursor.execute('''
-                SELECT 
-                    COUNT(*) as total_questions,
-                    SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END) as correct_answers,
-                    AVG(time_spent) as avg_time_spent
-                FROM user_answers 
-                WHERE session_id = ?
-            ''', (session_id,))
-            
-            stats = cursor.fetchone()
-            performance = {
-                "total_questions": stats['total_questions'] or 0,
-                "correct_answers": stats['correct_answers'] or 0,
-                "accuracy": round((stats['correct_answers'] or 0) / max(1, (stats['total_questions'] or 1)) * 100, 1),
-                "avg_time_spent": round(stats['avg_time_spent'] or 0, 1)
-            }
-            
-            return {
-                "success": True,
-                "session": dict(session),
-                "materials": {
-                    "questions": questions,
-                    "flashcards": flashcards,
-                    "notes": notes,
-                    "highlights": highlights
-                },
-                "performance": performance,
-                "summary": {
-                    "question_count": len(questions),
-                    "flashcard_count": len(flashcards),
-                    "note_count": len(notes),
-                    "highlight_count": len(highlights)
-                }
-            }
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Session retrieval error: {str(e)}")
+@app.post("/api/analyze-text")
+async def analyze_text(text: str = Form(...), session_id: str = Form(...)):
+    """Analyze selected text (simplified version)"""
+    
+    # Simple text analysis
+    words = text.split()
+    definitions = []
+    
+    # Simple "definition" generation for demo
+    for i, word in enumerate(words[:5]):  # Analyze first 5 words
+        if len(word) > 4:  # Only "define" longer words
+            definitions.append({
+                "word": word,
+                "definition": f"A term used in this context meaning: '{word}'",
+                "source": "StudyFlow AI",
+                "example": f"In the sentence: '{' '.join(words[max(0,i-2):min(len(words),i+3)])}'"
+            })
+    
+    # Generate simple explanation
+    word_count = len(words)
+    explanation = f"This text contains {word_count} words. "
+    if word_count < 10:
+        explanation += "It's a short phrase or sentence fragment."
+    elif word_count < 25:
+        explanation += "It's a sentence or two expressing a complete thought."
+    else:
+        explanation += "It's a paragraph expressing multiple related ideas."
+    
+    # Save as highlight
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    highlight_id = generate_id(text)
+    cursor.execute('''
+        INSERT OR IGNORE INTO highlights (id, session_id, text, context)
+        VALUES (?, ?, ?, ?)
+    ''', (highlight_id, session_id, text, json.dumps(definitions)))
+    
+    conn.commit()
+    conn.close()
+    
+    return JSONResponse({
+        "text": text,
+        "definitions": definitions,
+        "explanation": explanation,
+        "suggested_actions": [
+            "Add to flashcards",
+            "Create a practice question",
+            "Make a note about this concept"
+        ]
+    })
 
-@app.get("/api/user/sessions")
-async def get_user_sessions(user_id: str = "anonymous"):
-    """Get all sessions for a user"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            
-            cursor.execute('''
-                SELECT id, title, content_type, difficulty, created_at, updated_at, study_time
-                FROM sessions 
-                WHERE user_id = ? AND is_active = 1
-                ORDER BY updated_at DESC
-            ''', (user_id,))
-            
-            sessions = [dict(row) for row in cursor.fetchall()]
-            
-            # Get performance for each session
-            for session in sessions:
-                cursor.execute('''
-                    SELECT 
-                        COUNT(*) as total_answered,
-                        SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END) as correct_answers
-                    FROM user_answers 
-                    WHERE session_id = ?
-                ''', (session['id'],))
-                
-                stats = cursor.fetchone()
-                session['performance'] = {
-                    "answered": stats['total_answered'] or 0,
-                    "correct": stats['correct_answers'] or 0,
-                    "accuracy": round((stats['correct_answers'] or 0) / max(1, (stats['total_answered'] or 1)) * 100, 1)
+@app.get("/api/user/profile")
+async def get_user_profile():
+    """Get user learning profile"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("SELECT * FROM user_profile WHERE id = 1")
+    profile = cursor.fetchone()
+    
+    if not profile:
+        # Create default profile
+        cursor.execute('''
+            INSERT INTO user_profile (id, total_questions, correct_answers, total_study_time)
+            VALUES (1, 0, 0, 0)
+        ''')
+        conn.commit()
+        cursor.execute("SELECT * FROM user_profile WHERE id = 1")
+        profile = cursor.fetchone()
+    
+    # Get insights from questions
+    cursor.execute('''
+        SELECT difficulty, 
+               COUNT(*) as total,
+               SUM(is_correct) as correct
+        FROM questions 
+        WHERE user_answer IS NOT NULL
+        GROUP BY difficulty
+    ''')
+    difficulty_stats = cursor.fetchall()
+    
+    # Determine weak areas and strengths
+    weak_areas = []
+    strengths = []
+    
+    for diff, total, correct in difficulty_stats:
+        if total > 0:
+            accuracy = correct / total
+            if accuracy < 0.5:
+                weak_areas.append(f"{diff} difficulty questions")
+            elif accuracy > 0.8:
+                strengths.append(f"{diff} difficulty questions")
+    
+    conn.close()
+    
+    return JSONResponse({
+        "profile": {
+            "total_questions": profile[1],
+            "correct_answers": profile[2],
+            "total_study_time": profile[3],
+            "accuracy": round((profile[2] / profile[1] * 100) if profile[1] > 0 else 0, 1)
+        },
+        "insights": {
+            "weaknesses": weak_areas,
+            "strengths": strengths,
+            "recent_performance": [
+                {
+                    "date": datetime.now().strftime("%Y-%m-%d"),
+                    "total": profile[1],
+                    "correct": profile[2]
                 }
-            
-            return {
-                "success": True,
-                "sessions": sessions,
-                "total_sessions": len(sessions)
-            }
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Session list error: {str(e)}")
-
-@app.post("/api/create-note")
-async def create_note(
-    session_id: str = Form(...),
-    title: str = Form(...),
-    content: str = Form(...),
-    tags: str = Form("[]")
-):
-    """Create a note for a session"""
-    try:
-        note_id = str(uuid.uuid4())
-        
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO notes (id, session_id, title, content, tags, created_at, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                note_id,
-                session_id,
-                title,
-                content,
-                tags,
-                datetime.now().isoformat(),
-                datetime.now().isoformat()
-            ))
-            conn.commit()
-        
-        return {
-            "success": True,
-            "note_id": note_id,
-            "message": "Note created successfully"
+            ]
         }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Note creation error: {str(e)}")
+    })
+
+@app.delete("/api/session/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session"""
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+    
+    conn.commit()
+    affected = cursor.rowcount
+    conn.close()
+    
+    if affected == 0:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    return JSONResponse({"message": "Session deleted successfully"})
 
 @app.post("/api/update-study-time")
-async def update_study_time(
-    session_id: str = Form(...),
-    study_time: int = Form(...)
-):
+async def update_study_time(session_id: str = Form(...), study_time: int = Form(...)):
     """Update study time for a session"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                UPDATE sessions 
-                SET study_time = study_time + ?, updated_at = ?
-                WHERE id = ?
-            ''', (study_time, datetime.now().isoformat(), session_id))
-            conn.commit()
-        
-        return {"success": True}
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Study time update error: {str(e)}")
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute('''
+        UPDATE sessions 
+        SET last_accessed = CURRENT_TIMESTAMP 
+        WHERE id = ?
+    ''', (session_id,))
+    
+    cursor.execute('''
+        UPDATE user_profile 
+        SET total_study_time = COALESCE(total_study_time, 0) + ?
+        WHERE id = 1
+    ''', (study_time,))
+    
+    conn.commit()
+    conn.close()
+    
+    return JSONResponse({"message": "Study time updated"})
 
-@app.get("/api/user/profile")
-async def get_user_profile(user_id: str = "anonymous"):
-    """Get user profile and learning insights"""
+# Serve static files
+@app.get("/")
+async def serve_frontend():
+    """Serve the main frontend page"""
     try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            
-            # Get profile
-            cursor.execute('SELECT * FROM user_profiles WHERE user_id = ?', (user_id,))
-            profile = cursor.fetchone()
-            
-            if not profile:
-                return {
-                    "success": True,
-                    "profile": None,
-                    "message": "No profile found"
-                }
-            
-            # Get recent performance
-            cursor.execute('''
-                SELECT 
-                    DATE(created_at) as date,
-                    COUNT(*) as total,
-                    SUM(CASE WHEN is_correct = 1 THEN 1 ELSE 0 END) as correct
-                FROM user_answers 
-                WHERE session_id IN (
-                    SELECT id FROM sessions WHERE user_id = ?
-                )
-                GROUP BY DATE(created_at)
-                ORDER BY date DESC
-                LIMIT 7
-            ''', (user_id,))
-            
-            recent_performance = [dict(row) for row in cursor.fetchall()]
-            
-            # Get weak areas
-            strengths = json.loads(profile['strengths']) if profile['strengths'] else []
-            weaknesses = json.loads(profile['weaknesses']) if profile['weaknesses'] else []
-            
-            return {
-                "success": True,
-                "profile": dict(profile),
-                "insights": {
-                    "strengths": strengths[:10],
-                    "weaknesses": weaknesses[:10],
-                    "recent_performance": recent_performance,
-                    "total_weak_areas": len(weaknesses),
-                    "total_strengths": len(strengths)
-                }
-            }
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Profile retrieval error: {str(e)}")
+        with open("index.html", "r", encoding="utf-8") as f:
+            html_content = f.read()
+        return HTMLResponse(content=html_content)
+    except FileNotFoundError:
+        return HTMLResponse(content="<h1>StudyFlow AI Backend is running!</h1><p>Frontend files not found.</p>")
 
-@app.delete("/api/session/{session_id}")
-async def delete_session(session_id: str):
-    """Soft delete a session"""
+@app.get("/app.js")
+async def serve_js():
+    """Serve the JavaScript file"""
     try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                UPDATE sessions SET is_active = 0, updated_at = ? WHERE id = ?
-            ''', (datetime.now().isoformat(), session_id))
-            conn.commit()
-        
-        return {"success": True, "message": "Session deleted"}
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Session deletion error: {str(e)}")
+        with open("app.js", "r", encoding="utf-8") as f:
+            js_content = f.read()
+        return HTMLResponse(content=js_content, media_type="application/javascript")
+    except FileNotFoundError:
+        return HTMLResponse(content="console.error('app.js not found');", media_type="application/javascript")
 
+# Health check endpoint
 @app.get("/health")
-async def health():
+async def health_check():
     """Health check endpoint"""
-    try:
-        with get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('SELECT COUNT(*) as count FROM sessions WHERE is_active = 1')
-            result = cursor.fetchone()
-            
-        return {
-            "status": "healthy",
-            "timestamp": datetime.now().isoformat(),
-            "database": "connected",
-            "active_sessions": result['count'] if result else 0
-        }
-    except:
-        return {"status": "unhealthy", "timestamp": datetime.now().isoformat()}
-
-@app.get("/")
-async def root():
-    """Root endpoint"""
-    return {
-        "service": "StudyFlow AI Professional",
-        "version": "2.5.0",
-        "status": "running",
-        "features": [
-            "Persistent session storage",
-            "Personalized learning profiles",
-            "Text selection analysis",
-            "YouTube transcript processing",
-            "Performance tracking",
-            "Weak area identification",
-            "Tab-based interface",
-            "Real-time feedback"
-        ],
-        "endpoints": {
-            "process_content": "POST /api/process-content",
-            "analyze_text": "POST /api/analyze-text",
-            "submit_answer": "POST /api/submit-answer",
-            "get_session": "GET /api/session/{session_id}",
-            "get_user_sessions": "GET /api/user/sessions",
-            "get_user_profile": "GET /api/user/profile"
-        }
-    }
+    return JSONResponse({"status": "healthy", "timestamp": datetime.now().isoformat()})
 
 if __name__ == "__main__":
     import uvicorn
-    import random
-    port = int(os.getenv("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    uvicorn.run(app, host="0.0.0.0", port=7860)