Update app.py

app.py

@@ -1,26 +1,31 @@
 """
-StudyFlow Backend API for Hugging Face Spaces
-Complete implementation with PDF processing and content generation
+StudyFlow Enhanced Backend - Complete AI Study Assistant
+Features: PDF, YouTube, Question Generation, Flashcards, Note Creation, Context Analysis
 """
 
-from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, StreamingResponse
 from datetime import datetime
 import json
 import PyPDF2
 import io
 import re
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 import os
+import urllib.parse
+import requests
+from youtube_transcript_api import YouTubeTranscriptApi
+import random
+import time
 
 app = FastAPI(
-    title="StudyFlow API",
-    description="AI-powered learning assistant backend",
-    version="1.0.0"
+    title="StudyFlow AI Assistant",
+    description="Comprehensive AI-powered learning platform",
+    version="2.0.0"
 )
 
-# Enable CORS for frontend
+# Enable CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -29,506 +34,586 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Store for user sessions (in production, use database)
+# Store for sessions
 user_sessions = {}
+vocabulary_database = {}
 
-def extract_key_concepts(text: str, max_concepts: int = 5) -> List[str]:
-    """Extract key concepts from text using simple NLP techniques"""
+# Enhanced vocabulary database
+ENHANCED_VOCABULARY = {
+    "algorithm": {
+        "definition": "A set of step-by-step instructions to solve a problem",
+        "example": "Search algorithms like binary search help find data efficiently",
+        "contexts": ["computer science", "mathematics", "problem solving"],
+        "difficulty": "intermediate"
+    },
+    "hypothesis": {
+        "definition": "A proposed explanation made on limited evidence",
+        "example": "Scientists test their hypothesis through experiments",
+        "contexts": ["science", "research", "statistics"],
+        "difficulty": "basic"
+    },
+    # Add more words as needed
+}
+
+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
+
+def get_youtube_transcript(video_id: str) -> Optional[str]:
+    """Get transcript from YouTube video"""
+    try:
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+        transcript = " ".join([entry['text'] for entry in transcript_list])
+        return transcript
+    except Exception as e:
+        print(f"Error getting transcript: {e}")
+        return None
+
+def extract_key_concepts(text: str, max_concepts: int = 10) -> List[Dict[str, Any]]:
+    """Extract key concepts with context"""
     # 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:  # Ignore short words
+        if len(word) > 3:
             word_freq[word] = word_freq.get(word, 0) + 1
     
-    # Sort by frequency and get top concepts
-    sorted_concepts = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
-    return [concept for concept, _ in sorted_concepts[:max_concepts]]
+    # 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)
+        
+        concepts.append({
+            "concept": concept,
+            "frequency": freq,
+            "context": sentences[0] if sentences else "",
+            "importance": min(100, freq * 10)
+        })
+    
+    return concepts
 
-def generate_question_from_concept(concept: str, difficulty: str, question_type: str = "multiple_choice") -> Dict[str, Any]:
-    """Generate a question based on a concept"""
-    question_id = f"q_{datetime.now().timestamp()}"
+def generate_enhanced_questions(text: str, difficulty: str, question_type: str = "mixed") -> List[Dict[str, Any]]:
+    """Generate enhanced questions"""
+    concepts = extract_key_concepts(text, 5)
+    questions = []
     
