Create an AI Interview Bot: Transform PDFs or Webpages into Quizzes

🎯 Introduction

Picture this: You have a research paper to study for tomorrow's interview, or you found an amazing blog post that covers exactly what you need to know. But how do you test if you actually understood it?

That's where the AI-powered Interview Bot comes in! This isn't just another study tool but your personal AI interviewer that reads your documents, understands the content, and creates customized questions to test your knowledge. Best part? It gives you real-time scores and personalized feedback to help you improve.

Today, we'll build a complete system that can:

• 📄 Read PDF documents (up to 100 pages)

• 🌐 Extract content from websites or blogs

• 🤖 Generate intelligent questions using AI

• 📊 Evaluate your answers and provide scores

• 💡 Give personalized feedback to help you improve

🧠 Understanding the AI Models

Before we dive into the code, let's understand the AI models that make this possible.

1. Question Generation Model: T5-Base

Think of this as your AI partner who reads the content and comes up with questions.

What it does:

• Reads chunks of text from your document

• Understands the main concepts

• Generates relevant questions that test your understanding

How it works: The T5 (Text-to-Text Transfer Transformer) model is like a smart student who has read millions of books. When you give it text and say "generate question:", it creates questions based on the most important parts of that text.

Example:

• Input Text: "Machine learning is a subset of artificial intelligence that enables computers to learn from data without being explicitly programmed."

• Generated Question: "What is machine learning and how does it relate to artificial intelligence?"

2. Answer Evaluation Model: Sentence Transformers

This is like your AI examiner who checks if your answer is correct.

What it does:

• Converts your answer into a mathematical representation (embedding)

• Compares it with the original content

• Gives you a similarity score

How it works: The model creates "embeddings" – think of them as fingerprints for sentences. Similar sentences have similar fingerprints. When you answer a question, it compares your answer's fingerprint with the original content's fingerprint.

Example:

• Original text: "Python is a programming language"

• Your answer: "Python is used for coding"

• Result: High similarity score (both talk about Python and programming)

3. Text Processing Model: BART

This is your AI summarizer that helps process long documents.

What it does:

• Breaks down long texts into manageable chunks

• Identifies the most important information

• Helps organize content for question generation

🔧 Building the Bot

Step 1: Setting Up the Environment

First, we need to install all the required tools. It's like setting up your workshop before building something amazing!

# Install all the AI tools we need
!pip install gradio transformers torch PyPDF2 requests beautifulsoup4 sentence-transformers accelerate

• Gradio: Creates the web interface

• Transformers: Provides access to AI models

• PyPDF2: Reads PDF files

• BeautifulSoup4: Extracts text from websites

• Sentence-Transformers: Evaluates answer similarity

Step 2: Creating the AI Brain

The InterviewBot class is the heart of our system. Think of it as the brain that coordinates everything.

class InterviewBot:
    def __init__(self):
        # Initialize all the AI models
        self.init_models()

        # Storage for questions and answers
        self.questions = []
        self.user_answers = []
        self.scores = []

Key Components:

1. Content Processor: Reads PDFs and websites

2. Question Generator: Creates questions from content

3. Answer Evaluator: Scores your responses

4. Feedback System: Provides personalized tips

Step 3: Processing Different Content Types

Our bot can handle both PDFs and web content. Here's how:

For PDFs:

def extract_pdf_text(self, pdf_file):
    # Convert the uploaded file into readable text
    # Handle different file formats gracefully
    # Extract text from each page

For Websites:

def extract_web_content(self, url):
    # Fetch the webpage
    # Remove ads, menus, and irrelevant content
    # Extract only the main article text

Step 4: Smart Question Generation

The AI reads your content and creates questions:

def generate_questions(self, chunks, num_questions=10):
    # Break content into chunks
    # For each chunk, ask AI to generate a question
    # Create a question database with context

The Process:

1. Chunk the Text: Break large documents into smaller, manageable pieces

2. Select Diverse Content: Choose chunks that cover different topics

3. Generate Questions: Use AI to create relevant questions

4. Store Context: Keep track of what each question is about

Step 5: Intelligent Answer Evaluation

When you submit an answer, the AI evaluates it using two methods:

Method 1: Semantic Similarity

• Converts your answer into mathematical form

• Compares it with the original content

• Gives a similarity percentage

Method 2: Keyword Matching

• Look for important terms in your answer

• Checks if you used relevant vocabulary

