Create app.py

app.py

@@ -0,0 +1,492 @@
+# Research Paper Summarizer using LangChain and Gradio
+# Updated for Hugging Face Spaces with beautiful Gradio UI
+# Install required packages first:
+# pip install gradio langchain openai pypdf2 reportlab python-dotenv transformers torch
+
+import gradio as gr
+import os
+from dotenv import load_dotenv
+import PyPDF2
+from io import BytesIO
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+import tempfile
+
+# LangChain imports
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.chains.summarize import load_summarize_chain
+from langchain.docstore.document import Document
+from langchain.llms import OpenAI
+from langchain.chat_models import ChatOpenAI
+
+# Alternative: Use Hugging Face models
+from langchain.llms import HuggingFacePipeline
+from transformers import pipeline
+
+load_dotenv()
+
+class ResearchPaperSummarizer:
+    def __init__(self):
+        self.llm = None
+        self.model_info = ""
+        
+    def setup_llm(self, model_choice):
+        """Setup LLM based on user choice"""
+        # Check available API keys from environment
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+        hf_token = os.getenv("HUGGINGFACE_TOKEN")
+        
+        try:
+            if "OpenAI" in model_choice:
+                if not openai_api_key:
+                    return False, "❌ OpenAI API Key not found in environment variables. Please add OPENAI_API_KEY to your Hugging Face Space settings."
+                
+                os.environ["OPENAI_API_KEY"] = openai_api_key
+                if "GPT-4" in model_choice:
+                    self.llm = ChatOpenAI(model_name="gpt-4", temperature=0.3)
+                    self.model_info = "🚀 Using GPT-4 (Premium) - Highest quality summaries"
+                else:
+                    self.llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.3)
+                    self.model_info = "🚀 Using GPT-3.5 Turbo - Fast and efficient"
+                    
+            else:
+                # Use Hugging Face models (free but slower)
+                if "BART" in model_choice:
+                    summarizer = pipeline(
+                        "summarization", 
+                        model="facebook/bart-large-cnn",
+                        tokenizer="facebook/bart-large-cnn",
+                        use_auth_token=hf_token if hf_token else None
+                    )
+                    self.model_info = "🤗 Using BART model - Free, optimized for summarization"
+                else:
+                    summarizer = pipeline(
+                        "summarization", 
+                        model="t5-base",
+                        tokenizer="t5-base",
+                        use_auth_token=hf_token if hf_token else None
+                    )
+                    self.model_info = "🤗 Using T5 model - Free, versatile model"
+                
+                self.llm = HuggingFacePipeline(pipeline=summarizer)
+                
+            return True, f"✅ Model loaded successfully! {self.model_info}"
+            
+        except Exception as e:
+            return False, f"❌ Error loading model: {str(e)}"
+    
+    def extract_text_from_pdf(self, pdf_file):
+        """Extract text from uploaded PDF"""
+        try:
+            if pdf_file is None:
+                return None, "❌ No PDF file uploaded"
+                
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+            
+            if not text.strip():
+                return None, "❌ No text could be extracted from the PDF"
+                
+            return text, f"✅ Successfully extracted {len(text):,} characters from PDF"
+        except Exception as e:
+            return None, f"❌ Error reading PDF: {str(e)}"
+    
+    def create_documents(self, text):
+        """Split text into manageable chunks"""
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=4000,
+            chunk_overlap=200,
+            length_function=len
+        )
+        
+        chunks = text_splitter.split_text(text)
+        documents = [Document(page_content=chunk) for chunk in chunks]
+        return documents
+    
+    def generate_summary(self, documents, summary_type="map_reduce"):
+        """Generate summary using LangChain"""
+        try:
+            if summary_type == "map_reduce":
+                chain = load_summarize_chain(
+                    self.llm, 
+                    chain_type="map_reduce",
+                    verbose=False
+                )
+            elif summary_type == "stuff":
+                chain = load_summarize_chain(
+                    self.llm, 
+                    chain_type="stuff",
+                    verbose=False
+                )
+            else:  # refine
+                chain = load_summarize_chain(
+                    self.llm, 
+                    chain_type="refine",
+                    verbose=False
+                )
+            
+            summary = chain.run(documents)
+            return summary
+            
+        except Exception as e:
+            return f"❌ Error generating summary: {str(e)}"
+    
+    def create_structured_summary(self, text, documents):
+        """Create a structured summary with different sections"""
+        summaries = {}
+        
+        # Overall Summary
+        summaries['overall'] = self.generate_summary(documents, "map_reduce")
+        
+        # Key Points - Create a separate prompt for key points
+        if len(text) > 8000:
+            key_points_text = text[:8000]
+        else:
+            key_points_text = text
+            
+        key_points_prompt = f"""
+        Extract the 5-7 most important key points from this research paper:
+        
+        {key_points_text}
+        """
+        
+        key_points_docs = [Document(page_content=key_points_prompt)]
+        summaries['key_points'] = self.generate_summary(key_points_docs, "stuff")
+        
+        return summaries
+    
+    def create_pdf_summary(self, summaries, paper_title="Research Paper Summary"):
+        """Create PDF with the summary"""
+        buffer = BytesIO()
+        doc = SimpleDocTemplate(buffer, pagesize=letter)
+        styles = getSampleStyleSheet()
+        story = []
+        
+        # Title
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Heading1'],
+            fontSize=16,
+            spaceAfter=30,
+            textColor='darkblue'
+        )
+        
+        story.append(Paragraph(paper_title, title_style))
+        story.append(Spacer(1, 12))
+        
+        # Overall Summary
+        story.append(Paragraph("Overall Summary", styles['Heading2']))
+        story.append(Spacer(1, 12))
+        story.append(Paragraph(summaries.get('overall', 'No summary available'), styles['Normal']))
+        story.append(Spacer(1, 20))
+        
+        # Key Points
+        if 'key_points' in summaries:
+            story.append(Paragraph("Key Points", styles['Heading2']))
+            story.append(Spacer(1, 12))
+            story.append(Paragraph(summaries['key_points'], styles['Normal']))
+        
+        doc.build(story)
+        buffer.seek(0)
+        
+        # Save to temporary file for Gradio
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
+        temp_file.write(buffer.getvalue())
+        temp_file.close()
+        
+        return temp_file.name
+
+# Initialize the summarizer
+summarizer = ResearchPaperSummarizer()
+
+def process_paper(pdf_file, model_choice, summary_type, include_key_points, paper_title):
+    """Main function to process the research paper"""
+    
+    # Setup model
+    success, message = summarizer.setup_llm(model_choice)
+    if not success:
+        return message, "", "", None
+    
+    status_message = message + "\n\n"
+    
+    # Extract text from PDF
+    text, extract_message = summarizer.extract_text_from_pdf(pdf_file)
+    status_message += extract_message + "\n\n"
+    
+    if text is None:
+        return status_message, "", "", None
+    
+    # Create documents
+    documents = summarizer.create_documents(text)
+    status_message += f"📝 Text split into {len(documents)} chunks for processing\n\n"
+    
+    # Generate summary
+    status_message += "🔄 Generating summary... Please wait...\n\n"
+    
+    try:
+        if include_key_points:
+            summaries = summarizer.create_structured_summary(text, documents)
+            overall_summary = summaries.get('overall', 'No summary generated')
+            key_points = summaries.get('key_points', 'No key points generated')
+        else:
+            overall_summary = summarizer.generate_summary(documents, summary_type)
+            key_points = "Key points not requested"
+            summaries = {'overall': overall_summary}
+        
+        status_message += "🎉 Summary generated successfully!"
+        
+        # Generate PDF if title is provided
+        pdf_file_path = None
+        if paper_title and paper_title.strip():
+            try:
+                pdf_file_path = summarizer.create_pdf_summary(summaries, paper_title.strip())
+                status_message += "\n📄 PDF summary created!"
+            except Exception as e:
+                status_message += f"\n⚠️ PDF creation failed: {str(e)}"
+        
+        return status_message, overall_summary, key_points, pdf_file_path
+        
+    except Exception as e:
+        return status_message + f"❌ Error during processing: {str(e)}", "", "", None
+
+def get_model_info(model_choice):
+    """Return information about the selected model"""
+    model_descriptions = {
+        "OpenAI GPT-3.5": "💡 **Fast and Efficient** - Good for most tasks, paid API required",
+        "OpenAI GPT-4": "🚀 **Highest Quality** - Most advanced summaries, paid API required",
+        "Hugging Face BART": "🆓 **Free Model** - Optimized for summarization, slower on first load",
+        "Hugging Face T5": "🆓 **Free Versatile** - Good general-purpose model, slower on first load"
+    }
+    return model_descriptions.get(model_choice, "")
+
+# Custom CSS for beautiful styling
+custom_css = """
+    .gradio-container {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    
+    .gr-interface {
+        background: rgba(255, 255, 255, 0.95);
+        backdrop-filter: blur(10px);
+        border-radius: 20px;
+        box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1);
+    }
+    
+    .gr-box {
+        border-radius: 15px;
+        border: 2px solid #e1e5e9;
+        background: linear-gradient(145deg, #ffffff, #f0f2f5);
+    }
+    
+    .gr-button {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border: none;
+        border-radius: 10px;
+        color: white;
+        font-weight: bold;
+        transition: transform 0.2s;
+    }
+    
+    .gr-button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+    }
+    
+    .gr-textbox, .gr-dropdown {
+        border-radius: 10px;
+        border: 2px solid #e1e5e9;
+    }
+    
+    .gr-file {
+        border-radius: 15px;
+        border: 3px dashed #667eea;
+        background: linear-gradient(145deg, #f8f9ff, #ffffff);
+    }
+"""
+
+# Create the Gradio interface
+with gr.Blocks(css=custom_css, title="🔬 Research Paper Summarizer", theme=gr.themes.Soft()) as app:
+    
+    # Header
+    gr.Markdown(
+        """
+        # 🔬 Research Paper Summarizer
+        ### Transform lengthy research papers into concise, insightful summaries using AI
+        
+        Upload your PDF research paper and get an intelligent summary with key points extracted automatically!
+        """,
+        elem_classes="header"
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Input Section
+            gr.Markdown("## 📁 Upload & Configure")
+            
+            pdf_input = gr.File(
+                label="📄 Upload Research Paper (PDF)",
+                file_types=[".pdf"],
+                elem_classes="file-upload"
+            )
+            
+            model_choice = gr.Dropdown(
+                choices=[
+                    "OpenAI GPT-3.5",
+                    "OpenAI GPT-4", 
+                    "Hugging Face BART",
+                    "Hugging Face T5"
+                ],
+                value="Hugging Face BART",
+                label="🤖 Choose AI Model",
+                info="Free models work without API keys"
+            )
+            
+            model_info = gr.Markdown("")
+            
+            summary_type = gr.Dropdown(
+                choices=["map_reduce", "stuff", "refine"],
+                value="map_reduce",
+                label="📋 Summary Method",
+                info="map_reduce: best for long papers | stuff: faster for short papers | refine: iterative improvement"
+            )
+            
+            include_key_points = gr.Checkbox(
+                label="🔑 Include Key Points",
+                value=True,
+                info="Extract important key points separately"
+            )
+            
+            paper_title = gr.Textbox(
+                label="📝 Paper Title (for PDF export)",
+                placeholder="Enter the title of your research paper...",
+                info="Optional: Used as title in the generated PDF summary"
+            )
+            
+            process_btn = gr.Button(
+                "🚀 Generate Summary",
+                variant="primary",
+                size="lg",
+                elem_classes="process-button"
+            )
+        
+        with gr.Column(scale=2):
+            # Output Section
+            gr.Markdown("## 📊 Results")
+            
+            status_output = gr.Textbox(
+                label="📈 Processing Status",
+                lines=8,
+                max_lines=10,
+                interactive=False,
+                show_copy_button=True
+            )
+            
+            summary_output = gr.Textbox(
+                label="📋 Overall Summary",
+                lines=10,
+                max_lines=15,
+                interactive=False,
+                show_copy_button=True,
+                placeholder="Your paper summary will appear here..."
+            )
+            
+            key_points_output = gr.Textbox(
+                label="🔑 Key Points",
+                lines=8,
+                max_lines=12,
+                interactive=False,
+                show_copy_button=True,
+                placeholder="Key points will be extracted here..."
+            )
+            
+            pdf_output = gr.File(
+                label="📄 Download PDF Summary",
+                interactive=False
+            )
+    
+    # Setup Instructions
+    with gr.Accordion("🔧 Setup Instructions for API Keys", open=False):
+        gr.Markdown(
+            """
+            ### For Enhanced Performance (Optional):
+            
+            **OpenAI API Setup:**
+            1. Get your API key from [OpenAI Platform](https://platform.openai.com/api-keys)
+            2. In your Hugging Face Space settings, add: `OPENAI_API_KEY = your_key_here`
+            3. Restart your Space to apply changes
+            
+            **Hugging Face Token Setup:**
+            1. Get your token from [HuggingFace Settings](https://huggingface.co/settings/tokens)
+            2. Add: `HUGGINGFACE_TOKEN = your_token_here`
+            3. Provides access to gated models and higher rate limits
+            
+            **Note:** Free Hugging Face models work without any API keys but may be slower on first load.
+            """
+        )
+    
+    # Performance Tips
+    with gr.Accordion("💡 Tips for Best Results", open=False):
+        gr.Markdown(
+            """
+            ### Optimization Tips:
+            
+            - **📄 File Size:** Smaller PDFs (< 10MB) process faster
+            - **🤖 Model Choice:** OpenAI models provide highest quality but require API keys
+            - **⚡ Speed:** "stuff" method is fastest for papers under 20 pages
+            - **📊 Quality:** "map_reduce" works best for comprehensive summaries of long papers
+            - **🔄 First Load:** Hugging Face models may take 2-3 minutes to load initially
+            - **📱 Mobile:** Works on mobile devices but desktop recommended for large files
+            """
+        )
+    
+    # Event handlers
+    model_choice.change(
+        fn=get_model_info,
+        inputs=[model_choice],
+        outputs=[model_info]
+    )
+    
+    process_btn.click(
+        fn=process_paper,
+        inputs=[
+            pdf_input,
+            model_choice,
+            summary_type,
+            include_key_points,
+            paper_title
+        ],
+        outputs=[
+            status_output,
+            summary_output,
+            key_points_output,
+            pdf_output
+        ],
+        show_progress=True
+    )
+    
+    # Footer
+    gr.Markdown(
+        """
+        ---
+        <div style="text-align: center; color: #666; font-size: 14px;">
+            🔬 <strong>Research Paper Summarizer</strong> | Powered by LangChain & AI Models | 
+            Built with ❤️ using Gradio
+        </div>
+        """,
+        elem_classes="footer"
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch(
+        share=True,
+        show_error=True,
+        debug=True,
+        server_name="0.0.0.0",
+        server_port=7860
+    )