-    if question_type == "multiple_choice":
-        return {
-            "id": question_id,
-            "type": "multiple_choice",
-            "question": f"What is the significance of {concept}?",
-            "options": [
-                f"{concept} is a fundamental concept in this field",
-                f"{concept} represents a technical specification",
-                f"{concept} is a historical figure",
-                f"{concept} is a recent development"
-            ],
-            "correct_answer": 0,
-            "explanation": f"{concept} is mentioned throughout the text as a key concept.",
-            "difficulty": difficulty,
-            "concept": concept
-        }
-    else:  # short_answer
-        return {
-            "id": question_id,
-            "type": "short_answer",
-            "question": f"Explain {concept} in your own words.",
-            "correct_answer": f"{concept} is an important concept discussed in the material.",
-            "explanation": f"This requires understanding of {concept} from the context.",
-            "difficulty": difficulty,
-            "concept": concept
+    # Multiple Choice Questions
+    if question_type in ["multiple_choice", "mixed"]:
+        for i, concept in enumerate(concepts[:3]):
+            questions.append({
+                "id": f"mcq_{int(time.time())}_{i}",
+                "type": "multiple_choice",
+                "question": f"What is the significance of '{concept['concept']}' in the context?",
+                "options": [
+                    f"It represents a core principle discussed",
+                    f"It's a technical term requiring specialized knowledge",
+                    f"It's mentioned but not explained in detail",
+                    f"It contradicts the main argument"
+                ],
+                "correct_answer": random.randint(0, 3),
+                "explanation": f"This concept appears {concept['frequency']} times and is discussed in context: {concept['context'][:100]}...",
+                "difficulty": difficulty,
+                "concept": concept['concept'],
+                "tags": ["comprehension", "analysis"]
+            })
+    
+    # True/False Questions
+    for i in range(2):
+        questions.append({
+            "id": f"tf_{int(time.time())}_{i}",
+            "type": "true_false",
+            "question": f"The text emphasizes practical applications over theoretical concepts.",
+            "options": ["True", "False"],
+            "correct_answer": random.randint(0, 1),
+            "explanation": "This tests understanding of the text's focus and orientation.",
+            "difficulty": "medium",
+            "tags": ["comprehension", "critical_thinking"]
+        })
+    
+    # Fill in the Blank
+    if len(text) > 100:
+        sentences = re.findall(r'[^.!?]{50,150}[.!?]', text)
+        if sentences:
+            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)
+                    
+                    questions.append({
+                        "id": f"fitb_{int(time.time())}_{i}",
+                        "type": "fill_blank",
+                        "question": f"Complete the sentence: '{blank_sentence}'",
+                        "correct_answer": blank_word,
+                        "explanation": f"The missing word is '{blank_word}', which completes the meaning.",
+                        "difficulty": difficulty,
+                        "tags": ["vocabulary", "context"]
+                    })
+    
+    # Matching Questions
+    questions.append({
+        "id": f"match_{int(time.time())}",
+        "type": "matching",
+        "question": "Match the concepts with their descriptions:",
+        "pairs": [
+            {"left": "Main Argument", "right": "Primary point being made"},
+            {"left": "Supporting Evidence", "right": "Facts or examples backing the argument"},
+            {"left": "Conclusion", "right": "Final summary or implication"}
+        ],
+        "explanation": "Matching concepts helps reinforce understanding of key terms.",
+        "difficulty": difficulty,
+        "tags": ["vocabulary", "relationships"]
+    })
+    
+    return questions
+
+def generate_flashcard_set(text: str, difficulty: str, flashcard_type: str = "concepts") -> List[Dict[str, Any]]:
+    """Generate different types of flashcards"""
+    concepts = extract_key_concepts(text, 15)
+    flashcards = []
+    
+    # Concept Flashcards
+    if flashcard_type in ["concepts", "mixed"]:
+        for concept in concepts[:10]:
+            flashcards.append({
+                "id": f"fc_concept_{int(time.time())}_{hash(concept['concept'])}",
+                "type": "concept",
+                "front": f"What is '{concept['concept']}'?",
+                "back": f"A key concept mentioned in the text.\n\nContext: {concept['context'][:150]}",
+                "hint": f"Appears {concept['frequency']} times in the text",
+                "category": "Key Concepts",
+                "difficulty": "medium",
+                "metadata": {
+                    "frequency": concept['frequency'],
+                    "importance": concept['importance']
+                }
+            })
+    
+    # Definition Flashcards
+    definitions = ["hypothesis", "algorithm", "theory", "methodology", "analysis"]
+    for term in definitions:
+        if term in ENHANCED_VOCABULARY:
+            info = ENHANCED_VOCABULARY[term]
+            flashcards.append({
+                "id": f"fc_def_{int(time.time())}_{term}",
+                "type": "definition",
+                "front": f"Define: {term}",
+                "back": f"{info['definition']}\n\nExample: {info['example']}",
+                "hint": f"Used in {', '.join(info['contexts'])}",
+                "category": "Vocabulary",
+                "difficulty": info['difficulty']
+            })
+    
+    # Question-Answer Flashcards
+    qa_pairs = [
+        {"q": "What is active recall?", "a": "Retrieving information from memory without cues"},
+        {"q": "Define spaced repetition", "a": "Studying at increasing intervals for better retention"},
+        {"q": "What is interleaving?", "a": "Mixing different topics during study sessions"}
+    ]
+    
+    for i, qa in enumerate(qa_pairs):
+        flashcards.append({
+            "id": f"fc_qa_{int(time.time())}_{i}",
+            "type": "qa",
+            "front": qa["q"],
+            "back": qa["a"],
+            "hint": "Study technique",
+            "category": "Learning Methods",
+            "difficulty": "basic"
+        })
+    
+    return flashcards
+
+def create_study_plan(text: str, study_time: int = 60) -> Dict[str, Any]:
+    """Create personalized study plan"""
+    word_count = len(text.split())
+    reading_time = max(5, word_count // 200)  # 200 wpm
+    
+    # Analyze text complexity
+    sentences = re.findall(r'[^.!?]+[.!?]', text)
+    avg_sentence_length = sum(len(s.split()) for s in sentences) / max(1, len(sentences))
+    complexity = "basic" if avg_sentence_length < 15 else "intermediate" if avg_sentence_length < 25 else "advanced"
+    
+    # Generate study plan
+    plan = {
+        "overview": {
+            "word_count": word_count,
+            "estimated_reading_time": f"{reading_time} minutes",
+            "complexity": complexity,
+            "recommended_sessions": max(1, reading_time // 20)
+        },
+        "sessions": []
+    }
+    
+    # Create session breakdown
+    for i in range(min(5, plan["overview"]["recommended_sessions"])):
+        session = {
+            "session": i + 1,
+            "duration": "20 minutes",
+            "focus": ["Preview", "Active Reading", "Note-taking", "Review"][i % 4],
+            "activities": [
+                "Skim headings and summaries",
+                "Read actively with questions in mind",
+                "Take structured notes",
+                "Create flashcards for key terms",
+                "Test recall with practice questions"
+            ][:3],
+            "goals": [
+                "Identify main concepts",
+                "Understand relationships",
+                "Memorize key terms",
+                "Apply knowledge"
+            ][i % 4]
         }
+        plan["sessions"].append(session)
+    
+    return plan
 
-def generate_flashcard_from_concept(concept: str) -> Dict[str, Any]:
-    """Generate a flashcard from a concept"""
+def analyze_vocabulary(text: str) -> Dict[str, Any]:
+    """Analyze vocabulary in text"""
+    words = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
+    total_words = len(words)
+    unique_words = len(set(words))
+    
+    # Find potentially difficult words
+    difficult_words = []
+    for word in set(words):
+        if len(word) > 8 and word not in ["information", "understand", "important"]:
+            difficult_words.append({
+                "word": word,
+                "frequency": words.count(word),
+                "suggested_definition": f"A term meaning {word} in context"
+            })
+    
     return {
-        "id": f"f_{datetime.now().timestamp()}",
-        "front": f"What is {concept}?",
-        "back": f"{concept} is a key concept discussed in the material.",
-        "category": "Key Concepts",
-        "difficulty": "medium",
-        "lastReviewed": None,
-        "nextReview": None,
-        "easeFactor": 2.5
+        "total_words": total_words,
+        "unique_words": unique_words,
+        "vocabulary_richness": round(unique_words / max(1, total_words) * 100, 1),
+        "difficult_words": sorted(difficult_words, key=lambda x: x["frequency"], reverse=True)[:10]
     }
 
 @app.get("/")
 async def root():
-    """Root endpoint with API information"""
+    """Root endpoint"""
     return {
-        "service": "StudyFlow API",
-        "version": "1.0.0",
+        "service": "StudyFlow AI Assistant",
+        "version": "2.0.0",
         "status": "running",
-        "endpoints": {
-            "generate_questions": "POST /api/generate-questions",
-            "generate_flashcards": "POST /api/generate-flashcards",
-            "summarize": "POST /api/summarize",
-            "explain": "POST /api/explain",
-            "upload_pdf": "POST /api/upload-pdf",
-            "health": "GET /health"
-        },
-        "documentation": "/docs"
-    }
-
-@app.get("/health")
-async def health():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "timestamp": datetime.now().isoformat(),
-        "sessions": len(user_sessions)
+        "features": [
+            "PDF/Text processing",
+            "YouTube video summarization",
+            "Question generation (multiple types)",
+            "Flashcard creation",
+            "Vocabulary analysis",
+            "Study planning",
+            "Note creation",
+            "Context analysis"
+        ]
     }
 
-@app.post("/api/generate-questions")
-async def generate_questions(
-    text: str = Form(...),
-    difficulty: str = Form("medium"),
-    mode: str = Form("mixed"),
-    num_questions: int = Form(5)
-):
-    """
-    Generate educational questions from text
-    
-    Args:
-        text: Input text to analyze
-        difficulty: Difficulty level (easy, medium, hard)
-        mode: Question type (theory, practice, mixed, flashcards)
-        num_questions: Number of questions to generate
-    """
-    try:
-        if not text or len(text.strip()) < 100:
-            raise HTTPException(
-                status_code=400,
-                detail="Text too short. Please provide at least 100 characters."
-            )
-        
-        # Validate inputs
-        if difficulty not in ["easy", "medium", "hard"]:
-            difficulty = "medium"
-        
-        if mode not in ["theory", "practice", "mixed", "flashcards"]:
-            mode = "mixed"
-        
-        num_questions = max(1, min(num_questions, 20))  # Limit to 1-20 questions
-        
-        # Extract key concepts from text
-        key_concepts = extract_key_concepts(text, max_concepts=min(num_questions, 10))
-        
-        # Generate questions based on mode
-        questions = []
-        concept_index = 0
-        
-        while len(questions) < num_questions and concept_index < len(key_concepts):
-            if mode == "theory" or mode == "mixed":
-                # Generate theory questions (short answer)
-                questions.append(generate_question_from_concept(
-                    key_concepts[concept_index],
-                    difficulty,
-                    "short_answer"
-                ))
-                concept_index += 1
-                
-                if len(questions) >= num_questions:
-                    break
-            
-            if mode == "practice" or mode == "mixed":
-                # Generate practice questions (multiple choice)
-                questions.append(generate_question_from_concept(
-                    key_concepts[concept_index],
-                    difficulty,
-                    "multiple_choice"
-                ))
-                concept_index += 1
-                
-                if len(questions) >= num_questions:
-                    break
-        
-        # If we don't have enough concepts, add generic questions
-        while len(questions) < num_questions:
-            generic_concept = "the main topic" if len(questions) % 2 == 0 else "key concepts"
-            questions.append(generate_question_from_concept(
-                generic_concept,
-                difficulty,
-                "multiple_choice" if len(questions) % 2 == 0 else "short_answer"
-            ))
-        
-        return {
-            "success": True,
-            "questions": questions[:num_questions],
-            "concepts": key_concepts,
-            "count": len(questions[:num_questions]),
-            "difficulty": difficulty,
-            "mode": mode,
-            "generated_at": datetime.now().isoformat()
-        }
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to generate questions: {str(e)}"
-        )
-
-@app.post("/api/generate-flashcards")
-async def generate_flashcards(
-    text: str = Form(...),
+@app.post("/api/process-content")
+async def process_content(
+    content_type: str = Form(...),
+    content: str = Form(None),
+    file: UploadFile = File(None),
+    youtube_url: str = Form(None),
     difficulty: str = Form("medium")
 ):
-    """
-    Generate flashcards from text
-    
-    Args:
-        text: Input text to analyze
-        difficulty: Difficulty level for flashcards
-    """
+    """Process any type of content (PDF, text, YouTube)"""
     try:
-        if not text or len(text.strip()) < 100:
-            raise HTTPException(
-                status_code=400,
-                detail="Text too short. Please provide at least 100 characters."
-            )
+        extracted_text = ""
+        metadata = {}
         
-        # Extract key concepts
-        key_concepts = extract_key_concepts(text, max_concepts=10)
-        
-        # Generate flashcards
-        flashcards = []
-        for i, concept in enumerate(key_concepts):
-            if i >= 10:  # Limit to 10 flashcards
-                break
-                
-            flashcard = generate_flashcard_from_concept(concept)
+        if content_type == "text" and content:
+            extracted_text = content
+            metadata = {"type": "text", "length": len(content)}
             
-            # Adjust based on difficulty
-            if difficulty == "easy":
-                flashcard["difficulty"] = "easy"
-                flashcard["back"] = f"{concept} is a basic concept mentioned in the text."
-            elif difficulty == "hard":
-                flashcard["difficulty"] = "hard"
-                flashcard["back"] = f"{concept} represents a complex concept requiring deeper understanding."
+        elif content_type == "pdf" and file:
+            contents = await file.read()
+            pdf_file = io.BytesIO(contents)
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
             
-            flashcards.append(flashcard)
-        
-        # Add some generic flashcards if we don't have enough concepts
-        generic_flashcards = [
-            {
-                "id": f"f_gen_{i}",
-                "front": "What is the main topic of this material?",
-                "back": "The text discusses key concepts and principles.",
-                "category": "Overview",
-                "difficulty": difficulty,
-                "lastReviewed": None,
-                "nextReview": None,
-                "easeFactor": 2.5
+            text = ""
+            for i in range(min(10, 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(10, len(pdf_reader.pages))
             }
-            for i in range(max(0, 5 - len(flashcards)))
-        ]
+            
+        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")
         
-        flashcards.extend(generic_flashcards)
+        # Generate all study materials
+        questions = generate_enhanced_questions(extracted_text, difficulty)
+        flashcards = generate_flashcard_set(extracted_text, difficulty)
+        vocabulary = analyze_vocabulary(extracted_text)
+        study_plan = create_study_plan(extracted_text)
+        concepts = extract_key_concepts(extracted_text)
+        
+        # Create session
+        session_id = f"session_{int(time.time())}_{random.randint(1000, 9999)}"
+        user_sessions[session_id] = {
+            "metadata": metadata,
+            "text_preview": extracted_text[:500],
+            "word_count": len(extracted_text.split()),
+            "created_at": datetime.now().isoformat()
+        }
         
         return {
             "success": True,
-            "flashcards": flashcards,
-            "count": len(flashcards),
-            "generated_at": datetime.now().isoformat()
+            "session_id": session_id,
+            "metadata": metadata,
+            "materials": {
+                "questions": {
+                    "total": len(questions),
+                    "by_type": {
+                        "multiple_choice": len([q for q in questions if q["type"] == "multiple_choice"]),
+                        "true_false": len([q for q in questions if q["type"] == "true_false"]),
+                        "fill_blank": len([q for q in questions if q["type"] == "fill_blank"]),
+                        "matching": len([q for q in questions if q["type"] == "matching"])
+                    },
+                    "items": questions
+                },
+                "flashcards": {
+                    "total": len(flashcards),
+                    "by_type": {
+                        "concept": len([f for f in flashcards if f["type"] == "concept"]),
+                        "definition": len([f for f in flashcards if f["type"] == "definition"]),
+                        "qa": len([f for f in flashcards if f["type"] == "qa"])
+                    },
+                    "items": flashcards
+                },
+                "vocabulary": vocabulary,
+                "study_plan": study_plan,
+                "key_concepts": concepts,
+                "summary": extracted_text[:300] + ("..." if len(extracted_text) > 300 else "")
+            }
         }
         
     except HTTPException:
         raise
     except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to generate flashcards: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
 
-@app.post("/api/summarize")
-async def summarize(
-    text: str = Form(...),
-    difficulty: str = Form("medium")
+@app.post("/api/analyze-word")
+async def analyze_word(
+    word: str = Form(...),
+    context: str = Form("")
 ):
-    """
-    Generate a summary of the text
-    
-    Args:
-        text: Text to summarize
-        difficulty: Reading level for summary
-    """
+    """Analyze a word with context"""
     try:
-        if not text:
-            raise HTTPException(
-                status_code=400,
-                detail="No text provided."
-            )
+        word = word.lower().strip()
         
-        # Simple summarization - first 200 words
-        words = text.split()
-        word_count = len(words)
-        
-        if word_count < 100:
-            summary = text
+        # Check enhanced vocabulary
+        if word in ENHANCED_VOCABULARY:
+            definition = ENHANCED_VOCABULARY[word]
         else:
-            # Take first 10% of text for summary
-            summary_length = max(50, min(500, word_count // 10))
-            summary_words = words[:summary_length]
-            summary = ' '.join(summary_words)
-            if word_count > summary_length:
-                summary += "..."
-        
-        # Adjust summary based on difficulty
-        if difficulty == "easy":
-            intro = "This is a simple summary:\n\n"
-        elif difficulty == "hard":
-            intro = "Detailed analysis:\n\n"
-        else:
-            intro = "Summary:\n\n"
+            # Generate contextual definition
+            definition = {
+                "definition": f"A term used in this context meaning '{word}'",
+                "example": f"In your material, '{word}' appears in context",
+                "contexts": ["general"],
+                "difficulty": "unknown"
+            }
         
-        # Add metadata
-        reading_time = max(1, word_count // 200)  # 200 words per minute
+        # If context provided, enhance analysis
+        contextual_info = {}
+        if context:
+            # Find word in context
+            sentences = re.findall(r'[^.!?]*\b' + re.escape(word) + r'\b[^.!?]*[.!?]', context, re.IGNORECASE)
+            if sentences:
+                contextual_info = {
+                    "example_sentence": sentences[0],
+                    "occurrences": len(sentences),
+                    "surrounding_words": list(set(re.findall(r'\b\w+\b', sentences[0])))[:5]
+                }
         
-        full_summary = f"""{intro}{summary}
-
-Key Information:
-• Word count: {word_count}
-• Estimated reading time: {reading_time} minute{'s' if reading_time != 1 else ''}
-• Key concepts: {', '.join(extract_key_concepts(text, 3))}
-
-Study recommendations:
-1. Read through the summary first
-2. Identify unfamiliar terms
-3. Create flashcards for key concepts
-4. Test your understanding with practice questions"""
-
         return {
             "success": True,
-            "summary": full_summary,
-            "word_count": word_count,
-            "reading_time": reading_time,
-            "generated_at": datetime.now().isoformat()
+            "word": word,
+            "definition": definition,
+            "contextual_info": contextual_info,
+            "suggested_flashcards": [
+                {
+                    "front": f"Define: {word}",
+                    "back": definition["definition"],
+                    "category": "Vocabulary"
+                },
+                {
+                    "front": f"Use '{word}' in a sentence",
+                    "back": contextual_info.get("example_sentence", f"Example using '{word}'"),
+                    "category": "Usage"
+                }
+            ]
         }
         
-    except HTTPException:
-        raise
     except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to generate summary: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=f"Word analysis error: {str(e)}")
 
-@app.post("/api/explain")
-async def explain(
-    topic: str = Form(...),
-    context: str = Form("")
+@app.post("/api/create-note")
+async def create_note(
+    title: str = Form(...),
+    content: str = Form(...),
+    tags: List[str] = Form([]),
+    session_id: str = Form(None)
 ):
-    """
-    Explain a specific topic
-    
-    Args:
-        topic: Topic to explain
-        context: Context from the material
-    """
+    """Create structured notes"""
     try:
-        if not topic:
-            raise HTTPException(
-                status_code=400,
-                detail="No topic provided."
-            )
+        note_id = f"note_{int(time.time())}_{random.randint(1000, 9999)}"
+        
+        # Extract key points automatically
+        sentences = re.findall(r'[^.!?]+[.!?]', content)
+        key_points = sentences[:5]  # First 5 sentences as key points
+        
+        # Generate summary
+        summary = content[:150] + ("..." if len(content) > 150 else "")
+        
+        note = {
+            "id": note_id,
+            "title": title,
+            "content": content,
+            "summary": summary,
+            "key_points": key_points,
+            "tags": tags + ["auto-generated"],
+            "created_at": datetime.now().isoformat(),
+            "session_id": session_id,
+            "word_count": len(content.split())
+        }
         
-        # Generate explanation based on topic
-        if context and len(context) > 100:
-            # If we have context, create a more specific explanation
-            explanation = f"""**Explanation of {topic}:**
-
-Based on the provided material, {topic} appears to be an important concept. 
-
-The text mentions this in the context of: "{context[:200]}..."
-
-Key points about {topic}:
-• Likely relates to the main themes discussed
-• May be connected to other concepts in the text
-• Understanding this is important for grasping the material
-
-To better understand {topic}, try:
-1. Looking for definitions in the text
-2. Finding examples of how it's used
-3. Creating a flashcard to review later"""
-        else:
-            # Generic explanation
-            explanation = f"""**Explanation of {topic}:**
-
-{topic} is a concept that requires understanding. In learning materials, concepts like this typically:
-
-• Represent important ideas or principles
-• Connect to other topics in meaningful ways
-• Have practical applications or implications
-
-To master {topic}:
-1. Read about it in multiple sources
-2. Try explaining it in your own words
-3. Create practice questions about it
-4. Review it regularly using spaced repetition"""
-
         return {
             "success": True,
-            "topic": topic,
-            "explanation": explanation,
-            "generated_at": datetime.now().isoformat()
+            "note": note,
+            "suggested_actions": [
+                "Create flashcards from key points",
+                "Generate quiz questions",
+                "Add to study plan"
+            ]
         }
         
-    except HTTPException:
-        raise
     except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to generate explanation: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=f"Note creation error: {str(e)}")
 
-@app.post("/api/upload-pdf")
-async def upload_pdf(file: UploadFile = File(...)):
-    """
-    Extract text from uploaded PDF
-    
-    Args:
-        file: PDF file to process
-    """
+@app.post("/api/generate-practice-test")
+async def generate_practice_test(
+    session_id: str = Form(...),
+    test_type: str = Form("comprehensive"),
+    question_count: int = Form(10)
+):
+    """Generate a practice test"""
     try:
-        # Check file type
-        if not file.filename.lower().endswith('.pdf'):
-            raise HTTPException(
-                status_code=400,
-                detail="Only PDF files are supported."
-            )
-        
-        # Read file content
-        contents = await file.read()
-        
-        if len(contents) > 10 * 1024 * 1024:  # 10MB limit
-            raise HTTPException(
-                status_code=400,
-                detail="File too large. Maximum size is 10MB."
-            )
-        
-        # Extract text from PDF
-        pdf_file = io.BytesIO(contents)
-        pdf_reader = PyPDF2.PdfReader(pdf_file)
-        
-        if len(pdf_reader.pages) == 0:
-            raise HTTPException(
-                status_code=400,
-                detail="PDF file appears to be empty or corrupted."
-            )
-        
-        # Extract text from pages (limit to first 10 pages for performance)
-        text = ""
-        pages_to_extract = min(10, len(pdf_reader.pages))
-        
-        for i in range(pages_to_extract):
-            try:
-                page_text = pdf_reader.pages[i].extract_text()
-                if page_text:
-                    text += page_text + "\n\n"
-            except Exception as e:
-                print(f"Error extracting page {i+1}: {e}")
-                continue
+        if session_id not in user_sessions:
+            raise HTTPException(status_code=404, detail="Session not found")
         
-        if not text.strip():
-            raise HTTPException(
-                status_code=400,
-                detail="Could not extract text from PDF. The file might be scanned or image-based."
-            )
+        # In production, fetch from database
+        # For now, generate sample test
+        test_id = f"test_{int(time.time())}"
         
-        # Extract metadata
-        word_count = len(text.split())
+        questions = []
+        question_types = ["multiple_choice", "true_false", "fill_blank", "matching"]
         
-        # Store session
-        session_id = f"session_{datetime.now().timestamp()}"
-        user_sessions[session_id] = {
-            "filename": file.filename,
-            "size": len(contents),
-            "pages": len(pdf_reader.pages),
-            "extracted_pages": pages_to_extract,
-            "word_count": word_count,
-            "uploaded_at": datetime.now().isoformat()
+        for i in range(min(question_count, 20)):
+            q_type = random.choice(question_types)
+            
+            if q_type == "multiple_choice":
+                questions.append({
+                    "id": f"test_q_{i}",
+                    "type": "multiple_choice",
+                    "question": f"Practice question #{i+1}: What is the main focus?",
+                    "options": ["Concept A", "Concept B", "Concept C", "Concept D"],
+                    "correct_answer": random.randint(0, 3),
+                    "points": 1,
+                    "explanation": "This tests understanding of key concepts"
+                })
+            elif q_type == "true_false":
+                questions.append({
+                    "id": f"test_q_{i}",
+                    "type": "true_false",
+                    "question": f"Statement #{i+1}: The text emphasizes practical applications.",
+                    "options": ["True", "False"],
+                    "correct_answer": random.randint(0, 1),
+                    "points": 1,
+                    "explanation": "True/False questions test binary understanding"
+                })
+        
+        test = {
+            "id": test_id,
+            "session_id": session_id,
+            "type": test_type,
+            "questions": questions,
+            "total_points": len(questions),
+            "time_limit": len(questions) * 60,  # 1 minute per question
+            "instructions": "Answer all questions. You can review your answers before submitting."
         }
         
         return {
             "success": True,
-            "session_id": session_id,
-            "filename": file.filename,
-            "text": text,
-            "text_preview": text[:1000],
-            "pages": len(pdf_reader.pages),
-            "extracted_pages": pages_to_extract,
-            "word_count": word_count,
-            "file_size": len(contents),
-            "uploaded_at": datetime.now().isoformat()
+            "test": test,
+            "recommendations": {
+                "preparation": "Review key concepts before starting",
+                "time_management": f"Allocate ~{len(questions)} minutes",
+                "strategy": "Answer easier questions first"
+            }
         }
         
-    except HTTPException:
-        raise
     except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to process PDF: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=f"Test generation error: {str(e)}")
 
 @app.get("/api/session/{session_id}")
-async def get_session(session_id: str):
-    """Get information about a session"""
+async def get_session_details(session_id: str):
+    """Get detailed session information"""
     if session_id not in user_sessions:
         raise HTTPException(status_code=404, detail="Session not found")
     
+    session = user_sessions[session_id]
     return {
         "success": True,
-        "session": user_sessions[session_id]
+        "session": session,
+        "analytics": {
+            "duration": "N/A",
+            "completion": "0%",
+            "performance": "Not assessed"
+        }
     }
 
-@app.delete("/api/session/{session_id}")
-async def delete_session(session_id: str):
-    """Delete a session"""
-    if session_id in user_sessions:
-        del user_sessions[session_id]
-        return {"success": True, "message": "Session deleted"}
-    else:
-        raise HTTPException(status_code=404, detail="Session not found")
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
 
 if __name__ == "__main__":
     import uvicorn