• Rewards specific, detailed responses

Final Score Calculation:

Final Score = (Similarity Score × 70%) + (Keyword Score × 30%)

✅Complete code to test

!pip install gradio transformers torch PyPDF2 requests beautifulsoup4 sentence-transformers accelerate
!pip install --upgrade huggingface_hub

import gradio as gr
import PyPDF2
import requests
from bs4 import BeautifulSoup
import re
import random
from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
import torch
from sentence_transformers import SentenceTransformer
import json
from typing import List, Dict, Tuple
import numpy as np

class InterviewBot:
    def __init__(self):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        print(f"Using device: {self.device}")

        # Initialize models
        self.init_models()

        # Storage for content and questions
        self.content_chunks = []
        self.questions = []
        self.current_question_idx = 0
        self.user_answers = []
        self.scores = []

    def init_models(self):
        """Initialize Hugging Face models for question generation and evaluation"""
        try:
            # Question generation model
            print("Loading question generation model...")
            self.qg_tokenizer = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-question-generation-ap")
            self.qg_model = AutoModelForSeq2SeqLM.from_pretrained("mrm8488/t5-base-finetuned-question-generation-ap")
            self.qg_model.to(self.device)

            # Text similarity model for answer evaluation
            print("Loading similarity model...")
            self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')

            # Text summarization for content processing
            print("Loading summarization pipeline...")
            self.summarizer = pipeline("summarization", 
                                     model="facebook/bart-large-cnn",
                                     device=0 if self.device == "cuda" else -1)

            print("All models loaded successfully!")

        except Exception as e:
            print(f"Error loading models: {e}")
            # Fallback to smaller models
            self.init_fallback_models()

    def init_fallback_models(self):
        """Initialize smaller models if main models fail to load"""
        print("Loading fallback models...")
        self.qg_tokenizer = AutoTokenizer.from_pretrained("t5-small")
        self.qg_model = AutoModelForSeq2SeqLM.from_pretrained("t5-small")
        self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
        self.summarizer = pipeline("summarization", model="t5-small", device=-1)

    def extract_pdf_text(self, pdf_file) -> str:
        """Extract text from uploaded PDF file"""
        try:
            import io

            # Handle different input types from Gradio
            if isinstance(pdf_file, bytes):
                # If it's bytes, create a BytesIO object
                pdf_stream = io.BytesIO(pdf_file)
            elif hasattr(pdf_file, 'read'):
                # If it's a file-like object, read it
                pdf_stream = io.BytesIO(pdf_file.read())
            elif isinstance(pdf_file, str):
                # If it's a file path, open it
                with open(pdf_file, 'rb') as f:
                    pdf_stream = io.BytesIO(f.read())
            else:
                # Try to use it directly
                pdf_stream = pdf_file

            pdf_reader = PyPDF2.PdfReader(pdf_stream)
            text = ""

            # Limit to first 50 pages memory constraints
            max_pages = min(50, len(pdf_reader.pages))

            for page_num in range(max_pages):
                page = pdf_reader.pages[page_num]
                page_text = page.extract_text()
                if page_text.strip():  # Only add non-empty pages
                    text += page_text + "\n"

            if not text.strip():
                return "Error extracting PDF: No readable text found in the PDF"

            return text
        except Exception as e:
            return f"Error extracting PDF: {str(e)}"

    def extract_web_content(self, url: str) -> str:
        """Extract text content from web URL"""
        try:
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
            }
            response = requests.get(url, headers=headers, timeout=10)
            response.raise_for_status()

            soup = BeautifulSoup(response.content, 'html.parser')

            # Remove script and style elements
            for script in soup(["script", "style"]):
                script.decompose()

            # Extract text from main content areas
            content_tags = soup.find_all(['p', 'h1', 'h2', 'h3', 'h4', 'article', 'div'])
            text = ""
            for tag in content_tags:
                if tag.get_text().strip():
                    text += tag.get_text().strip() + "\n"

            return text
        except Exception as e:
            return f"Error extracting web content: {str(e)}"

    def chunk_text(self, text: str, chunk_size: int = 1000) -> List[str]:
        """Split text into manageable chunks"""
        # Clean text
        text = re.sub(r'\s+', ' ', text).strip()

        # Split into sentences
        sentences = re.split(r'[.!?]+', text)

        chunks = []
        current_chunk = ""

        for sentence in sentences:
            sentence = sentence.strip()
            if not sentence:
                continue

            if len(current_chunk) + len(sentence) < chunk_size:
                current_chunk += sentence + ". "
            else:
                if current_chunk:
                    chunks.append(current_chunk.strip())
                current_chunk = sentence + ". "

        if current_chunk:
            chunks.append(current_chunk.strip())

        return chunks

    def generate_questions(self, chunks: List[str], num_questions: int = 10) -> List[Dict]:
        """Generate questions from text chunks"""
        questions = []

        # Select diverse chunks
        selected_chunks = random.sample(chunks, min(len(chunks), num_questions * 2))

        for i, chunk in enumerate(selected_chunks[:num_questions]):
            try:
                # Prepare input for question generation
                input_text = f"generate question: {chunk}"
                inputs = self.qg_tokenizer.encode(input_text, 
                                                return_tensors="pt", 
                                                max_length=512, 
                                                truncation=True)
                inputs = inputs.to(self.device)

                # Generate question
                with torch.no_grad():
                    outputs = self.qg_model.generate(inputs, 
                                                   max_length=64,
                                                   num_beams=3,
                                                   do_sample=True,
                                                   temperature=0.7)

                question = self.qg_tokenizer.decode(outputs[0], skip_special_tokens=True)

                # Extract key information for answer evaluation
                key_phrases = self.extract_key_phrases(chunk)

                questions.append({
                    'question': question,
                    'context': chunk,
                    'key_phrases': key_phrases,
                    'question_id': i + 1
                })

            except Exception as e:
                print(f"Error generating question {i+1}: {e}")
                # Fallback question
                questions.append({
                    'question': f"What is the main point discussed in this section?",
                    'context': chunk,
                    'key_phrases': self.extract_key_phrases(chunk),
                    'question_id': i + 1
                })

        return questions

    def extract_key_phrases(self, text: str) -> List[str]:
        """Extract key phrases from text for answer evaluation"""
        # Simple keyword extraction
        words = re.findall(r'\b[A-Za-z]{4,}\b', text.lower())

        # Remove common words
        stop_words = {'this', 'that', 'with', 'have', 'will', 'from', 'they', 'been', 
                     'were', 'said', 'each', 'which', 'their', 'time', 'would', 'there'}

        key_words = [word for word in words if word not in stop_words]

        # Get most frequent words
        word_freq = {}
        for word in key_words:
            word_freq[word] = word_freq.get(word, 0) + 1

        # Return top keywords
        sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
        return [word for word, freq in sorted_words[:10]]

    def evaluate_answer(self, question_data: Dict, user_answer: str) -> float:
        """Evaluate user answer and return score (0-100)"""
        if not user_answer.strip():
            return 0.0

        try:
            # Method 1: Semantic similarity
            context_embedding = self.similarity_model.encode([question_data['context']])
            answer_embedding = self.similarity_model.encode([user_answer])

            similarity_score = np.dot(context_embedding[0], answer_embedding[0]) / (
                np.linalg.norm(context_embedding[0]) * np.linalg.norm(answer_embedding[0])
            )

            # Method 2: Keyword matching
            user_words = set(re.findall(r'\b[A-Za-z]{3,}\b', user_answer.lower()))
            key_phrases = set(question_data['key_phrases'])

            keyword_overlap = len(user_words.intersection(key_phrases)) / max(len(key_phrases), 1)

            # Combined score
            final_score = (similarity_score * 0.7 + keyword_overlap * 0.3) * 100

            return min(100.0, max(0.0, final_score))

        except Exception as e:
            print(f"Error evaluating answer: {e}")
            # Fallback scoring
            return len(user_answer.split()) * 5 if len(user_answer.split()) <= 20 else 100

    def process_content(self, pdf_file=None, web_url="", num_questions=10):
        """Process uploaded content and generate questions"""
        try:
            # Extract text based on input type
            if pdf_file is not None:
                text = self.extract_pdf_text(pdf_file)
                source = "PDF"
            elif web_url.strip():
                text = self.extract_web_content(web_url.strip())
                source = "Web URL"
            else:
                return "Please provide either a PDF file or a web URL.", "", ""

            if text.startswith("Error"):
                return text, "", ""

            # Process text
            self.content_chunks = self.chunk_text(text)

            if not self.content_chunks:
                return "No valid content found to generate questions.", "", ""

            # Generate questions
            self.questions = self.generate_questions(self.content_chunks, num_questions)
            self.current_question_idx = 0
            self.user_answers = []
            self.scores = []

            if not self.questions:
                return "Failed to generate questions from the content.", "", ""

            summary = f"Successfully processed {source}!\n"
            summary += f"Extracted {len(self.content_chunks)} content chunks\n"
            summary += f"Generated {len(self.questions)} questions\n"
            summary += "Click 'Start Quiz' to begin the interview!"

            first_question = f"Question 1/{len(self.questions)}:\n{self.questions[0]['question']}"

            return summary, first_question, ""

        except Exception as e:
            return f"Error processing content: {str(e)}", "", ""

    def submit_answer(self, user_answer):
        """Submit answer and get next question"""
        if not self.questions:
            return "No quiz in progress. Please upload content first.", "", "No active quiz"

        if self.current_question_idx >= len(self.questions):
            return "Quiz completed!", "", self.get_final_results()

        # Evaluate current answer
        current_question = self.questions[self.current_question_idx]
        score = self.evaluate_answer(current_question, user_answer)

        self.user_answers.append(user_answer)
        self.scores.append(score)

        self.current_question_idx += 1

        # Prepare response
        feedback = f"Answer {self.current_question_idx} submitted! Score: {score:.1f}/100\n\n"

        if self.current_question_idx < len(self.questions):
            # Next question
            next_question = self.questions[self.current_question_idx]
            question_text = f"Question {self.current_question_idx + 1}/{len(self.questions)}:\n{next_question['question']}"
            return feedback, question_text, self.get_current_progress()
        else:
            # Quiz completed
            return feedback + "Quiz completed!", "🎉 Interview Complete!", self.get_final_results()

    def get_current_progress(self):
        """Get current progress summary with dynamic tips"""
        if not self.scores:
            return "No answers submitted yet"

        avg_score = sum(self.scores) / len(self.scores)
        progress = f"Progress: {len(self.scores)}/{len(self.questions)} questions answered\n"
        progress += f"Average Score: {avg_score:.1f}/100\n"
        progress += f"Latest Score: {self.scores[-1]:.1f}/100\n\n"

        # Add dynamic tips based on current performance
        if len(self.scores) >= 3:
            progress += self.get_live_tips()

        return progress

    def get_live_tips(self):
        """Generate live tips during the quiz based on current performance"""
        recent_scores = self.scores[-3:]  # Last 3 answers
        avg_recent = sum(recent_scores) / len(recent_scores)

        tips = "🎯 **Live Performance Tips:**\n"

        if avg_recent >= 80:
            tips += "• Excellent work! Keep providing detailed answers\n"
        elif avg_recent >= 60:
            tips += "• Good progress! Try adding more specific examples\n"
        elif avg_recent >= 40:
            tips += "• Focus on key terms from the source material\n"
        else:
            tips += "• Take time to carefully read the content before answering\n"

        # Trend analysis
        if len(recent_scores) >= 2:
            if recent_scores[-1] > recent_scores[-2]:
                tips += "• 📈 Improving! You're on the right track\n"
            elif recent_scores[-1] < recent_scores[-2]:
                tips += "• 📉 Refocus needed - slow down and think carefully\n"

        return tips

    def get_final_results(self):
        """Generate final quiz results with personalized feedback"""
        if not self.scores:
            return "No quiz completed yet"

        total_questions = len(self.scores)
        avg_score = sum(self.scores) / total_questions

        # Performance categorization
        if avg_score >= 80:
            performance = "Excellent! 🌟"
        elif avg_score >= 60:
            performance = "Good! 👍"
        elif avg_score >= 40:
            performance = "Fair 📚"
        else:
            performance = "Needs Improvement 💪"

        results = f"""
🎯 INTERVIEW RESULTS 🎯

Total Questions: {total_questions}
Average Score: {avg_score:.1f}/100
Performance: {performance}

📊 Detailed Scores:
"""

        for i, score in enumerate(self.scores, 1):
            results += f"Question {i}: {score:.1f}/100\n"

        results += f"\n🏆 Best Score: {max(self.scores):.1f}/100"
        results += f"\n📉 Lowest Score: {min(self.scores):.1f}/100"

        # Personalized improvement suggestions
        results += "\n\n" + self.get_personalized_tips()

        return results

    def get_personalized_tips(self):
        """Generate personalized tips based on performance patterns"""
        if not self.scores:
            return "💡 Complete a quiz to get personalized tips!"

        avg_score = sum(self.scores) / len(self.scores)
        low_scores = [s for s in self.scores if s < 50]
        high_scores = [s for s in self.scores if s >= 80]

        tips = "💡 **Personalized Improvement Tips:**\n"

        # Analyze performance patterns
        if avg_score >= 80:
            tips += "🌟 **Excellent Performance!**\n"
            tips += "• You're demonstrating strong comprehension\n"
            tips += "• Continue providing detailed, context-rich answers\n"
            tips += "• Try tackling more complex content to challenge yourself\n"

        elif avg_score >= 60:
            tips += "✅ **Good Foundation - Ready to Excel!**\n"
            if len(low_scores) > 0:
                tips += "• Focus on questions where you scored below 50 - review that content\n"
            tips += "• Add more specific examples from the source material\n"
            tips += "• Try to connect concepts across different sections\n"

        elif avg_score >= 40:
            tips += "📚 **Building Understanding - You're on the Right Track!**\n"
            tips += "• Spend more time reading each question carefully\n"
            tips += "• Include key terms and phrases from the original content\n"
            tips += "• Structure answers with main points first, then details\n"
            if len(low_scores) > len(self.scores) // 2:
                tips += "• Consider re-reading the source material before answering\n"

        else:
            tips += "💪 **Focus Areas for Improvement:**\n"
            tips += "• Take time to thoroughly read the source content first\n"
            tips += "• Look for main ideas and key concepts in each section\n"
            tips += "• Practice paraphrasing content in your own words\n"
            tips += "• Don't rush - quality over speed in your responses\n"

        # Additional specific tips based on patterns
        score_variance = max(self.scores) - min(self.scores)
        if score_variance > 40:
            tips += "• **Consistency Tip**: Your scores vary widely - focus on maintaining steady quality across all answers\n"

        if len([s for s in self.scores if s < 30]) > 0:
            tips += "• **Comprehension Tip**: Some very low scores suggest reviewing the content more carefully before answering\n"

        # Answer length analysis (if we tracked that)
        recent_trend = self.scores[-3:] if len(self.scores) >= 3 else self.scores
        if len(recent_trend) > 1:
            if recent_trend[-1] > recent_trend[0]:
                tips += "• **Positive Trend**: Your recent answers are improving - keep up the momentum!\n"
            elif recent_trend[-1] < recent_trend[0]:
                tips += "• **Focus Needed**: Your recent scores are declining - take a moment to refocus\n"

        return tips

