Upload 3 files

app.py

@@ -0,0 +1,299 @@
+from flask import Flask, render_template, request, jsonify, send_file
+import ollama
+import json
+import re
+from duckduckgo_search import DDGS
+import requests
+from bs4 import BeautifulSoup
+import fitz  # PyMuPDF
+import urllib3
+import pandas as pd
+import io
+import ast
+
+
+app = Flask(__name__)
+
+search_prompt = """
+The user will provide a detailed description of a technical problem they are trying to solve in the context of intellectual property (IP) and patents. Your task is to generate some (2 to 5) highly specific and relevant search queries for Google, aimed at finding research papers closely related to the user's problem. Each search query should:
+
+1. Be crafted to find research papers, articles, or academic resources that address similar issues or solutions.
+2. Be focused and precise, avoiding generic or overly broad terms.
+
+Provide the search queries in the following **JSON format**. There should be no extra text, only the search queries as values.
+
+**Example Output:**
+
+```json
+{
+    "1": "user authentication 5G cryptographic keys identity management",
+    "2": "5G authentication security issues cryptography 3GPP key management"
+}
+```
+"""
+
+infringement_prompt = """You are an expert assistant designed to evaluate the novelty and inventiveness of patents by comparing them with existing documents. Your task is to analyze the background of a given patent and the first page of a related document to determine how well the document covers the problems mentioned in the patent.
+
+# Instructions:
+
+Understand the Patent Background: Carefully read and comprehend the background information provided for the patent. Identify the key problems that the patent aims to address.
+
+Analyze the Document: Review the provided document. Focus on identifying any problems that are similar to those mentioned in the patent background.
+
+Evaluate Coverage: Assess how well the document covers the problems mentioned in the patent. Use the following scoring system:
+
+Score 5: The document explicitly discusses the same problems as the patent, indicating that the problems are not novel.
+Score 4: The document discusses problems that are very similar to those in the patent, significantly impacting the novelty of the patent's problems.
+Score 3: The document mentions problems that are somewhat similar to those in the patent, but the coverage is not extensive enough to fully block the novelty of the patent's problems.
+Score 2: The document mentions problems that are similar in some ways but are clearly different from those in the patent.
+Score 1: The document touches upon related problems but does not directly address the specific problems mentioned in the patent.
+Score 0: The document does not discuss any problems related to those in the patent.
+Provide a Score: Based on your analysis, provide a score from 0 to 5 indicating how well the document covers the problems mentioned in the patent.
+
+Justify Your Score: Briefly explain the reasoning behind your score, highlighting specific similarities or differences between the problems discussed in the patent and the document.
+
+# Output Format:
+No details or explainations are required, just the results in the required **JSON** format with no additional word.
+
+{
+    'score': [Your Score],
+    'justification': "[Your Justification]"
+}
+"""
+
+
+def ask_ollama(user_message, model='gemma3:1b', system_prompt=search_prompt):
+    response = ollama.chat(model=model, messages=[
+        {
+            "role": "system",
+            "content": system_prompt
+        },
+        {
+            "role": "user", 
+            "content": user_message
+        }
+    ])
+    ai_reply = response['message']['content']
+    print(f"AI REPLY json:\n{ai_reply}")
+
+    # Process the response to ensure we return valid JSON
+    try:
+        # First, try to parse it directly in case it's already valid JSON
+        print(f"AI REPLY:\n{ai_reply}")
+        return ast.literal_eval(ai_reply.replace('json\n', '').replace('```', ''))
+    except:
+        print(f"ERROR:\n{e}")
+        # If it's not valid JSON, try to extract JSON from the text
+        return {
+            "1": "Error parsing response. Please try again.",
+            "2": "Error parsing response. Please try again."
+        }
+
+def search_web(topic, max_references=5, data_type="pdf"):
+    """Search the web using DuckDuckGo and return results."""
+    doc_list = []
+    with DDGS(verify=False) as ddgs:
+        i = 0
+        for r in ddgs.text(topic, region='wt-wt', safesearch='On', timelimit='n'):
+            if i >= max_references:
+                break
+            doc_list.append({"type": data_type, "title": r['title'], "body": r['body'], "url": r['href']})
+            i += 1
+    return doc_list
+
+def analyze_pdf_novelty(patent_background, url, data_type="pdf"):
+    """Extract first page text from PDF or background from patent and evaluate novelty"""
+    try:
+        # Disable SSL warnings
+        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+        # Extract text based on the type
+        if data_type == "pdf":            
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+                "Accept": "application/pdf"
+            }
+
+            response = requests.get(url, headers=headers, timeout=20, verify=False)
+            if response.status_code != 200:
+                print(f"Failed to download PDF (status code: {response.status_code})")
+                return {"error": f"Failed to download PDF (status code: {response.status_code})"}
+                
+            # Extract first page text
+            try:
+                pdf_document = fitz.open(stream=response.content, filetype="pdf")
+                if pdf_document.page_count == 0:
+                    return {"error": "PDF has no pages"}
+                    
+                first_page = pdf_document.load_page(0)
+                text = first_page.get_text()
+            except Exception as e:
+                return {"error": f"Error processing PDF: {str(e)}"}
+        
+        elif data_type == "patent":
+            # Extract background from patent
+            print("extract from patent")
+            try:
+                response = requests.get(url, timeout=20, verify=False)
+                if response.status_code != 200:
+                    print(f"Failed to access patent (status code: {response.status_code})")
+                    return {"error": f"Failed to access patent (status code: {response.status_code})"}
+                content = response.content.decode('utf-8').replace("\n", "")
+                soup = BeautifulSoup(content, 'html.parser')
+                section = soup.find('section', itemprop='description', itemscope='')
+                matches = re.findall(r"background(.*?)(?:summary|description of the drawing)", str(section), re.DOTALL | re.IGNORECASE)
+                if matches:
+                    text = BeautifulSoup(matches[0], "html.parser").get_text(separator=" ").strip()
+                else:
+                    text = "Background section not found in patent."
+            except Exception as e:
+                return {"error": f"Error processing patent: {str(e)}"}
+        elif data_type == "web":  
+            try:
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+                    "Accept": "application/pdf"
+                }
+                response = requests.get(url, headers=headers, timeout=20, verify=False)
+                response.raise_for_status()                
+                soup = BeautifulSoup(response.text, 'html.parser')
+                full_text = soup.get_text()
+                text = re.sub(r'\n+', ' ', full_text)[:5000]
+            except requests.RequestException as e:
+                return {"error": f"Error fetching the page: {str(e)}"}
+        else:
+            return {"error": "Unknown document type"}
+        
+        # Analyze with Ollama
+        result = ask_ollama(
+            user_message=f"Patent background:\n{patent_background}\n\nDocument first page:\n{text}",
+            system_prompt=infringement_prompt
+        )
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error: {str(e)}"}
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    user_message = request.form.get('message')
+    ai_reply = ask_ollama(user_message)
+    return jsonify({'reply': ai_reply})
+
+@app.route('/search', methods=['POST'])
+def search():
+    query = request.form.get('query')
+    pdf_checked = request.form.get('pdfOption') == 'true'
+    patent_checked = request.form.get('patentOption') == 'true'
+    web_checked = request.form.get('webOption') == 'true' or request.form.get('webOption') == 'on'
+
+    if not query:
+        return jsonify({'error': 'No query provided', 'results': []})
+    
+    all_results = []
+    
+    try:
+        # Handle various combinations
+        if pdf_checked:
+            pdf_query = f"{query} filetype:pdf"
+            pdf_results = search_web(pdf_query, max_references=5, data_type="pdf")
+            all_results.extend(pdf_results)
+            
+        if patent_checked:
+            patent_query = f"{query} site:patents.google.com"
+            patent_results = search_web(patent_query, max_references=5, data_type="patent")
+            all_results.extend(patent_results)
+            
+        if web_checked:
+            # For web, we don't add anything to the query
+            web_results = search_web(query, max_references=5, data_type="web")
+            all_results.extend(web_results)
+            
+        # If nothing is checked, default to web search
+        if not (pdf_checked or patent_checked or web_checked):
+            web_results = search_web(query, max_references=5, data_type="web")
+            all_results.extend(web_results)
+        
+        return jsonify({'results': all_results})
+    except Exception as e:
+        print(f"Error performing search: {e}")
+        return jsonify({'error': str(e), 'results': []})
+
+@app.route('/analyze', methods=['POST'])
+def analyze():
+    data = request.json
+    if not data or 'patent_background' not in data or 'pdf_url' not in data:
+        return jsonify({'error': 'Missing required parameters', 'result': None})
+    
+    try:
+        patent_background = data['patent_background']
+        url = data['pdf_url']
+        data_type = data.get('data_type', 'pdf')  # Default to pdf if not specified
+        
+        result = analyze_pdf_novelty(patent_background, url, data_type)
+        return jsonify({'result': result})
+    except Exception as e:
+        print(f"Error analyzing document: {e}")
+        return jsonify({'error': str(e), 'result': None})
+    
+@app.route('/export-excel', methods=['POST'])
+def export_excel():
+    try:
+        data = request.json
+        if not data or 'tableData' not in data:
+            return jsonify({'error': 'No table data provided'})
+            
+        # Create pandas DataFrame from the data
+        df = pd.DataFrame(data['tableData'])
+        
+        # Get the user query
+        user_query = data.get('userQuery', 'No query provided')
+        
+        # Create a BytesIO object to store the Excel file
+        output = io.BytesIO()
+        
+        # Create Excel file with xlsxwriter engine
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            # Write the data to a sheet named 'Results'
+            df.to_excel(writer, sheet_name='Results', index=False)
+            
+            # Get workbook and worksheet objects
+            workbook = writer.book
+            worksheet = writer.sheets['Results']
+            
+            # Add a sheet for the query
+            query_sheet = workbook.add_worksheet('Query')
+            query_sheet.write(0, 0, 'Patent Query')
+            query_sheet.write(1, 0, user_query)
+            
+            # Adjust column widths
+            for i, col in enumerate(df.columns):
+                # Get maximum column width
+                max_len = max(
+                    df[col].astype(str).map(len).max(),
+                    len(col)
+                ) + 2
+                # Set column width (limit to 100 to avoid issues)
+                worksheet.set_column(i, i, min(max_len, 100))
+        
+        # Seek to the beginning of the BytesIO object
+        output.seek(0)
+        
+        # Return the Excel file
+        return send_file(
+            output,
+            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            as_attachment=True,
+            download_name='patent_search_results.xlsx'
+        )
+        
+    except Exception as e:
+        print(f"Error exporting Excel: {e}")
+        return jsonify({'error': str(e)})
+
+if __name__ == '__main__':
+    app.run(debug=True)

requirements.txt

@@ -0,0 +1,34 @@
+annotated-types==0.7.0
+anyio==4.9.0
+beautifulsoup4==4.13.3
+blinker==1.9.0
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+duckduckgo_search==7.5.2
+Flask==3.1.0
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+lxml==5.3.1
+MarkupSafe==3.0.2
+numpy==2.2.4
+ollama==0.4.7
+pandas==2.2.3
+primp==0.14.0
+pydantic==2.10.6
+pydantic_core==2.27.2
+PyMuPDF==1.25.4
+python-dateutil==2.9.0.post0
+pytz==2025.1
+requests==2.32.3
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.6
+typing_extensions==4.12.2
+tzdata==2025.1
+urllib3==2.3.0
+Werkzeug==3.1.3

templates/index.html

@@ -0,0 +1,765 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Patentability</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+    <script>
+        function generateQueries(event) {
+            event.preventDefault();
+            
+            const userInput = document.getElementById('userInput').value.trim();
+            if (!userInput) {
+                alert('Please enter a technical problem description');
+                return;
+            }
+            
+            // Show loading indicator
+            document.getElementById('loadingIndicator').style.display = 'block';
+            // Hide results if they were previously shown
+            document.getElementById('resultsContainer').style.display = 'none';
+            
+            // Send message to Flask backend
+            fetch('/chat', {
+                method: 'POST',
+                body: new URLSearchParams({ 'message': userInput }),
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+            })
+            .then(response => response.json())
+            .then(data => {
+                // Hide loading indicator
+                document.getElementById('loadingIndicator').style.display = 'none';
+                
+                try {
+                    // Parse the JSON string from the LLM response
+                    let jsonData;
+                    // First check if data.reply is already an object
+                    if (typeof data.reply === 'object') {
+                        jsonData = data.reply;
+                    } else {
+                        // Try to extract JSON if it's a string possibly with markdown code blocks
+                        const jsonString = data.reply.replace(/```json|```/g, '').trim();
+                        jsonData = JSON.parse(jsonString);
+                    }
+                    
+                    // Clear existing queries
+                    const queriesContainer = document.getElementById('queriesContainer');
+                    queriesContainer.innerHTML = '';
+                    
+                    // Add each query from the response
+                    Object.keys(jsonData).forEach(key => {
+                        addQueryField(jsonData[key]);
+                    });
+                    
+                    // Show results container
+                    document.getElementById('resultsContainer').style.display = 'block';
+                } catch (error) {
+                    console.error('Error parsing JSON:', error);
+                    alert('There was an error processing the response. Please try again.');
+                }
+            })
+            .catch(error => {
+                document.getElementById('loadingIndicator').style.display = 'none';
+                console.error('Error:', error);
+                alert('There was an error communicating with the server. Please try again.');
+            });
+        }
+        
+        // Add a new query field with the given text (or empty if not provided)
+        function addQueryField(queryText = '') {
+            const queriesContainer = document.getElementById('queriesContainer');
+            const queryIndex = queriesContainer.children.length + 1;
+            
+            // Create main container for this query item
+            const queryItem = document.createElement('div');
+            queryItem.className = 'query-item';
+            
+            // Create container for query field and buttons
+            const queryContainer = document.createElement('div');
+            queryContainer.className = 'query-container';
+            
+            // Input field
+            const queryField = document.createElement('input');
+            queryField.type = 'text';
+            queryField.className = 'query-field';
+            queryField.value = queryText;
+            queryField.placeholder = `Search Query ${queryIndex}`;
+            
+            // Delete button
+            const deleteButton = document.createElement('button');
+            deleteButton.type = 'button';
+            deleteButton.className = 'action-button delete-button';
+            deleteButton.textContent = 'Delete';
+            deleteButton.onclick = function() {
+                queriesContainer.removeChild(queryItem);
+                // Update the placeholder numbers for remaining queries
+                updateQueryIndices();
+            };
+            // Search button
+            const searchButton = document.createElement('button');
+            searchButton.type = 'button';
+            searchButton.className = 'action-button search-button';
+            searchButton.textContent = 'Search';
+            searchButton.onclick = function() {
+                performSearch(queryField.value, queryItem);
+            };
+            
+            // Add elements to container
+            queryContainer.appendChild(queryField);
+            queryContainer.appendChild(searchButton);
+            queryContainer.appendChild(deleteButton);
+            
+            // Create loading indicator for this search
+            const searchLoading = document.createElement('div');
+            searchLoading.className = 'search-loading';
+            searchLoading.textContent = 'Searching... Please wait.';
+            
+            // Create table for results
+            const resultsTable = document.createElement('table');
+            resultsTable.className = 'results-table';
+            
+            // Add table header
+            const tableHeader = document.createElement('thead');
+            const headerRow = document.createElement('tr');
+
+            const typeHeader = document.createElement('th');
+            typeHeader.textContent = 'Type';
+
+            const titleHeader = document.createElement('th');
+            titleHeader.textContent = 'Title';
+
+            const bodyHeader = document.createElement('th');
+            bodyHeader.textContent = 'Description';
+
+            const urlHeader = document.createElement('th');
+            urlHeader.textContent = 'URL';
+
+            const scoreHeader = document.createElement('th');
+            scoreHeader.textContent = 'Score';
+
+            const justificationHeader = document.createElement('th');
+            justificationHeader.textContent = 'Justification';
+
+            headerRow.appendChild(typeHeader);
+            headerRow.appendChild(titleHeader);
+            headerRow.appendChild(bodyHeader);
+            headerRow.appendChild(urlHeader);
+            headerRow.appendChild(scoreHeader);
+            headerRow.appendChild(justificationHeader);
+            tableHeader.appendChild(headerRow);
+            
+            // Add table body
+            const tableBody = document.createElement('tbody');
+            
+            resultsTable.appendChild(tableHeader);
+            resultsTable.appendChild(tableBody);
+            
+            // Add all elements to the query item
+            queryItem.appendChild(queryContainer);
+            queryItem.appendChild(searchLoading);
+            queryItem.appendChild(resultsTable);
+            
+            // Add container to the queries list
+            queriesContainer.appendChild(queryItem);
+        }
+        
+        // Perform search and update the results table
+        function performSearch(query, queryItemElement) {
+            if (!query.trim()) {
+                alert('Please enter a search query');
+                return;
+            }
+            
+            const loadingElement = queryItemElement.querySelector('.search-loading');
+            const tableElement = queryItemElement.querySelector('.results-table');
+            const tableBody = tableElement.querySelector('tbody');
+            
+            // Show loading and hide previous results
+            loadingElement.style.display = 'block';
+            tableElement.style.display = 'none';
+            
+            // Clear previous results
+            tableBody.innerHTML = '';
+            
+            // Get checkbox values
+            const pdfChecked = document.getElementById('pdfOption').checked;
+            const patentChecked = document.getElementById('patentOption').checked;
+            const webChecked = document.getElementById('webOption').checked;
+
+            
+            // Create form data with query and checkbox values
+            const formData = new FormData();
+            formData.append('query', query);
+            formData.append('pdfOption', pdfChecked);
+            formData.append('patentOption', patentChecked);
+            formData.append('webOption', webChecked);
+
+            
+            // Send search request to backend
+            fetch('/search', {
+                method: 'POST',
+                body: formData
+            })
+            .then(response => response.json())
+            .then(data => {
+                // Hide loading indicator
+                loadingElement.style.display = 'none';
+                
+                if (data.results && data.results.length > 0) {
+                    // Populate table with results
+                    data.results.forEach(result => {
+                        const row = document.createElement('tr');
+
+                        const typeCell = document.createElement('td');
+                        typeCell.textContent = result.type;                        
+                        
+                        const titleCell = document.createElement('td');
+                        titleCell.textContent = result.title;
+                        
+                        const bodyCell = document.createElement('td');
+                        bodyCell.textContent = result.body;
+                        
+                        const urlCell = document.createElement('td');
+                        const urlLink = document.createElement('a');
+                        urlLink.href = result.url;
+                        urlLink.textContent = result.url;
+                        urlLink.className = 'url-link';
+                        urlLink.target = '_blank';
+                        urlCell.appendChild(urlLink);
+
+                        // Add "Analyze" button to the URL cell
+                        const analyzeButton = document.createElement('button');
+                        analyzeButton.textContent = 'Analyze';
+                        analyzeButton.className = 'action-button analyze-button';
+                        analyzeButton.onclick = function(e) {
+                            e.preventDefault();
+                            analyzePaper(result.url, queryItemElement);
+                        };
+                        urlCell.appendChild(document.createElement('br'));
+                        urlCell.appendChild(analyzeButton);
+                        
+                        row.appendChild(typeCell);
+                        row.appendChild(titleCell);
+                        row.appendChild(bodyCell);
+                        row.appendChild(urlCell);
+                        
+                        tableBody.appendChild(row);
+                    });
+                    
+                    // Show the table
+                    tableElement.style.display = 'table';
+                } else {
+                    // No results
+                    const row = document.createElement('tr');
+                    const cell = document.createElement('td');
+                    cell.colSpan = 4; // Updated to 4 since we now have 4 columns with the type column
+                    cell.textContent = 'No results found.';
+                    cell.style.textAlign = 'center';
+                    row.appendChild(cell);
+                    tableBody.appendChild(row);
+                    tableElement.style.display = 'table';
+                }
+            })
+            .catch(error => {
+                loadingElement.style.display = 'none';
+                console.error('Error:', error);
+                
+                // Show error in table
+                const row = document.createElement('tr');
+                const cell = document.createElement('td');
+                cell.colSpan = 4; // Updated to 4 since we now have 4 columns with the type column
+                cell.textContent = 'Error performing search. Please try again.';
+                cell.style.textAlign = 'center';
+                cell.style.color = 'red';
+                row.appendChild(cell);
+                tableBody.appendChild(row);
+                tableElement.style.display = 'table';
+            });
+        }
+        
+        function analyzePaper(paperUrl, queryItemElement) {
+            const patentBackground = document.getElementById('userInput').value.trim();
+            if (!patentBackground) {
+                alert('Please provide a patent background in the input field');
+                return;
+            }
+            
+            // Find the row containing this URL
+            const rows = queryItemElement.querySelectorAll('tbody tr');
+            let targetRow;
+            let documentType = 'pdf'; // Default type
+            
+            for (const row of rows) {
+                const urlLink = row.querySelector('.url-link');
+                if (urlLink && urlLink.href === paperUrl) {
+                    targetRow = row;
+                    // Get the document type from the first cell of the row
+                    documentType = row.cells[0].textContent.toLowerCase();
+                    break;
+                }
+            }
+            
+            if (!targetRow) {
+                alert('Could not find the paper in the results table');
+                return;
+            }
+            
+            // Check if we already have analysis columns
+            let scoreCell, justificationCell;
+            if (targetRow.cells.length <= 4) {
+                // We need to create the cells
+                scoreCell = document.createElement('td');
+                scoreCell.className = 'score-cell';
+                scoreCell.innerHTML = '<div class="loading-spinner"></div>';
+                
+                justificationCell = document.createElement('td');
+                justificationCell.className = 'justification-cell';
+                justificationCell.innerHTML = 'Analyzing...';
+                
+                targetRow.appendChild(scoreCell);
+                targetRow.appendChild(justificationCell);
+            } else {
+                // Use existing cells
+                scoreCell = targetRow.cells[4];
+                justificationCell = targetRow.cells[5];
+                scoreCell.innerHTML = '<div class="loading-spinner"></div>';
+                justificationCell.innerHTML = 'Analyzing...';
+            }
+            
+            // Send analysis request to backend
+            fetch('/analyze', {
+                method: 'POST',
+                body: JSON.stringify({ 
+                    'patent_background': patentBackground, 
+                    'pdf_url': paperUrl,
+                    'data_type': documentType
+                }),
+                headers: { 'Content-Type': 'application/json' }
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.error) {
+                    scoreCell.innerHTML = 'Error';
+                    justificationCell.innerHTML = data.error;
+                } else if (data.result) {
+                    // Get score and justification from the result
+                    const result = data.result;
+                    const score = result.score !== undefined ? result.score : 'N/A';
+                    const justification = result.justification || 'No justification provided';
+                    
+                    // Update cells with results
+                    scoreCell.innerHTML = score;
+                    justificationCell.innerHTML = justification;
+                    
+                    // Color-code the score
+                    if (score >= 0 && score <= 5) {
+                        const redComponent = Math.floor((score / 5) * 255);
+                        const greenComponent = Math.floor(((5 - score) / 5) * 255);
+                        scoreCell.style.backgroundColor = `rgb(${redComponent}, ${greenComponent}, 0)`;
+                        scoreCell.style.color = 'white';
+                        scoreCell.style.fontWeight = 'bold';
+                        scoreCell.style.textAlign = 'center';
+                    }
+                } else {
+                    scoreCell.innerHTML = 'No data';
+                    justificationCell.innerHTML = 'Analysis failed';
+                }
+            })
+            .catch(error => {
+                console.error('Error:', error);
+                scoreCell.innerHTML = 'Error';
+                justificationCell.innerHTML = 'Failed to analyze paper';
+            });
+        }
+
+        // Update the placeholder text numbers after deletions
+        function updateQueryIndices() {
+            const queryItems = document.getElementById('queriesContainer').children;
+            for (let i = 0; i < queryItems.length; i++) {
+                const queryField = queryItems[i].querySelector('.query-field');
+                queryField.placeholder = `Search Query ${i + 1}`;
+            }
+        }
+        
+        // Get all queries as an array of strings
+        function getQueries() {
+            const queryFields = document.querySelectorAll('.query-field');
+            return Array.from(queryFields).map(field => field.value.trim());
+        }
+
+        // Analyze all unanalyzed papers in the results
+        function analyzeAllPapers() {
+            // Show loading overlay
+            const loadingOverlay = document.getElementById('globalLoadingOverlay');
+            if (loadingOverlay) loadingOverlay.style.display = 'flex';
+            
+            // Get all query items
+            const queryItems = document.querySelectorAll('.query-item');
+            let totalToAnalyze = 0;
+            let completedAnalyses = 0;
+            
+            // Count total papers that need analysis
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr');
+                rows.forEach(row => {
+                    if (row.cells.length <= 4 || row.cells[4].textContent.trim() === 'Error' || 
+                        row.cells[4].textContent.trim() === 'N/A' || row.cells[4].textContent.trim() === '') {
+                        totalToAnalyze++;
+                    }
+                });
+            });
+            
+            if (totalToAnalyze === 0) {
+                alert('No papers need analysis');
+                if (loadingOverlay) loadingOverlay.style.display = 'none';
+                return;
+            }
+            
+            // Function to update progress
+            function updateProgress() {
+                completedAnalyses++;
+                if (loadingOverlay) {
+                    const progressElement = loadingOverlay.querySelector('.progress-text');
+                    if (progressElement) {
+                        progressElement.textContent = `Analyzing papers: ${completedAnalyses}/${totalToAnalyze}`;
+                    }
+                }
+                
+                if (completedAnalyses >= totalToAnalyze) {
+                    if (loadingOverlay) loadingOverlay.style.display = 'none';
+                }
+            }
+            
+            // Analyze each paper that needs it
+            queryItems.forEach(queryItem => {
+                const rows = queryItem.querySelectorAll('tbody tr');
+                rows.forEach(row => {
+                    // Check if this row needs analysis
+                    if (row.cells.length <= 4 || row.cells[4].textContent.trim() === 'Error' || 
+                        row.cells[4].textContent.trim() === 'N/A' || row.cells[4].textContent.trim() === '') {
+                        
+                        // Get the URL
+                        const urlLink = row.querySelector('.url-link');
+                        const documentType = row.cells[0].textContent.toLowerCase();
+                        if (urlLink && urlLink.href) {
+                            // Create a promise for this analysis
+                            const promise = new Promise((resolve) => {
+                                // Prepare for analysis
+                                const patentBackground = document.getElementById('userInput').value.trim();
+                                
+                                // Create score and justification cells if needed
+                                let scoreCell, justificationCell;
+                                if (row.cells.length <= 4) {
+                                    scoreCell = document.createElement('td');
+                                    scoreCell.className = 'score-cell';
+                                    scoreCell.innerHTML = '<div class="loading-spinner"></div>';
+                                    
+                                    justificationCell = document.createElement('td');
+                                    justificationCell.className = 'justification-cell';
+                                    justificationCell.innerHTML = 'Analyzing...';
+                                    
+                                    row.appendChild(scoreCell);
+                                    row.appendChild(justificationCell);
+                                } else {
+                                    scoreCell = row.cells[4];
+                                    justificationCell = row.cells[5];
+                                    scoreCell.innerHTML = '<div class="loading-spinner"></div>';
+                                    justificationCell.innerHTML = 'Analyzing...';
+                                }
+                                
+                                // Send analysis request
+                                fetch('/analyze', {
+                                    method: 'POST',
+                                    body: JSON.stringify({ 
+                                        'patent_background': patentBackground, 
+                                        'pdf_url': urlLink.href,
+                                        'data_type': documentType
+                                    }),
+                                    headers: { 'Content-Type': 'application/json' }
+                                })
+                                .then(response => response.json())
+                                .then(data => {
+                                    if (data.error) {
+                                        scoreCell.innerHTML = 'Error';
+                                        justificationCell.innerHTML = data.error;
+                                    } else if (data.result) {
+                                        // Get score and justification
+                                        const result = data.result;
+                                        const score = result.score !== undefined ? result.score : 'N/A';
+                                        const justification = result.justification || 'No justification provided';
+                                        
+                                        // Update cells
+                                        scoreCell.innerHTML = score;
+                                        justificationCell.innerHTML = justification;
+                                        
+                                        // Color-code score
+                                        if (score >= 0 && score <= 5) {
+                                            const redComponent = Math.floor((score / 5) * 255);
+                                            const greenComponent = Math.floor(((5 - score) / 5) * 255);
+                                            scoreCell.style.backgroundColor = `rgb(${redComponent}, ${greenComponent}, 0)`;
+                                            scoreCell.style.color = 'white';
+                                            scoreCell.style.fontWeight = 'bold';
+                                            scoreCell.style.textAlign = 'center';
+                                        }
+                                    } else {
+                                        scoreCell.innerHTML = 'No data';
+                                        justificationCell.innerHTML = 'Analysis failed';
+                                    }
+                                    resolve();
+                                })
+                                .catch(error => {
+                                    console.error('Error:', error);
+                                    scoreCell.innerHTML = 'Error';
+                                    justificationCell.innerHTML = 'Failed to analyze paper';
+                                    resolve();
+                                });
+                            });
+                            
+                            // When this analysis is done, update the progress
+                            promise.then(() => {
+                                updateProgress();
+                            });
+                        } else {
+                            // No URL found, count as completed
+                            updateProgress();
+                        }
+                    }
+                });
+            });
+        }
+
+        // Remove rows with failed analyses
+        function removeFailedAnalyses() {
+            const queryItems = document.querySelectorAll('.query-item');
+            let removedCount = 0;
+            
+            queryItems.forEach(queryItem => {
+                const tbody = queryItem.querySelector('tbody');
+                const rows = Array.from(tbody.querySelectorAll('tr'));
+                
+                rows.forEach(row => {
+                    if (row.cells.length > 4) {
+                        const scoreText = row.cells[4].textContent.trim();
+                        if (scoreText === 'Error' || scoreText === 'N/A' || scoreText === 'No data') {
+                            tbody.removeChild(row);
+                            removedCount++;
+                        }
+                    }
+                });
+            });
+            
+            alert(`Removed ${removedCount} papers with failed analyses`);
+        }
+
+        // Export all tables to Excel
+        function exportToExcel() {
+            // Show loading overlay
+            const loadingOverlay = document.getElementById('globalLoadingOverlay');
+            if (loadingOverlay) {
+                loadingOverlay.style.display = 'flex';
+                loadingOverlay.querySelector('.progress-text').textContent = 'Generating Excel file...';
+            }
+            
+            try {
+                // Collect all data from all tables
+                const allData = [];
+                const queryItems = document.querySelectorAll('.query-item');
+                
+                queryItems.forEach(queryItem => {
+                    // Get the search query text for this table
+                    const queryText = queryItem.querySelector('.query-field').value;
+                    
+                    // Get all rows in this table
+                    const rows = queryItem.querySelectorAll('tbody tr');
+                    
+                    rows.forEach(row => {
+                        // Skip empty rows or error rows
+                        if (row.cells.length === 1 && row.cells[0].colSpan > 1) {
+                            return; // Skip "No results found" rows
+                        }
+                        
+                        // Prepare object for this row
+                        const rowData = {
+                            'Topic': queryText,
+                            'Type': row.cells[0].textContent,
+                            'Title': row.cells[1].textContent,
+                            'Description': row.cells[2].textContent,
+                            'URL': row.querySelector('.url-link')?.href || ''
+                        };
+                        
+                        // Add score and justification if they exist
+                        if (row.cells.length > 4) {
+                            rowData['Score'] = row.cells[4].textContent;
+                            rowData['Justification'] = row.cells[5].textContent;
+                        } else {
+                            rowData['Score'] = '';
+                            rowData['Justification'] = '';
+                        }
+                        
+                        allData.push(rowData);
+                    });
+                });
+                
+                // Check if we have any data
+                if (allData.length === 0) {
+                    if (loadingOverlay) loadingOverlay.style.display = 'none';
+                    alert('No data to export. Please perform a search first.');
+                    return;
+                }
+                
+                // User query for context
+                const userQuery = document.getElementById('userInput').value;
+                
+                // Send to server for Excel generation
+                fetch('/export-excel', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        'tableData': allData,
+                        'userQuery': userQuery
+                    }),
+                    headers: { 'Content-Type': 'application/json' }
+                })
+                .then(response => {
+                    if (!response.ok) {
+                        throw new Error(`Server error: ${response.status}`);
+                    }
+                    return response.blob();
+                })
+                .then(blob => {
+                    // Hide loading overlay
+                    if (loadingOverlay) loadingOverlay.style.display = 'none';
+                    
+                    // Create URL for the blob
+                    const url = window.URL.createObjectURL(new Blob([blob], {
+                        type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+                    }));
+                    
+                    // Create a link and trigger download
+                    const a = document.createElement('a');
+                    a.href = url;
+                    a.download = 'patent_search_results.xlsx';
+                    document.body.appendChild(a);
+                    a.click();
+                    
+                    // Clean up
+                    window.URL.revokeObjectURL(url);
+                    document.body.removeChild(a);
+                })
+                .catch(error => {
+                    console.error('Error exporting to Excel:', error);
+                    if (loadingOverlay) loadingOverlay.style.display = 'none';
+                    alert(`Error exporting to Excel: ${error.message}`);
+                });
+            } catch (error) {
+                console.error('Error preparing Excel data:', error);
+                if (loadingOverlay) loadingOverlay.style.display = 'none';
+                alert(`Error preparing data for export: ${error.message}`);
+            }
+        }
+    </script>
+</head>
+<body>
+    <div class="container">
+        <header class="header">
+            <div class="logo">
+                <div class="logo-icon">P</div>
+                <h1>Patentability</h1>
+            </div>
+            <p>Enter a detailed description of your technical problem to generate search queries for finding relevant research papers.</p>
+        </header>
+
+        <section class="card">
+            <form id="queryForm" onsubmit="generateQueries(event)">
+                <div class="form-group">
+                    <label for="userInput">Technical Problem Description:</label>
+                    <textarea id="userInput" placeholder="Describe your technical problem in detail..." required></textarea>
+                </div>
+                
+                <button type="submit" class="btn btn-primary">Generate Search Queries</button>
+            </form>
+            
+            <div id="loadingIndicator">
+                <div class="loading-spinner"></div>
+                <p>Generating search queries... Please wait.</p>
+            </div>
+        </section>
+
+        <section class="search-options">
+            <label>Search Options:</label>
+            <div class="checkbox-group">
+                <div class="checkbox-item">
+                    <input type="checkbox" id="pdfOption" name="searchOptions" value="pdf" checked>
+                    <label for="pdfOption">PDF</label>
+                </div>
+                <div class="checkbox-item">
+                    <input type="checkbox" id="patentOption" name="searchOptions" value="patent">
+                    <label for="patentOption">Patent</label>
+                </div>
+                <div class="checkbox-item">
+                    <input type="checkbox" id="webOption" name="searchOptions" value="web">
+                    <label for="webOption">Web</label>
+                </div>
+            </div>
+        </section> 
+        
+        <section id="resultsContainer">
+            <h2>Generated Search Queries</h2>
+            
+            <div id="queriesContainer">
+                <!-- Query fields will be added here dynamically -->
+            </div>
+            
+            <div class="button-container">
+                <button type="button" class="btn btn-secondary" onclick="addQueryField()">
+                    <span>Add New Query</span>
+                </button>
+            </div>
+        </section>
+    </div>
+
+
+
+
+    <!-- Global action buttons (floating) -->
+    <div class="floating-buttons">
+        <button id="analyzeAllButton" class="btn btn-primary floating-button" title="Analyze All Unanalyzed Papers">
+            Analyze All
+        </button>
+        <button id="removeFailedButton" class="btn btn-danger floating-button" title="Remove Papers with Failed Analyses">
+            Remove Failed
+        </button>
+        <button id="exportExcelButton" class="btn btn-success floating-button" title="Export All Data to Excel">
+            Export to Excel
+        </button>
+    </div>
+
+    <!-- Global loading overlay -->
+    <div id="globalLoadingOverlay" class="loading-overlay">
+        <div class="loading-content">
+            <div class="loading-spinner"></div>
+            <div class="progress-text">Processing...</div>
+        </div>
+    </div>
+
+    <script>
+        // Add event listeners for floating buttons
+        document.addEventListener('DOMContentLoaded', function() {
+            // Analyze all button
+            document.getElementById('analyzeAllButton').addEventListener('click', function() {
+                analyzeAllPapers();
+            });
+            
+            // Remove failed button
+            document.getElementById('removeFailedButton').addEventListener('click', function() {
+                removeFailedAnalyses();
+            });
+            
+            // Export to Excel button
+            document.getElementById('exportExcelButton').addEventListener('click', function() {
+                exportToExcel();
+            });
+        });
+    </script>
+</body>
+</html>