# Initialize the bot
bot = InterviewBot()

# Create Gradio interface
def create_interface():
    with gr.Blocks(title="Interview Bot - PDF/Web Quiz Generator", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🤖 Interview Bot - PDF/Web Content Quiz Generator

        Upload a PDF or provide a web URL to generate an interactive quiz for interview practice!

        **Features:**
        - Extracts content from PDFs (up to 50 pages) or web pages
        - Generates intelligent questions using AI
        - Evaluates your answers with semantic analysis
        - Provides real-time scoring and feedback
        """)

        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 📤 Content Input")

                pdf_input = gr.File(
                    label="Upload PDF File",
                    file_types=[".pdf"]
                )

                web_input = gr.Textbox(
                    label="Or Enter Web URL",
                    placeholder="https://example.com/article",
                    lines=1
                )

                num_questions = gr.Slider(
                    minimum=5,
                    maximum=20,
                    value=10,
                    step=1,
                    label="Number of Questions"
                )

                process_btn = gr.Button("🚀 Process Content & Generate Quiz", variant="primary")

            with gr.Column(scale=2):
                gr.Markdown("### 📝 Quiz Interface")

                status_output = gr.Textbox(
                    label="Status",
                    lines=4,
                    value="Upload a PDF or enter a web URL to start!"
                )

                question_output = gr.Textbox(
                    label="Current Question",
                    lines=3,
                    value="Questions will appear here..."
                )

                answer_input = gr.Textbox(
                    label="Your Answer",
                    lines=4,
                    placeholder="Type your answer here..."
                )

                submit_btn = gr.Button("✅ Submit Answer", variant="secondary")

                with gr.Row():
                    progress_output = gr.Textbox(
                        label="Progress & Scoring",
                        lines=6,
                        value="Quiz progress will be shown here..."
                    )

        # Event handlers
        process_btn.click(
            fn=bot.process_content,
            inputs=[pdf_input, web_input, num_questions],
            outputs=[status_output, question_output, progress_output]
        )

        submit_btn.click(
            fn=bot.submit_answer,
            inputs=[answer_input],
            outputs=[status_output, question_output, progress_output]
        ).then(
            fn=lambda: "",  # Clear answer input after submission
            outputs=[answer_input]
        )

        # Dynamic tips section
        with gr.Row():
            tips_display = gr.Markdown("""
            ### 💡 Dynamic Performance Tips:
            Personalized tips will appear here based on your quiz performance!
            Start answering questions to get customized feedback.
            """)

        # Update tips based on progress
        def update_tips():
            if bot.scores:
                return bot.get_personalized_tips()
            else:
                return """
### 💡 Getting Started Tips:
- Read each question carefully
- Think about the main concepts from the source
- Provide specific, detailed answers
- Use terminology from the original content
"""

        submit_btn.click(
            fn=update_tips,
            outputs=[tips_display]
        )

    return demo

# Launch the application
if __name__ == "__main__":
    # Create and launch the interface
    demo = create_interface()

    # For Google Colab
    demo.launch()

    print("🚀 Interview Bot is ready!")
    print("Upload a PDF or enter a web URL to start generating your personalized quiz!")

Try out the sample app from the code at https://huggingface.co/spaces/divivetri/interview_bot.

🚀 Advanced Features

1. Adaptive Difficulty

The system learns from your performance and adjusts:

• If you're doing well, it focuses on complex concepts

• If you're struggling, it provides more basic questions

2. Personalized Feedback

Instead of generic tips, you get specific advice:

• High performers: "Great job! Try connecting concepts across sections."

• Struggling students: "Focus on key terms and main idea.s"

3. Performance Analytics

Track your progress with detailed insights:

• Question-by-question scores

• Improvement trends

• Consistency patterns

• Weak area identification

🔍 Understanding Your Scores

Score Ranges:

• 90-100: Exceptional understanding

• 80-89: Strong grasp of concepts

• 70-79: Good comprehension with minor gaps

• 60-69: Fair understanding, needs improvement

• Below 60: Requires focused study

What the AI Looks For:

1. Relevance: Does your answer relate to the question?

2. Accuracy: Are your facts correct?

3. Completeness: Did you cover the main points?

4. Specificity: Are you using precise language?

🛠️ Limitations - Lookout for some common errors

PDF :

• Error reading PDF: Try a different PDF or convert to text first

• No text extracted: PDF might be image-based (scanned)

• Memory issues: Reduce the number of questions or use smaller documents

Web Content Issues:

• Can't access website: Check if URL is correct and publicly accessible

• No content found: Some sites block automated access

• Poor question quality: Try websites with clear, well-structured content

🎊 Wrap Up!

Congratulations! You've just built an AI-powered interview bot that can transform any document or webpage into an interactive learning experience. This isn't just a cool project – it's a practical tool that can revolutionize how you study and prepare for interviews.

📚 References and Learning Resources

AI Models and Libraries:

1. Hugging Face Transformers - Wolf, T., et al. (2020). "Transformers: State-of-the-art natural language processing." Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations.

2. T5 Model - Raffel, C., et al. (2020). "Exploring the limits of transfer learning with a unified text-to-text transformer." Journal of Machine Learning Research, 21(140), 1-67.

3. Sentence Transformers - Reimers, N., & Gurevych, I. (2019). "Sentence-BERT: Sentence embeddings using Siamese BERT-networks." Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing.

4. BART Model - Lewis, M., et al. (2020). "BART: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension." Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics.

Python Libraries:

• Gradio - Abid, A., et al. (2019). "Gradio: Hassle-free sharing and testing of ML models in the wild." arXiv preprint arXiv:1906.02569.

• PyPDF2 - Community-maintained PDF processing library

• BeautifulSoup4 - Richardson, L. Beautiful Soup Documentation

• PyTorch - Paszke, A., et al. (2019). "PyTorch: An imperative style, high-performance deep learning library." Advances in neural information processing systems.

Educational Resources:

• Question Generation Techniques - Du, X., et al. (2017). "Learning to ask: Neural question generation for reading comprehension." Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics.

• Answer Evaluation Methods - Mohler, M., et al. (2011). "Learning to grade short answer questions using semantic similarity measures and dependency graph alignments." Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics.