First version

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10.3
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,627 @@
+from flask import Flask, render_template, request, jsonify, send_file
+import json
+import re
+from duckduckgo_search import DDGS
+import httpx
+import requests
+from bs4 import BeautifulSoup
+import fitz  # PyMuPDF
+import urllib3
+import pandas as pd
+import io
+import ast
+from groq import Groq
+import os
+
+
+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 explanations are required, just the results in the required **JSON** format with no additional word.
+{
+    'score': [Your Score],
+    'justification': "[Your Justification]"
+}
+"""
+
+insight_prompt = """Analyze the technical document and extract key insights that could enhance the patent problem. Focus on identifying security vulnerabilities, technical problems, innovative technologies, research questions, and protocols mentioned in the document.
+# Instructions:
+1. Identify 3-5 key insights from the document that could enhance or inform the patent problem.
+2. Each insight should be concise (max 10 words) but informative.
+3. Focus on technical elements that could be valuable for improving the patent.
+# Output Format:
+Return only a JSON object with insights as an array, with no additional text:
+{
+    "insights": [
+        "Security vulnerability in authentication handshake",
+        "Novel quantum encryption protocol",
+        "Lightweight implementation for IoT devices",
+        "Privacy-preserving key exchange mechanism",
+        "Real-time threat detection algorithm"
+    ]
+}
+"""
+
+refine_problem_prompt = """You are an expert consultant specializing in enhancing and refining technical problems to make them more sophisticated, novel, and inventive. Your task is to transform an initial technical problem description into two improved versions by integrating selected insights from technical documents.
+# Instructions:
+1. Carefully review the initial technical problem.
+2. Consider the selected insights from technical documents that could enhance the problem formulation.
+3. If any user comments are provided, incorporate those suggestions into your refinement process.
+4. Generate TWO distinct refined problem statements that:
+   - Integrate the selected insights in a meaningful way
+   - Make the problem more sophisticated and technically interesting
+   - Increase the novelty and inventive potential of any solution
+   - Add appropriate constraints and technical requirements
+   - Maintain coherence and technical feasibility
+   - Suggest innovative directions without fully solving the problem
+# Output Format:
+Return the results in **strictly valid JSON** format with no additional text. 
+All string values (especially multiline descriptions) must:
+- Be enclosed in double quotes
+- Escape internal double quotes with backslashes (e.g., \")
+- Replace newline characters with "\\n" (double backslash-n for JSON)
+- Avoid unescaped Markdown if it breaks JSON syntax
+Reference json:
+{
+    "refined_problem_1": {
+        "title": "Brief descriptive title for the first refined problem",
+        "description": "Comprehensive description of the first refined problem that integrates insights and adds sophistication"
+    },
+    "refined_problem_2": {
+        "title": "Brief descriptive title for the second refined problem",
+        "description": "Alternative comprehensive description that takes a different approach to refining the problem"
+    }
+}
+"""
+
+def ask_llm(user_message, model='llama-3.3-70b-versatile', system_prompt="You are a helpful assistant."):
+    client = Groq(api_key="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", http_client=httpx.Client(verify=False))
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {
+                "role": "system",
+                "content": system_prompt
+            },
+            {
+                "role": "user", 
+                "content": user_message
+            }
+        ],
+        stream=False,
+    )
+
+    return response.choices[0].message.content
+
+def ask_ollama(user_message, model='llama-3.3-70b-versatile', system_prompt=search_prompt):
+    client = Groq(api_key="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", http_client=httpx.Client(verify=False))
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {
+                "role": "system",
+                "content": system_prompt
+            },
+            {
+                "role": "user", 
+                "content": user_message
+            }
+        ],
+        stream=False,
+    )
+    
+    ai_reply = response.choices[0].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 Exception as e:
+        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 full document 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 full document text (limited to 6000 characters)
+            try:
+                pdf_document = fitz.open(stream=response.content, filetype="pdf")
+                if pdf_document.page_count == 0:
+                    return {"error": "PDF has no pages"}
+                    
+                text = ""
+                for page_num in range(min(5, pdf_document.page_count)):  # Limit to first 5 pages
+                    page = pdf_document.load_page(page_num)
+                    text += page.get_text() + " "
+                    if len(text) >= 6000:
+                        break
+                
+                text = text[:6000]  # Limit to 6000 characters
+            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 for novelty assessment
+        result = ask_ollama(
+            user_message=f"Patent background:\n{patent_background}\n\nDocument content:\n{text}",
+            system_prompt=infringement_prompt
+        )
+        
+        # # Extract insights
+        # insights = ask_ollama(
+        #     user_message=f"Document content:\n{text}",
+        #     system_prompt=insight_prompt
+        # )
+        
+        # # Combine results
+        # result['insights'] = insights.get('insights', [])
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error: {str(e)}"}
+
+
+def extract_insights(patent_background, url, data_type="pdf"):
+    """Extract full document 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 full document text (limited to 6000 characters)
+            try:
+                pdf_document = fitz.open(stream=response.content, filetype="pdf")
+                if pdf_document.page_count == 0:
+                    return {"error": "PDF has no pages"}
+                    
+                text = ""
+                for page_num in range(min(5, pdf_document.page_count)):  # Limit to first 5 pages
+                    page = pdf_document.load_page(page_num)
+                    text += page.get_text() + " "
+                    if len(text) >= 6000:
+                        break
+                
+                text = text[:6000]  # Limit to 6000 characters
+            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"}
+        
+        # Extract insights
+        insights = ask_ollama(
+            user_message=f"Document content:\n{text}",
+            system_prompt=insight_prompt
+        )
+        
+        return insights
+        
+    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('/post_insights', methods=['POST'])
+def post_insights():
+    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 = extract_insights(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('/refine-problem', methods=['POST'])
+def refine_problem():
+    data = request.json
+    if not data or 'original_problem' not in data or 'insights' not in data:
+        return jsonify({'error': 'Missing required parameters', 'result': None})
+    
+    try:
+        original_problem = data['original_problem']
+        insights = data['insights']
+        user_comments = data.get('user_comments', '')
+        
+        # Prepare the message for the LLM
+        message = f"""Initial Technical Problem:
+{original_problem}
+Selected Insights:
+{', '.join(insights)}
+User Comments/Suggestions:
+{user_comments}
+"""
+        
+        # Get refined problem suggestions from the LLM
+        result = ask_ollama(
+            user_message=message,
+            system_prompt=refine_problem_prompt
+        )
+        
+        return jsonify({'result': result})
+    except Exception as e:
+        print(f"Error refining problem: {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')
+        
+        # Get problem versions if available
+        problem_versions = data.get('problemVersions', {})
+        
+        # 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)
+            
+            # Add a sheet for problem versions if available
+            if problem_versions:
+                versions_sheet = workbook.add_worksheet('Problem Versions')
+                versions_sheet.write(0, 0, 'Version')
+                versions_sheet.write(0, 1, 'Problem Statement')
+                
+                row = 1
+                for version, text in problem_versions.items():
+                    versions_sheet.write(row, 0, version)
+                    versions_sheet.write(row, 1, text)
+                    row += 1
+                
+                # Set column width for problem versions
+                versions_sheet.set_column(0, 0, 20)
+                versions_sheet.set_column(1, 1, 100)
+            
+            # 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)})
+
+@app.route('/ai-select-insights', methods=['POST'])
+def ai_select_insights():
+    data = request.json
+    if not data or 'patent_background' not in data or 'insights' not in data:
+        return jsonify({'error': 'Missing required parameters', 'selected_insights': []})
+    
+    try:
+        patent_background = data['patent_background']
+        insights = data['insights']
+        
+        if not insights or len(insights) == 0:
+            return jsonify({'error': 'No insights provided', 'selected_insights': []})
+            
+        # Prepare the prompt for the LLM
+        ai_select_prompt = """You are an expert in patent analysis and technology innovation. Your task is to select the most relevant insights from a list that would help enhance the patentability of an invention.
+
+INSTRUCTIONS:
+
+1. Review the patent background description carefully.
+
+2. Analyze each insight in the provided list and determine its relevance to the patent background.
+
+3. Select ONLY THE MOST RELEVANT insights that are:
+   - Directly relevant to the patent's technical area
+   - Provide unique perspectives or identify novel challenges
+   - Could significantly enhance the patentability or scope of the invention
+   - Are technically substantive and not obvious
+
+4. Ignore insights that are generic, obvious, or would weaken the patent case.
+
+5. SELECT A MAXIMUM OF 7 INSIGHTS, even fewer if only a few are truly relevant.
+
+6. Return ONLY the selected insights in a valid JSON array.
+
+OUTPUT FORMAT:
+Return only a valid JSON array of strings, each containing the exact text of a selected insight.
+Example: ["Insight 1", "Insight 3", "Insight 5"]"""
+        
+        # Prepare message content
+        message = f"""PATENT BACKGROUND:
+{patent_background}
+
+ALL AVAILABLE INSIGHTS:
+{json.dumps(insights)}"""
+        
+        ai_reply = ask_llm(message, system_prompt=ai_select_prompt)
+        print(f"AI SELECTION RESPONSE: {ai_reply}")
+        
+        # Parse the JSON array from the response
+        # First strip markdown code blocks if present
+        cleaned_reply = ai_reply.replace('```json', '').replace('```', '').strip()
+        
+        try:
+            selected_insights = json.loads(cleaned_reply)
+            
+            # Validate that the response is a list
+            if not isinstance(selected_insights, list):
+                return jsonify({'error': 'Invalid response format from AI', 'selected_insights': []})
+                
+            # Make sure all selected insights actually exist in the original list
+            validated_insights = [insight for insight in selected_insights if insight in insights]
+            
+            return jsonify({'selected_insights': validated_insights})
+            
+        except json.JSONDecodeError as e:
+            print(f"JSON parsing error: {e}")
+            return jsonify({'error': f'Failed to parse AI response: {e}', 'selected_insights': []})
+            
+    except Exception as e:
+        print(f"Error in AI insight selection: {e}")
+        return jsonify({'error': str(e), 'selected_insights': []})
+
+@app.route('/generate-key-issues', methods=['POST'])
+def generate_key_issues():
+    data = request.json
+    if not data or 'query' not in data:
+        return jsonify({'error': 'No query provided', 'key_issues': []})
+    
+    try:
+        query = data['query']
+        
+        # Make a request to the external API
+        API_URL = "https://organizedprogrammers-fastapi-kig.hf.space/"
+        endpoint = f"{API_URL}/key-issue-format"
+        api_data = {"query": query}
+        
+        response = requests.post(endpoint, json=api_data, verify=False)
+        if response.status_code == 200:
+            result = response.json()
+            return jsonify(result)
+        else:
+            return jsonify({
+                'error': f"API Error: {response.status_code}",
+                'key_issues': []
+            })
+            
+    except Exception as e:
+        print(f"Error generating key issues: {e}")
+        return jsonify({'error': str(e), 'key_issues': []})
+
+if __name__ == '__main__':
+    app.run(host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,12 @@
+Flask
+duckduckgo-search
+httpx
+requests
+beautifulsoup4
+PyMuPDF
+urllib3
+pandas
+groq
+astor
+openpyxl
+xlsxwriter

static/script.js

@@ -0,0 +1,2139 @@
+// Array to store problem history versions
+const problemHistory = [];
+let currentHistoryIndex = -1;
+// Store all refined problem suggestions
+let storedRefinedProblems = {};
+document.getElementById("tab1").style.display = "block";
+
+function openTab(evt, tabName) {
+    var i, tabcontent, tablinks;
+    tabcontent = document.getElementsByClassName("tabcontent");
+    for (i = 0; i < tabcontent.length; i++) {
+      tabcontent[i].style.display = "none";
+    }
+    tablinks = document.getElementsByClassName("tablinks");
+    for (i = 0; i < tablinks.length; i++) {
+      tablinks[i].className = tablinks[i].className.replace(" active", "");
+    }
+    document.getElementById(tabName).style.display = "block";
+    evt.currentTarget.className += " active";
+}
+
+function navigateProblemHistory(direction) {
+    const problemInput = document.getElementById('userProblemDescription');
+    console.log("Current history index:", currentHistoryIndex, "Total history:", problemHistory.length);
+    
+    if (direction === 'prev' && currentHistoryIndex > 0) {
+        currentHistoryIndex--;
+        problemInput.value = problemHistory[currentHistoryIndex];
+        console.log("Moving to previous version:", currentHistoryIndex);
+    } else if (direction === 'next' && currentHistoryIndex < problemHistory.length - 1) {
+        currentHistoryIndex++;
+        problemInput.value = problemHistory[currentHistoryIndex];
+        console.log("Moving to next version:", currentHistoryIndex);
+    }
+    
+    updateHistoryNavigation();
+}
+
+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.querySelector(".progress-text").innerHTML = "Generating key issues ... Please wait."
+    document.getElementById('globalLoadingOverlay').style.display = 'flex';
+    
+    // Send message to Flask backend
+    fetch('https://organizedprogrammers-fastapi-kig.hf.space/key-issue-format', {
+        method: 'POST',
+        body: JSON.stringify({ 'query': userInput }),
+        headers: { 'Content-Type': 'application/json' }
+    })
+    .then(response => response.json())
+    .then(data => {
+        // Hide loading indicator
+        document.getElementById('globalLoadingOverlay').style.display = 'none';
+        
+        // Check if we have key issues in the response
+        if (data.key_issues && data.key_issues.length > 0) {
+            // Display the key issues
+            displayKeyIssues(data.key_issues);
+        } else if (data.error) {
+            alert('Error: ' + data.error);
+        } else {
+            alert('No key issues found. Please try a different query.');
+        }
+    })
+    .catch(error => {
+        document.getElementById('globalLoadingOverlay').style.display = 'none';
+        console.error('Error:', error);
+        alert('There was an error communicating with the server. Please try again.');
+    });
+}
+
+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('userProblemDescription').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';
+            }
+            
+            // Add "Extract Insights" button to the justify cell
+            const insightsButton = document.createElement('button');
+            insightsButton.textContent = 'Extract Insights';
+            insightsButton.className = 'action-button insights-button';
+            insightsButton.style.marginTop = '5px';
+            insightsButton.style.fontSize = '0.8em';
+            insightsButton.onclick = function(e) {
+                e.preventDefault();
+                extractInsights(paperUrl, targetRow);
+            };
+            justificationCell.appendChild(document.createElement('br'));
+            justificationCell.appendChild(insightsButton);
+        } else {
+            scoreCell.innerHTML = 'No data';
+            justificationCell.innerHTML = 'Analysis failed';
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        scoreCell.innerHTML = 'Error';
+        justificationCell.innerHTML = 'Failed to analyze paper';
+    });
+}
+
+function extractInsights(paperUrl, row) {
+    const patentBackground = document.getElementById('userProblemDescription').value.trim();
+    if (!patentBackground) {
+        alert('Please provide a patent background in the input field');
+        return;
+    }
+    
+    const documentType = row.cells[0].textContent.toLowerCase();
+    
+    // Check if there's already an insights row for this document
+    let insightsRow = row.nextElementSibling;
+    if (insightsRow && insightsRow.className === 'insights-row') {
+        // Insights row already exists, get the container
+        insightsContainer = insightsRow.querySelector('.insights-container');
+        insightsContainer.innerHTML = '<div class="loading-spinner"></div><div>Extracting insights...</div>';
+    } else {
+        // Create insights row that spans across all columns
+        insightsRow = document.createElement('tr');
+        insightsRow.className = 'insights-row';
+        
+        const insightsTd = document.createElement('td');
+        insightsTd.colSpan = row.cells.length;
+        
+        insightsContainer = document.createElement('div');
+        insightsContainer.className = 'insights-container';
+        insightsContainer.innerHTML = '<div class="loading-spinner"></div><div>Extracting insights...</div>';
+        
+        insightsTd.appendChild(insightsContainer);
+        insightsRow.appendChild(insightsTd);
+        
+        // Insert after the current row
+        row.parentNode.insertBefore(insightsRow, row.nextSibling);
+    }
+    
+    // Store the row reference as a data attribute on the container for later access
+    insightsContainer.dataset.parentRow = row.rowIndex;
+    
+    // Send request to extract insights
+    fetch('/post_insights', {
+        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) {
+            insightsContainer.innerHTML = `<div class="error">Error: ${data.error}</div>`;
+        } else if (data.result && data.result.insights) {
+            // Create header with title and actions
+            const insightsHeader = document.createElement('div');
+            insightsHeader.className = 'insights-header';
+            
+            const insightsTitle = document.createElement('div');
+            insightsTitle.className = 'insights-title';
+            insightsTitle.textContent = 'Document Insights';
+            
+            const insightsActions = document.createElement('div');
+            insightsActions.className = 'insights-actions';
+            
+            // Store the insights for this specific container
+            const containerInsights = [...data.result.insights];
+            insightsContainer.dataset.allInsights = JSON.stringify(containerInsights);
+            
+            const selectAllBtn = document.createElement('button');
+            selectAllBtn.className = 'insights-button select-all-btn';
+            selectAllBtn.textContent = 'Select All';
+            // Use a closure to ensure the button has access to the correct container and row
+            selectAllBtn.addEventListener('click', function() {
+                const container = this.closest('.insights-container');
+                const parentRow = row;
+                const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                
+                const tags = container.querySelectorAll('.insight-tag');
+                tags.forEach(tag => tag.classList.add('selected'));
+                
+                parentRow.dataset.selectedInsights = JSON.stringify(allInsights);
+                parentRow.dataset.unselectedInsights = JSON.stringify([]);
+                
+                // Trigger check for enabling/disabling enhance button
+                checkSelectedInsights();
+            });
+            
+            const clearAllBtn = document.createElement('button');
+            clearAllBtn.className = 'insights-button clear-all-btn';
+            clearAllBtn.textContent = 'Clear All';
+            // Use a closure to ensure the button has access to the correct container and row
+            clearAllBtn.addEventListener('click', function() {
+                const container = this.closest('.insights-container');
+                const parentRow = row;
+                const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                
+                const tags = container.querySelectorAll('.insight-tag');
+                tags.forEach(tag => tag.classList.remove('selected'));
+                
+                parentRow.dataset.selectedInsights = JSON.stringify([]);
+                parentRow.dataset.unselectedInsights = JSON.stringify(allInsights);
+                
+                // Trigger check for enabling/disabling enhance button
+                checkSelectedInsights();
+            });
+            
+            insightsActions.appendChild(selectAllBtn);
+            insightsActions.appendChild(clearAllBtn);
+            
+            insightsHeader.appendChild(insightsTitle);
+            insightsHeader.appendChild(insightsActions);
+            
+            // Create insight tags
+            const insightsList = document.createElement('div');
+            insightsList.className = 'insights-list';
+            
+            // Clear the container and add the new elements
+            insightsContainer.innerHTML = '';
+            insightsContainer.appendChild(insightsHeader);
+            insightsContainer.appendChild(insightsList);
+            
+            // Initialize selected insights
+            const selectedInsights = [];
+            const unselectedInsights = [];
+            
+            // Add insight tags
+            data.result.insights.forEach(insight => {
+                const tagElement = document.createElement('div');
+                tagElement.className = 'insight-tag';
+                tagElement.textContent = insight;
+                tagElement.addEventListener('click', function() {
+                    this.classList.toggle('selected');
+                    
+                    // Update selected insights
+                    updateSelectedInsights(row, insightsContainer);
+                    
+                    // Trigger check for enabling/disabling enhance button
+                    checkSelectedInsights();
+                });
+                
+                // Add to unselected by default
+                // tagElement.classList.add('selected');
+                unselectedInsights.push(insight);
+                
+                insightsList.appendChild(tagElement);
+            });
+            
+            // Store initial selections
+            row.dataset.selectedInsights = JSON.stringify(selectedInsights);
+            row.dataset.unselectedInsights = JSON.stringify(unselectedInsights);
+            
+            // Trigger check for enabling/disabling enhance button immediately
+            checkSelectedInsights();
+            
+        } else {
+            insightsContainer.innerHTML = '<div class="error">No insights found</div>';
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        insightsContainer.innerHTML = `<div class="error">Error extracting insights: ${error.message}</div>`;
+    });
+}
+
+function updateSelectedInsights(row, insightsContainer) {
+    const selectedInsights = [];
+    const unselectedInsights = [];
+    
+    const tags = insightsContainer.querySelectorAll('.insight-tag');
+    tags.forEach(tag => {
+        if (tag.classList.contains('selected')) {
+            selectedInsights.push(tag.textContent);
+        } else {
+            unselectedInsights.push(tag.textContent);
+        }
+    });
+    
+    row.dataset.selectedInsights = JSON.stringify(selectedInsights);
+    row.dataset.unselectedInsights = JSON.stringify(unselectedInsights);
+}
+
+function checkSelectedInsights() {
+    const selectedInsights = collectAllSelectedInsights();
+    const enhanceButton = document.getElementById('enhanceProblemButton');
+    
+    if (selectedInsights.length > 0) {
+        enhanceButton.classList.remove('disabled');
+        enhanceButton.disabled = false;
+    } else {
+        enhanceButton.classList.add('disabled');
+        enhanceButton.disabled = true;
+    }
+}
+
+function collectAllSelectedInsights() {
+    const allSelectedInsights = [];
+    const queryItems = document.querySelectorAll('.query-item');
+    
+    queryItems.forEach(queryItem => {
+        const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+        rows.forEach(row => {
+            if (row.dataset.selectedInsights) {
+                try {
+                    const selectedInsights = JSON.parse(row.dataset.selectedInsights);
+                    selectedInsights.forEach(insight => {
+                        if (!allSelectedInsights.includes(insight)) {
+                            allSelectedInsights.push(insight);
+                        }
+                    });
+                } catch (e) {
+                    console.error('Error parsing selected insights:', e);
+                }
+            }
+        });
+    });
+    
+    return allSelectedInsights;
+}
+
+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:not(.insights-row)');
+            
+            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.split('\n')[0]; // Only get the justification text
+                } else {
+                    rowData['Score'] = '';
+                    rowData['Justification'] = '';
+                }
+                
+                // Add selected and unselected insights if they exist
+                if (row.dataset.selectedInsights) {
+                    try {
+                        const selectedInsights = JSON.parse(row.dataset.selectedInsights);
+                        rowData['Selected Insights'] = selectedInsights.join('; ');
+                    } catch (e) {
+                        rowData['Selected Insights'] = '';
+                    }
+                } else {
+                    rowData['Selected Insights'] = '';
+                }
+                
+                if (row.dataset.unselectedInsights) {
+                    try {
+                        const unselectedInsights = JSON.parse(row.dataset.unselectedInsights);
+                        rowData['Unselected Insights'] = unselectedInsights.join('; ');
+                    } catch (e) {
+                        rowData['Unselected Insights'] = '';
+                    }
+                } else {
+                    rowData['Unselected Insights'] = '';
+                }
+                
+                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;
+        }
+        
+        // Get all problem versions
+        const problemVersions = {};
+        if (problemHistory.length > 0) {
+            problemHistory.forEach((problem, index) => {
+                problemVersions[`Problem Version ${index + 1}`] = problem;
+            });
+        } else {
+            // If no history, just use the current problem
+            const currentProblem = document.getElementById('userProblemDescription').value.trim();
+            if (currentProblem) {
+                problemVersions['Problem Version 1'] = currentProblem;
+            }
+        }
+        
+        // Send to server for Excel generation
+        fetch('/export-excel', {
+            method: 'POST',
+            body: JSON.stringify({
+                'tableData': allData,
+                'userQuery': document.getElementById('userProblemDescription').value,
+                'problemVersions': problemVersions
+            }),
+            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}`);
+    }
+}
+
+function hasSearchResults() {
+    const resultsContainer = document.getElementById('resultsContainer');
+    const hasResults = resultsContainer && resultsContainer.style.display !== 'none';
+    const hasTables = document.querySelectorAll('.results-table[style*="display: table"]').length > 0;
+    return hasResults && hasTables;
+}
+
+
+function analyzeAllPapers() {
+    // Show loading overlay
+    const loadingOverlay = document.getElementById('globalLoadingOverlay');
+    if (loadingOverlay) loadingOverlay.style.display = 'flex';
+    if (loadingOverlay) loadingOverlay.querySelector('.progress-text').textContent = 'Analyzing all papers...';
+    
+    // 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('userProblemDescription').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';
+                                }
+                                
+                                // Add "Extract Insights" button to the justify cell - for Analyze All function
+                                const insightsButton = document.createElement('button');
+                                insightsButton.textContent = 'Extract Insights';
+                                insightsButton.className = 'action-button insights-button';
+                                insightsButton.style.marginTop = '5px';
+                                insightsButton.style.fontSize = '0.8em';
+                                insightsButton.onclick = function(e) {
+                                    e.preventDefault();
+                                    extractInsights(urlLink.href, row);
+                                };
+                                justificationCell.appendChild(document.createElement('br'));
+                                justificationCell.appendChild(insightsButton);
+                            } 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();
+                }
+            }
+        });
+    });
+}
+
+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++;
+                }
+            }
+        });
+    });
+    
+    // Create and display a simple notification instead of alert
+    const notification = document.createElement('div');
+    notification.className = 'simple-notification';
+    notification.textContent = `Removed ${removedCount} papers with failed analyses`;
+    notification.style.position = 'fixed';
+    notification.style.top = '20px';
+    notification.style.right = '20px';
+    notification.style.background = '#4CAF50';
+    notification.style.color = 'white';
+    notification.style.padding = '15px';
+    notification.style.borderRadius = '5px';
+    notification.style.boxShadow = '0 2px 5px rgba(0,0,0,0.2)';
+    notification.style.zIndex = '10000';
+    
+    // Add notification to the body
+    document.body.appendChild(notification);
+    
+    // Remove notification after 3 seconds
+    setTimeout(() => {
+        if (notification.parentNode) {
+            notification.parentNode.removeChild(notification);
+        }
+    }, 3000);
+}
+
+function extractAllInsights() {
+    const patentBackground = document.getElementById('userProblemDescription').value.trim();
+    if (!patentBackground) {
+        alert('Please provide a patent background in the input field');
+        return;
+    }
+    
+    // Show loading overlay
+    const loadingOverlay = document.getElementById('globalLoadingOverlay');
+    if (loadingOverlay) {
+        loadingOverlay.style.display = 'flex';
+        loadingOverlay.querySelector('.progress-text').textContent = 'Extracting insights from all documents...';
+    }
+    
+    // Get all query items
+    const queryItems = document.querySelectorAll('.query-item');
+    let totalDocuments = 0;
+    let completedDocuments = 0;
+    
+    // Count total analyzed documents that need insights extraction
+    const analyzedRows = [];
+    queryItems.forEach(queryItem => {
+        const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+        rows.forEach(row => {
+            // Only include rows that have been analyzed (have score and justification cells)
+            if (row.cells.length > 4 && row.cells[4].textContent.trim() !== 'Error' && 
+                row.cells[4].textContent.trim() !== 'N/A' && row.cells[4].textContent.trim() !== '') {
+                analyzedRows.push(row);
+                totalDocuments++;
+            }
+        });
+    });
+    
+    if (totalDocuments === 0) {
+        if (loadingOverlay) loadingOverlay.style.display = 'none';
+        alert('No analyzed documents found. Please analyze documents first.');
+        return;
+    }
+    
+    // Function to update progress
+    function updateProgress() {
+        completedDocuments++;
+        if (loadingOverlay) {
+            const progressElement = loadingOverlay.querySelector('.progress-text');
+            if (progressElement) {
+                progressElement.textContent = `Extracting insights: ${completedDocuments}/${totalDocuments}`;
+            }
+        }
+        
+        if (completedDocuments >= totalDocuments) {
+            if (loadingOverlay) loadingOverlay.style.display = 'none';
+            checkSelectedInsights(); // Update enhance button state based on selected insights
+        }
+    }
+    
+    // Process each analyzed document sequentially to avoid overwhelming the server
+    function processNextDocument(index) {
+        if (index >= analyzedRows.length) {
+            return; // All documents processed
+        }
+        
+        const row = analyzedRows[index];
+        const urlLink = row.querySelector('.url-link');
+        const documentType = row.cells[0].textContent.toLowerCase();
+        
+        if (!urlLink || !urlLink.href) {
+            updateProgress();
+            processNextDocument(index + 1);
+            return;
+        }
+        
+        // Check if there's already an insights row for this document
+        let insightsRow = row.nextElementSibling;
+        if (insightsRow && insightsRow.className === 'insights-row') {
+            // Insights row already exists, get the container
+            insightsContainer = insightsRow.querySelector('.insights-container');
+            insightsContainer.innerHTML = '<div class="loading-spinner"></div><div>Extracting insights...</div>';
+        } else {
+            // Create insights row that spans across all columns
+            insightsRow = document.createElement('tr');
+            insightsRow.className = 'insights-row';
+            
+            const insightsTd = document.createElement('td');
+            insightsTd.colSpan = row.cells.length;
+            
+            insightsContainer = document.createElement('div');
+            insightsContainer.className = 'insights-container';
+            insightsContainer.innerHTML = '<div class="loading-spinner"></div><div>Extracting insights...</div>';
+            
+            insightsTd.appendChild(insightsContainer);
+            insightsRow.appendChild(insightsTd);
+            
+            // Insert after the current row
+            row.parentNode.insertBefore(insightsRow, row.nextSibling);
+        }
+        
+        // Store the row reference as a data attribute on the container for later access
+        insightsContainer.dataset.parentRow = row.rowIndex;
+        
+        // Send request to extract insights
+        fetch('/post_insights', {
+            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) {
+                insightsContainer.innerHTML = `<div class="error">Error: ${data.error}</div>`;
+            } else if (data.result && data.result.insights) {
+                // Create header with title and actions
+                const insightsHeader = document.createElement('div');
+                insightsHeader.className = 'insights-header';
+                
+                const insightsTitle = document.createElement('div');
+                insightsTitle.className = 'insights-title';
+                insightsTitle.textContent = 'Document Insights';
+                
+                const insightsActions = document.createElement('div');
+                insightsActions.className = 'insights-actions';
+                
+                // Store the insights for this specific container
+                const containerInsights = [...data.result.insights];
+                insightsContainer.dataset.allInsights = JSON.stringify(containerInsights);
+                
+                const selectAllBtn = document.createElement('button');
+                selectAllBtn.className = 'insights-button select-all-btn';
+                selectAllBtn.textContent = 'Select All';
+                selectAllBtn.addEventListener('click', function() {
+                    const container = this.closest('.insights-container');
+                    const parentRow = row;
+                    const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                    
+                    const tags = container.querySelectorAll('.insight-tag');
+                    tags.forEach(tag => tag.classList.add('selected'));
+                    
+                    parentRow.dataset.selectedInsights = JSON.stringify(allInsights);
+                    parentRow.dataset.unselectedInsights = JSON.stringify([]);
+                    
+                    checkSelectedInsights();
+                });
+                
+                const clearAllBtn = document.createElement('button');
+                clearAllBtn.className = 'insights-button clear-all-btn';
+                clearAllBtn.textContent = 'Clear All';
+                clearAllBtn.addEventListener('click', function() {
+                    const container = this.closest('.insights-container');
+                    const parentRow = row;
+                    const allInsights = JSON.parse(container.dataset.allInsights || '[]');
+                    
+                    const tags = container.querySelectorAll('.insight-tag');
+                    tags.forEach(tag => tag.classList.remove('selected'));
+                    
+                    parentRow.dataset.selectedInsights = JSON.stringify([]);
+                    parentRow.dataset.unselectedInsights = JSON.stringify(allInsights);
+                    
+                    checkSelectedInsights();
+                });
+                
+                insightsActions.appendChild(selectAllBtn);
+                insightsActions.appendChild(clearAllBtn);
+                
+                insightsHeader.appendChild(insightsTitle);
+                insightsHeader.appendChild(insightsActions);
+                
+                // Create insight tags
+                const insightsList = document.createElement('div');
+                insightsList.className = 'insights-list';
+                
+                // Clear the container and add the new elements
+                insightsContainer.innerHTML = '';
+                insightsContainer.appendChild(insightsHeader);
+                insightsContainer.appendChild(insightsList);
+                
+                // Initialize selected insights
+                const selectedInsights = [];
+                const unselectedInsights = [];
+                
+                // Add insight tags
+                data.result.insights.forEach(insight => {
+                    const tagElement = document.createElement('div');
+                    tagElement.className = 'insight-tag';
+                    tagElement.textContent = insight;
+                    tagElement.addEventListener('click', function() {
+                        this.classList.toggle('selected');
+                        updateSelectedInsights(row, insightsContainer);
+                        checkSelectedInsights();
+                    });
+                    
+                    // Add to unselected by default
+                    // tagElement.classList.add('selected');
+                    unselectedInsights.push(insight);
+                    
+                    insightsList.appendChild(tagElement);
+                });
+                
+                // Store initial selections
+                row.dataset.selectedInsights = JSON.stringify(selectedInsights);
+                row.dataset.unselectedInsights = JSON.stringify(unselectedInsights);
+                
+            } else {
+                insightsContainer.innerHTML = '<div class="error">No insights found</div>';
+            }
+            
+            // Process next document
+            updateProgress();
+            processNextDocument(index + 1);
+        })
+        .catch(error => {
+            console.error('Error:', error);
+            insightsContainer.innerHTML = `<div class="error">Error extracting insights: ${error.message}</div>`;
+            
+            // Continue with next document even if this one failed
+            updateProgress();
+            processNextDocument(index + 1);
+        });
+    }
+    
+    // Start processing documents
+    processNextDocument(0);
+}
+
+
+function groupInsightsByScore() {
+    // Get all query items
+    const queryItems = document.querySelectorAll('.query-item');
+    let hasInsights = false;
+    
+    // Create structure to hold insights grouped by score
+    const insightsByScore = {
+        5: { insights: [], sources: [] },
+        4: { insights: [], sources: [] },
+        3: { insights: [], sources: [] },
+        2: { insights: [], sources: [] },
+        1: { insights: [], sources: [] },
+        0: { insights: [], sources: [] }
+    };
+    
+    // Collect all insights from all documents and group by score
+    queryItems.forEach(queryItem => {
+        const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+        rows.forEach(row => {
+            // Skip if no score or insights
+            if (row.cells.length <= 4 || !row.dataset.selectedInsights) {
+                return;
+            }
+            
+            // Get the score
+            const scoreText = row.cells[4].textContent.trim();
+            if (scoreText === 'Error' || scoreText === 'N/A' || isNaN(parseFloat(scoreText))) {
+                return;
+            }
+            
+            const score = Math.round(parseFloat(scoreText));
+            const urlLink = row.querySelector('.url-link');
+            
+            if (!urlLink) return;
+            
+            // Get insights from this document
+            try {
+                const selectedInsights = JSON.parse(row.dataset.selectedInsights || '[]');
+                const unselectedInsights = JSON.parse(row.dataset.unselectedInsights || '[]');
+                const allInsights = [...selectedInsights, ...unselectedInsights];
+                
+                // Add insights to the appropriate score group
+                if (score >= 0 && score <= 5 && allInsights.length > 0) {
+                    hasInsights = true;
+                    
+                    // For all insights in this document
+                    allInsights.forEach(insight => {
+                        // Check if this insight is already in the group
+                        const existingIndex = insightsByScore[score].insights.findIndex(i => i === insight);
+                        
+                        if (existingIndex === -1) {
+                            // New insight
+                            insightsByScore[score].insights.push(insight);
+                            insightsByScore[score].sources.push({
+                                url: urlLink.href,
+                                title: row.cells[1].textContent.trim().substring(0, 30) + '...',
+                                selected: selectedInsights.includes(insight)
+                            });
+                        }
+                    });
+                }
+            } catch (e) {
+                console.error('Error parsing insights:', e);
+            }
+        });
+    });
+    
+    if (!hasInsights) {
+        alert('No insights found. Please analyze documents and extract insights first.');
+        return;
+    }
+    
+    // Create or get the grouped insights container
+    let container = document.getElementById('groupedInsightsContainer');
+    if (!container) {
+        container = document.createElement('div');
+        container.id = 'groupedInsightsContainer';
+        container.className = 'grouped-insights-container';
+        
+        // Insert after the problem input card
+        const card = document.querySelector("#tab2 .card");
+        card.parentNode.insertBefore(container, card.nextSibling);
+    }
+    
+    // Create header
+    const header = document.createElement('div');
+    header.className = 'grouped-insights-header';
+    header.innerHTML = `
+        <div>Insights Grouped by Score</div>
+        <div class="grouped-insights-actions">
+            <button class="ai-select-btn pulse" id="aiSelectButton" onclick="aiSelectInsights()">AI Select Insights</button>
+            <div class="grouped-insights-close" onclick="closeGroupedInsights()">&times;</div>
+        </div>
+    `;
+    
+    // Create content area
+    const content = document.createElement('div');
+    content.className = 'grouped-insights-content';
+    
+    // Create score groups
+    for (let score = 5; score >= 0; score--) {
+        const insights = insightsByScore[score].insights;
+        const sources = insightsByScore[score].sources;
+        
+        if (insights.length === 0) continue;
+        
+        const scoreGroup = document.createElement('div');
+        scoreGroup.className = 'score-group';
+        scoreGroup.dataset.score = score;
+        
+        // Create score header
+        const scoreHeader = document.createElement('div');
+        scoreHeader.className = 'score-group-header';
+        
+        let scoreColor = '';
+        if (score >= 0 && score <= 5) {
+            const redComponent = Math.floor((score / 5) * 255);
+            const greenComponent = Math.floor(((5 - score) / 5) * 255);
+            scoreColor = `background-color: rgb(${redComponent}, ${greenComponent}, 0); color: white;`;
+        }
+        
+        scoreHeader.innerHTML = `
+            <div>
+                <span style="display: inline-block; width: 25px; height: 25px; text-align: center; border-radius: 50%; ${scoreColor} font-weight: bold;">${score}</span>
+                <span style="margin-left: 8px;">Score ${score} Insights (${insights.length})</span>
+            </div>
+            <div class="score-group-actions">
+                <button class="insights-button select-score-all-btn" onclick="selectAllInScore(${score})">Select All</button>
+                <button class="insights-button clear-score-all-btn" onclick="clearAllInScore(${score})">Clear All</button>
+            </div>
+        `;
+        
+        // Create insights list
+        const insightsList = document.createElement('div');
+        insightsList.className = 'score-insights-list';
+        
+        // Add each insight
+        insights.forEach((insight, index) => {
+            const source = sources[index];
+            const tagElement = document.createElement('div');
+            tagElement.className = `grouped-insight-tag${source.selected ? ' selected' : ''}`;
+            tagElement.dataset.score = score;
+            tagElement.dataset.index = index;
+            tagElement.dataset.source = source.url;
+            
+            // Create insight text with source link
+            tagElement.innerHTML = `
+                ${insight}
+                <a href="${source.url}" target="_blank" class="insight-source" title="${source.title}">${score}</a>
+            `;
+            
+            // Add click event to toggle selection
+            tagElement.addEventListener('click', function(e) {
+                // Prevent clicking on the source link from toggling selection
+                if (e.target.classList.contains('insight-source')) return;
+                
+                this.classList.toggle('selected');
+                updateGroupedInsightSelections();
+            });
+            
+            insightsList.appendChild(tagElement);
+        });
+        
+        // Add header and list to score group
+        scoreGroup.appendChild(scoreHeader);
+        scoreGroup.appendChild(insightsList);
+        
+        // Add score group to content
+        content.appendChild(scoreGroup);
+    }
+    
+    // Clear the container and add new content
+    container.innerHTML = '';
+    container.appendChild(header);
+    container.appendChild(content);
+    
+    // Show the container
+    container.style.display = 'block';
+    
+    // Collapse all accordions
+    const accordions = document.querySelectorAll('.accordion-section');
+    accordions.forEach(accordion => {
+        const header = accordion.querySelector('.accordion-header');
+        const body = accordion.querySelector('.accordion-body');
+        if (header && body && !header.classList.contains('collapsed')) {
+            header.classList.add('collapsed');
+            body.classList.add('collapsed');
+            
+            // Update the toggle icon
+            const toggleIcon = header.querySelector('.toggle-icon');
+            if (toggleIcon) toggleIcon.textContent = '▶';
+        }
+    });
+    
+    // Scroll to the insights container
+    container.scrollIntoView({ behavior: 'smooth' });
+    
+    // Remove the pulse animation after a few seconds
+    setTimeout(() => {
+        const aiSelectBtn = document.getElementById('aiSelectButton');
+        if (aiSelectBtn) {
+            aiSelectBtn.classList.remove('pulse');
+        }
+    }, 5000);
+}
+
+function enhanceProblem() {
+    const problemInput = document.getElementById('userProblemDescription');
+    const originalProblem = problemInput.value.trim();
+    
+    if (!originalProblem) {
+        alert('Please provide a technical problem description first');
+        return;
+    }
+    
+    const selectedInsights = collectAllSelectedInsights();
+    if (selectedInsights.length === 0) {
+        alert('Please select at least one insight to enhance the problem');
+        return;
+    }
+    
+    // Get user comments if any
+    const userComments = document.getElementById('insightCommentArea')?.value || '';
+    
+    // If we have stored refined problems for this exact problem, just show them
+    const currentProblemKey = JSON.stringify({
+        problem: originalProblem,
+        insights: selectedInsights.sort(),
+        comments: userComments
+    });
+    
+    if (storedRefinedProblems[currentProblemKey]) {
+        showRefinedProblems(storedRefinedProblems[currentProblemKey]);
+        return;
+    }
+    
+    // Show loading overlay
+    const loadingOverlay = document.getElementById('globalLoadingOverlay');
+    if (loadingOverlay) {
+        loadingOverlay.style.display = 'flex';
+        loadingOverlay.querySelector('.progress-text').textContent = 'Enhancing problem statement...';
+    }
+    
+    // Send request to backend to refine the problem
+    fetch('/refine-problem', {
+        method: 'POST',
+        body: JSON.stringify({
+            'original_problem': originalProblem,
+            'insights': selectedInsights,
+            'user_comments': userComments
+        }),
+        headers: { 'Content-Type': 'application/json' }
+    })
+    .then(response => response.json())
+    .then(data => {
+        // Hide loading overlay
+        if (loadingOverlay) loadingOverlay.style.display = 'none';
+        
+        if (data.error) {
+            alert(`Error: ${data.error}`);
+            return;
+        }
+        
+        if (data.result) {
+            // Add current problem to history if not already there
+            if (currentHistoryIndex === -1) {
+                problemHistory.push(originalProblem);
+                currentHistoryIndex = 0;
+            }
+            
+            // Store the refined problems for future use
+            storedRefinedProblems[currentProblemKey] = data.result;
+            
+            // Show refined problem options
+            showRefinedProblems(data.result);
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        if (loadingOverlay) loadingOverlay.style.display = 'none';
+        alert(`Error enhancing problem: ${error.message}`);
+    });
+}
+
+function closeGroupedInsights() {
+    const container = document.getElementById('groupedInsightsContainer');
+    if (container) {
+        container.style.display = 'none';
+    }
+}
+
+// Select all insights for a specific score
+function selectAllInScore(score) {
+    const container = document.getElementById('groupedInsightsContainer');
+    const tags = container.querySelectorAll(`.grouped-insight-tag[data-score="${score}"]`);
+    
+    tags.forEach(tag => {
+        tag.classList.add('selected');
+    });
+    
+    updateGroupedInsightSelections();
+}
+
+// Clear all insights for a specific score
+function clearAllInScore(score) {
+    const container = document.getElementById('groupedInsightsContainer');
+    const tags = container.querySelectorAll(`.grouped-insight-tag[data-score="${score}"]`);
+    
+    tags.forEach(tag => {
+        tag.classList.remove('selected');
+    });
+    
+    updateGroupedInsightSelections();
+}
+
+function updateGroupedInsightSelections() {
+    // Get all selected insights from the grouped view
+    const container = document.getElementById('groupedInsightsContainer');
+    const selectedTags = container.querySelectorAll('.grouped-insight-tag.selected');
+    
+    // Create a mapping of URL to selected insights
+    const selectionsBySource = {};
+    
+    // Process each selected tag
+    selectedTags.forEach(tag => {
+        const insight = tag.textContent.trim().replace(/\d+$/, '').trim(); // Remove the score number at the end
+        const sourceUrl = tag.dataset.source;
+        
+        if (!selectionsBySource[sourceUrl]) {
+            selectionsBySource[sourceUrl] = [];
+        }
+        
+        selectionsBySource[sourceUrl].push(insight);
+    });
+    
+    // Now update the original document rows
+    const queryItems = document.querySelectorAll('.query-item');
+    queryItems.forEach(queryItem => {
+        const rows = queryItem.querySelectorAll('tbody tr:not(.insights-row)');
+        rows.forEach(row => {
+            const urlLink = row.querySelector('.url-link');
+            if (!urlLink) return;
+            
+            const sourceUrl = urlLink.href;
+            
+            // If we have selections for this source
+            if (selectionsBySource[sourceUrl]) {
+                // Get all insights for this row
+                try {
+                    // Combine selected and unselected to get all insights
+                    const currentSelected = JSON.parse(row.dataset.selectedInsights || '[]');
+                    const currentUnselected = JSON.parse(row.dataset.unselectedInsights || '[]');
+                    const allInsights = [...currentSelected, ...currentUnselected];
+                    
+                    // New selected and unselected based on grouped view
+                    const newSelected = [];
+                    const newUnselected = [];
+                    
+                    // Process each insight
+                    allInsights.forEach(insight => {
+                        if (selectionsBySource[sourceUrl].includes(insight)) {
+                            newSelected.push(insight);
+                        } else {
+                            newUnselected.push(insight);
+                        }
+                    });
+                    
+                    // Update the dataset
+                    row.dataset.selectedInsights = JSON.stringify(newSelected);
+                    row.dataset.unselectedInsights = JSON.stringify(newUnselected);
+                } catch (e) {
+                    console.error('Error updating insights selections:', e);
+                }
+            }
+        });
+    });
+    
+    // Update enhance button state
+    checkSelectedInsights();
+}
+
+function showRefinedProblems(result) {
+    const refinedContainer = document.getElementById('refinedProblemContainer');
+    const tabs = document.getElementById('refinedProblemTabs');
+    const content = document.getElementById('refinedProblemContent');
+    
+    // Clear previous content
+    tabs.innerHTML = '';
+    content.innerHTML = '';
+    
+    // Add tabs and content for each refined problem
+    let isFirst = true;
+    for (const key in result) {
+        if (result.hasOwnProperty(key)) {
+            const problem = result[key];
+            
+            // Create tab
+            const tab = document.createElement('div');
+            tab.className = `refined-problem-tab ${isFirst ? 'active' : ''}`;
+            tab.dataset.target = key;
+            tab.textContent = `Option ${key.split('_')[1]}`;
+            tab.onclick = function() {
+                document.querySelectorAll('.refined-problem-tab').forEach(t => t.classList.remove('active'));
+                document.querySelectorAll('.refined-problem').forEach(p => p.classList.remove('active'));
+                tab.classList.add('active');
+                document.getElementById(key).classList.add('active');
+            };
+            tabs.appendChild(tab);
+            
+            // Create content
+            const problemDiv = document.createElement('div');
+            problemDiv.className = `refined-problem ${isFirst ? 'active' : ''}`;
+            problemDiv.id = key;
+            
+            const title = document.createElement('div');
+            title.className = 'refined-problem-title';
+            title.textContent = problem.title;
+            
+            const description = document.createElement('div');
+            description.className = 'refined-problem-description';
+            description.textContent = problem.description;
+            
+            const applyButton = document.createElement('button');
+            applyButton.className = 'apply-problem-btn';
+            applyButton.textContent = 'Apply This Problem';
+            applyButton.onclick = function() {
+                applyRefinedProblem(problem.description);
+            };
+            
+            problemDiv.appendChild(title);
+            problemDiv.appendChild(description);
+            problemDiv.appendChild(applyButton);
+            
+            content.appendChild(problemDiv);
+            
+            isFirst = false;
+        }
+    }
+    
+    // Show the container
+    refinedContainer.style.display = 'block';
+    
+    // Scroll to the container
+    refinedContainer.scrollIntoView({ behavior: 'smooth' });
+}
+
+function applyRefinedProblem(problemText) {
+    const problemInput = document.getElementById('userProblemDescription');
+    
+    // Add current problem to history
+    problemHistory.push(problemInput.value);
+    currentHistoryIndex = problemHistory.length - 1; // Set to latest version
+    
+    // Update problem text with the new version
+    problemInput.value = problemText;
+    
+    // Now add the new version to history
+    problemHistory.push(problemText);
+    currentHistoryIndex = problemHistory.length - 1; // Update index to point to the newly added version
+    
+    // Update history navigation display
+    updateHistoryNavigation();
+    
+    // Display is kept visible, removed: document.getElementById('refinedProblemContainer').style.display = 'none';
+    
+    // Focus on the problem input
+    problemInput.focus();
+    
+    console.log("Problem history after applying:", problemHistory, "Current index:", currentHistoryIndex);
+}
+
+function updateHistoryNavigation() {
+    const historyNav = document.getElementById('problemHistoryNav');
+    const prevBtn = historyNav.querySelector('.history-prev');
+    const nextBtn = historyNav.querySelector('.history-next');
+    const status = historyNav.querySelector('.history-status');
+    
+    // Update buttons state
+    prevBtn.classList.toggle('disabled', currentHistoryIndex <= 0);
+    nextBtn.classList.toggle('disabled', currentHistoryIndex >= problemHistory.length - 1);
+    
+    // Update status text
+    if (problemHistory.length > 0) {
+        status.textContent = `Version ${currentHistoryIndex + 1} of ${problemHistory.length}`;
+        historyNav.style.display = 'flex';
+    } else {
+        historyNav.style.display = 'none';
+    }
+}
+
+function aiSelectInsights() {
+    const patentBackground = document.getElementById('userProblemDescription').value.trim();
+    if (!patentBackground) {
+        alert('Please provide a patent background in the input field');
+        return;
+    }
+    
+    // Change button appearance to show it's working
+    const aiSelectBtn = document.getElementById('aiSelectButton');
+    if (aiSelectBtn) {
+        aiSelectBtn.disabled = true;
+        aiSelectBtn.textContent = 'AI Selecting...';
+        aiSelectBtn.style.opacity = '0.7';
+    }
+    
+    // Show loading overlay
+    const loadingOverlay = document.getElementById('globalLoadingOverlay');
+    if (loadingOverlay) {
+        loadingOverlay.style.display = 'flex';
+        loadingOverlay.querySelector('.progress-text').textContent = 'AI selecting the most relevant insights...';
+    }
+    
+    // Get all insights from all score groups
+    const container = document.getElementById('groupedInsightsContainer');
+    const insightTags = container.querySelectorAll('.grouped-insight-tag');
+    const insights = Array.from(insightTags).map(tag => {
+        return tag.textContent.trim().replace(/\d+$/, '').trim(); // Remove the score number
+    });
+    
+    if (insights.length === 0) {
+        if (loadingOverlay) loadingOverlay.style.display = 'none';
+        alert('No insights found');
+        return;
+    }
+    
+    // Send request to backend to get AI selection
+    fetch('/ai-select-insights', {
+        method: 'POST',
+        body: JSON.stringify({
+            'patent_background': patentBackground,
+            'insights': insights
+        }),
+        headers: { 'Content-Type': 'application/json' }
+    })
+    .then(response => response.json())
+    .then(data => {
+        // Reset button appearance
+        if (aiSelectBtn) {
+            aiSelectBtn.disabled = false;
+            aiSelectBtn.textContent = 'AI Select Insights';
+            aiSelectBtn.style.opacity = '1';
+        }
+        
+        if (loadingOverlay) loadingOverlay.style.display = 'none';
+        
+        if (data.error) {
+            alert(`Error: ${data.error}`);
+            return;
+        }
+        
+        if (data.selected_insights && data.selected_insights.length > 0) {
+            // First clear all selections
+            insightTags.forEach(tag => {
+                tag.classList.remove('selected');
+            });
+            
+            // Then select the recommended insights
+            insightTags.forEach(tag => {
+                const insightText = tag.textContent.trim().replace(/\d+$/, '').trim();
+                if (data.selected_insights.includes(insightText)) {
+                    tag.classList.add('selected');
+                }
+            });
+            
+            // Update the original document rows
+            updateGroupedInsightSelections();
+            
+            // Remove alert notification - user can see the selected insights visually
+            // alert(`AI selected ${data.selected_insights.length} insights from ${insights.length} available insights`);
+        } else {
+            alert('AI could not identify any relevant insights to select');
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        
+        // Reset button appearance
+        if (aiSelectBtn) {
+            aiSelectBtn.disabled = false;
+            aiSelectBtn.textContent = 'AI Select Insights';
+            aiSelectBtn.style.opacity = '1';
+        }
+        
+        if (loadingOverlay) loadingOverlay.style.display = 'none';
+        alert(`Error using AI to select insights: ${error.message}`);
+    });
+}
+
+function generateSearchQueries() {
+    function addQueryField(queryText = '', container = null) {
+        const queriesContainer = container || document.getElementById('queriesContainer');
+        
+        // Count existing query items in this container for indexing
+        const queryItems = container ? 
+            container.querySelectorAll('.query-item') : 
+            document.getElementById('queriesContainer').querySelectorAll('.query-item');
+        
+        const queryIndex = queryItems.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() {
+            queryItem.parentNode.removeChild(queryItem);
+            
+            // Update the placeholder numbers for remaining queries within this container
+            const parent = container || document.getElementById('queriesContainer');
+            const items = parent.querySelectorAll('.query-item');
+            items.forEach((item, idx) => {
+                const field = item.querySelector('.query-field');
+                if (field) field.placeholder = `Search Query ${idx + 1}`;
+            });
+        };
+        
+        // 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);
+    }
+    
+    function createAccordionSection(timestamp) {
+        const accordionSection = document.createElement('div');
+        accordionSection.className = 'accordion-section';
+        
+        const accordionHeader = document.createElement('div');
+        accordionHeader.className = 'accordion-header';
+        accordionHeader.innerHTML = `
+            <span>Search Results <span class="query-timestamp">${timestamp}</span></span>
+            <span class="toggle-icon">▼</span>
+        `;
+        accordionHeader.onclick = function() {
+            this.classList.toggle('collapsed');
+            const body = this.nextElementSibling;
+            body.classList.toggle('collapsed');
+            
+            // Update the toggle icon
+            const toggleIcon = this.querySelector('.toggle-icon');
+            if (body.classList.contains('collapsed')) {
+                toggleIcon.textContent = '▶';
+            } else {
+                toggleIcon.textContent = '▼';
+            }
+        };
+        
+        const accordionBody = document.createElement('div');
+        accordionBody.className = 'accordion-body';
+        
+        const accordionContent = document.createElement('div');
+        accordionContent.className = 'accordion-content';
+        accordionBody.appendChild(accordionContent);
+        
+        accordionSection.appendChild(accordionHeader);
+        accordionSection.appendChild(accordionBody);
+        
+        return accordionSection;
+    }
+
+    const userInput = document.getElementById('userProblemDescription').value.trim();
+    if (!userInput) {
+        alert('Please enter a technical problem description');
+        return;
+    }
+    
+    // Show loading indicator
+    document.getElementById('loadingIndicator').style.display = 'block';
+    
+    // Collapse all existing query sections
+    const existingAccordions = document.querySelectorAll('.accordion-section');
+    existingAccordions.forEach(accordion => {
+        const header = accordion.querySelector('.accordion-header');
+        const body = accordion.querySelector('.accordion-body');
+        if (header && body && !header.classList.contains('collapsed')) {
+            header.classList.add('collapsed');
+            body.classList.add('collapsed');
+        }
+    });
+    
+    // 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);
+            }
+            
+            // Create a new accordion section for these search results
+            const timestamp = new Date().toLocaleString();
+            const accordionSection = createAccordionSection(timestamp);
+            
+            // Add each query from the response to this accordion
+            Object.keys(jsonData).forEach(key => {
+                addQueryField(jsonData[key], accordionSection.querySelector('.accordion-content'));
+            });
+            
+            // Add the accordion to the container
+            const queriesContainer = document.getElementById('queriesContainer');
+            queriesContainer.insertBefore(accordionSection, queriesContainer.firstChild);
+            
+            // 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.');
+    });
+}
+
+function displayKeyIssues(keyIssues) {
+    // Get or create the key issues container
+    let keyIssuesContainer = document.getElementById('keyIssuesContainer');
+    if (!keyIssuesContainer) {
+        keyIssuesContainer = document.createElement('div');
+        keyIssuesContainer.id = 'keyIssuesContainer';
+        keyIssuesContainer.className = 'key-issues-container';
+        document.getElementById('resultsContainer').appendChild(keyIssuesContainer);
+    }
+    
+    // Clear previous content
+    keyIssuesContainer.innerHTML = '';
+    
+    // Create header
+    const header = document.createElement('h3');
+    header.textContent = 'Key Issues';
+    keyIssuesContainer.appendChild(header);
+    
+    // Create issues list
+    const issuesList = document.createElement('div');
+    issuesList.className = 'key-issues-list';
+
+    const KIsubmitButton = document.createElement('button');
+    KIsubmitButton.className = "btn btn-primary";
+    KIsubmitButton.id = "key-issues-submit-btn";
+    KIsubmitButton.textContent = "Generate problem descriptions";
+    KIsubmitButton.style.marginTop = "10px";
+    KIsubmitButton.onclick = generateProblemDescriptions;
+
+    const centerButton = document.createElement("center");
+    centerButton.appendChild(KIsubmitButton);
+
+    
+    // Add each key issue
+    keyIssues.forEach(issue => {
+        const issueCard = document.createElement('div');
+        issueCard.className = 'key-issue-card';
+        issueCard.dataset.id = issue.id;
+        
+        const issueTitle = document.createElement('div');
+        issueTitle.className = 'key-issue-title';
+        issueTitle.textContent = issue.title;
+        
+        const issueDescription = document.createElement('div');
+        issueDescription.className = 'key-issue-description';
+        issueDescription.textContent = issue.description;
+        
+        const challengesTitle = document.createElement('div');
+        challengesTitle.style.fontWeight = 'bold';
+        challengesTitle.style.marginTop = '10px';
+        challengesTitle.textContent = 'Challenges:';
+        
+        const challengesList = document.createElement('ul');
+        challengesList.className = 'key-issue-challenges';
+        
+        issue.challenges.forEach(challenge => {
+            const challengeItem = document.createElement('li');
+            challengeItem.textContent = challenge;
+            challengesList.appendChild(challengeItem);
+        });
+        
+        const impactTitle = document.createElement('div');
+        impactTitle.style.fontWeight = 'bold';
+        impactTitle.style.marginTop = '10px';
+        impactTitle.textContent = 'Potential Impact:';
+        
+        const issueImpact = document.createElement('div');
+        issueImpact.className = 'key-issue-impact';
+        issueImpact.textContent = issue.potential_impact;
+        
+        // Add click handler to toggle selection
+        issueCard.addEventListener('click', function() {
+            this.classList.toggle('selected');
+        });
+        
+        // Append all elements
+        issueCard.appendChild(issueTitle);
+        issueCard.appendChild(issueDescription);
+        issueCard.appendChild(challengesTitle);
+        issueCard.appendChild(challengesList);
+        issueCard.appendChild(impactTitle);
+        issueCard.appendChild(issueImpact);
+        
+        issuesList.appendChild(issueCard);
+    });
+    
+    keyIssuesContainer.appendChild(issuesList);
+    keyIssuesContainer.appendChild(centerButton);
+    keyIssuesContainer.style.display = "block";
+}
+
+function generateProblemDescriptions(){
+    let result = {
+        descriptions: {},
+        challenges: {}
+    };
+
+    const selectedCards = document.querySelectorAll(".key-issue-card.selected");
+
+    selectedCards.forEach(card => {
+        const userInput = document.getElementById('userInput').value.trim();
+        const id = card.getAttribute("data-id");
+        const description = card.querySelector('.key-issue-description').textContent.trim();
+        const challenges = Array.from(card.querySelectorAll(".key-issue-challenges li")).map(challenge => challenge.textContent.trim());
+
+        result.descriptions[id] = description;
+        result.challenges[id] = challenges;
+        result["technical_topic"] = userInput;
+    })
+
+    document.querySelector('.progress-text').innerHTML = "Generating problem descriptions ... This may take a while."
+    document.getElementById('globalLoadingOverlay').style.display = 'flex';
+    
+    // Send message to Flask backend
+    fetch('https://organizedprogrammers-fastapi-kig.hf.space/create-several-probdesc', {
+        method: 'POST',
+        body: JSON.stringify(result),
+        headers: { 'Content-Type': 'application/json' }
+    })
+    .then(response => response.json())
+    .then(data => {
+        // Hide loading indicator
+        document.getElementById('globalLoadingOverlay').style.display = 'none';
+        
+        // Check if we have key issues in the response
+        if (data.problem_descriptions && data.problem_descriptions.length > 0) {
+            // Display the key issues
+            displayProblemDescriptions(data.problem_descriptions);
+        } else if (data.error) {
+            alert('Error: ' + data.error);
+        } else {
+            alert('No problem descriptions found/generated. Please try again with another or the same query.');
+        }
+    })
+    .catch(error => {
+        document.getElementById('globalLoadingOverlay').style.display = 'none';
+        console.error('Error:', error);
+        alert('There was an error communicating with the server. Please try again.');
+    });
+}
+
+function displayProblemDescriptions(probDescs) {
+    // Get or create the key issues container
+    let probDescCards = document.getElementById("probDescCards");
+    let probDescContainer = document.getElementById('probDescContainer');
+    // Clear previous content
+    probDescContainer.innerHTML = '';
+    
+    // Create header
+    const header = document.createElement('h3');
+    header.textContent = 'Problem Descriptions';
+    probDescContainer.appendChild(header);
+    
+    // Create issues list
+    const descriptionList = document.createElement('div');
+    descriptionList.className = 'prob-desc-list';
+    
+    // Add each key issue
+    probDescs.forEach((desc, index) => {
+        const descCard = document.createElement('div');
+        descCard.className = 'prob-desc-card';
+        descCard.dataset.id = index+1;
+        
+        const descTitle = document.createElement('div');
+        descTitle.className = 'prob-desc-title';
+        descTitle.textContent = `Problem Description n°${index+1}`;
+        
+        const descDescription = document.createElement('div');
+        descDescription.className = 'prob-desc-description';
+        descDescription.textContent = desc;
+        
+        // Add click handler to toggle selection
+        descCard.addEventListener('click', function() {
+            document.getElementById("userProblemDescription").textContent = desc;
+            document.getElementsByClassName("tablinks")[1].click();
+        });
+        
+        // Append all elements
+        descCard.appendChild(descTitle);
+        descCard.appendChild(descDescription);
+        
+        descriptionList.appendChild(descCard);
+    });
+    
+    probDescContainer.appendChild(descriptionList);
+    probDescCards.style.display = "block";
+}
+
+function initRibbonAccordion() {
+    const ribbon = document.querySelector('.ribbon-accordion');
+    const ribbonHeader = ribbon.querySelector('.ribbon-header');
+    
+    ribbonHeader.addEventListener('click', function() {
+        ribbon.classList.toggle('collapsed');
+    });
+}
+
+function setupRibbonButtons() {
+    // Generate Queries
+    document.getElementById('ribbonGenerateQueriesButton').addEventListener('click', function() {
+        generateSearchQueries();
+    });
+    
+    // Analyze All
+    document.getElementById('ribbonAnalyzeAllButton').addEventListener('click', function() {
+        if(hasSearchResults()) {
+            analyzeAllPapers();
+        }
+    });
+    
+    // Remove Failed
+    document.getElementById('ribbonRemoveFailedButton').addEventListener('click', function() {
+        if(hasSearchResults()) {
+            removeFailedAnalyses();
+        }
+    });
+    
+    // Extract All Insights
+    document.getElementById('ribbonExtractAllInsightsButton').addEventListener('click', function() {
+        extractAllInsights();
+    });
+    
+    // Group Insights
+    document.getElementById('ribbonGroupInsightsButton').addEventListener('click', function() {
+        groupInsightsByScore();
+    });
+    
+    // Enhance Problem
+    document.getElementById('ribbonEnhanceProblemButton').addEventListener('click', function() {
+        enhanceProblem();
+    });
+    
+    // Export to Excel
+    document.getElementById('ribbonExportExcelButton').addEventListener('click', function() {
+        if(hasSearchResults()) {
+            exportToExcel();
+        }
+    });
+}
+
+initRibbonAccordion();
+setupRibbonButtons();

static/style.css

@@ -0,0 +1,1319 @@
+:root {
+    --primary: #2563eb;
+    --primary-light: #3b82f6;
+    --primary-dark: #1d4ed8;
+    --danger: #ef4444;
+    --success: #10b981;
+    --warning: #f59e0b;
+    --gray-100: #f3f4f6;
+    --gray-200: #e5e7eb;
+    --gray-300: #d1d5db;
+    --gray-400: #9ca3af;
+    --gray-500: #6b7280;
+    --gray-600: #4b5563;
+    --gray-700: #374151;
+    --gray-800: #1f2937;
+    --gray-900: #111827;
+    --transition: all 0.2s ease;
+    --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+    --shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06);
+    --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+    --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+    line-height: 1.6;
+    color: var(--gray-800);
+    background-color: #f8fafc;
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 2rem;
+}
+
+@media (max-width: 768px) {
+    body {
+        padding: 1rem;
+    }
+}
+
+.tab {
+    overflow: hidden;
+    border: 1px solid #ccc;
+    background-color: #f1f1f1;
+}
+
+.tab button {
+    background-color: inherit;
+    float: left;
+    border: none;
+    outline: none;
+    cursor: pointer;
+    padding: 14px 16px;
+    transition: 0.3s;
+}
+
+.tab button.active {
+    background-color: #ccc;
+}
+
+.tabcontent {
+    display: none;
+}
+
+.container {
+    max-width: 1000px;
+    margin: 0 auto;
+}
+
+.header {
+    margin-bottom: 2.5rem;
+    text-align: center;
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-bottom: 1rem;
+}
+
+.logo-icon {
+    width: 40px;
+    height: 40px;
+    background-color: var(--primary);
+    border-radius: 8px;
+    color: white;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: bold;
+    font-size: 1.5rem;
+    margin-right: 10px;
+}
+
+h1 {
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--gray-900);
+    margin-bottom: 0.5rem;
+}
+
+h2 {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--gray-800);
+    margin-bottom: 1.5rem;
+}
+
+p {
+    color: var(--gray-600);
+    margin-bottom: 1rem;
+}
+
+.card {
+    background-color: white;
+    border-radius: 0.75rem;
+    box-shadow: var(--shadow);
+    padding: 2rem;
+    margin-bottom: 2rem;
+}
+
+.form-group {
+    margin-bottom: 1.5rem;
+}
+
+label {
+    display: block;
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+    color: var(--gray-700);
+}
+
+#userInput {
+    width: 100%;
+    padding: 0.75rem;
+    border: 1px solid var(--gray-300);
+    border-radius: 0.5rem;
+    min-height: 150px;
+    font-family: inherit;
+    resize: vertical;
+    transition: var(--transition);
+}
+
+#userProblemDescription {
+    width: 100%;
+    padding: 0.75rem;
+    border: 1px solid var(--gray-300);
+    border-radius: 0.5rem;
+    min-height: 150px;
+    font-family: inherit;
+    resize: vertical;
+    transition: var(--transition);
+}
+
+#userInput:focus {
+    outline: none;
+    border-color: var(--primary);
+    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.2);
+}
+
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0.625rem 1.25rem;
+    border: none;
+    border-radius: 0.5rem;
+    font-weight: 500;
+    font-size: 0.875rem;
+    cursor: pointer;
+    transition: var(--transition);
+    gap: 0.5rem;
+}
+
+.btn-primary {
+    background-color: var(--primary);
+    color: white;
+}
+
+.btn-primary:hover {
+    background-color: var(--primary-dark);
+}
+
+.btn-secondary {
+    background-color: var(--gray-100);
+    color: var(--gray-700);
+}
+
+.btn-secondary:hover {
+    background-color: var(--gray-200);
+}
+
+.btn-danger {
+    background-color: var(--danger);
+    color: white;
+}
+
+.btn-danger:hover {
+    background-color: #dc2626;
+}
+
+.btn-success {
+    background-color: var(--success);
+    color: white;
+}
+
+.btn-success:hover {
+    background-color: #059669;
+}
+
+.btn-warning {
+    background-color: var(--warning);
+    color: white;
+}
+
+.btn-warning:hover {
+    background-color: #d97706;
+}
+
+.btn-info {
+    background-color: #0dcaf0;
+    color: white;
+}
+
+.btn-info:hover {
+    background-color: #0aa2c0;
+}
+
+.btn-info.disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+}
+
+.btn-group-insights {
+    background-color: #8e44ad;
+    color: white;
+}
+
+.btn-group-insights:hover {
+    background-color: #7d3c98;
+}
+
+.query-item {
+    background-color: white;
+    border-radius: 0.75rem;
+    box-shadow: var(--shadow);
+    padding: 1.5rem;
+    margin-bottom: 1.5rem;
+}
+
+.query-container {
+    display: flex;
+    margin-bottom: 1rem;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.query-field {
+    flex-grow: 1;
+    padding: 0.625rem 0.75rem;
+    border: 1px solid var(--gray-300);
+    border-radius: 0.5rem;
+    transition: var(--transition);
+}
+
+.query-field:focus {
+    outline: none;
+    border-color: var(--primary);
+    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.2);
+}
+
+.action-button {
+    background-color: hsl(192, 83%, 66%);
+    color: white;
+    padding: 8px 12px;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    margin-right: 5px;
+}
+.delete-button {
+    background-color: #f44336;
+}
+.search-button {
+    background-color: #2196F3;
+}
+button:hover {
+    opacity: 0.9;
+}
+
+#resultsContainer {
+    margin-top: 20px;
+    display: none;
+}
+#queriesContainer {
+    margin-bottom: 15px;
+}
+#loadingIndicator {
+    display: none;
+    margin-top: 20px;
+    text-align: center;
+    color: #666;
+}
+.button-container {
+    margin-top: 15px;
+}
+.results-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 10px;
+    display: none;
+}
+.results-table th, .results-table td {
+    border: 1px solid #ddd;
+    padding: 8px;
+    text-align: left;
+}
+.results-table th {
+    background-color: #f2f2f2;
+}
+.results-table tr:nth-child(even) {
+    background-color: #f9f9f9;
+}
+.results-table tr:hover {
+    background-color: #f1f1f1;
+}
+.search-loading {
+    display: none;
+    margin: 10px 0;
+    font-style: italic;
+    color: #666;
+}
+.url-link {
+    color: #0066cc;
+    text-decoration: none;
+    word-break: break-all;
+}
+.url-link:hover {
+    text-decoration: underline;
+}
+
+.analyze-button {
+    margin-top: 5px;
+    padding: 3px 8px;
+    font-size: 0.8em;
+}
+
+.loading-spinner {
+    border: 4px solid #f3f3f3;
+    border-top: 4px solid #3498db;
+    border-radius: 50%;
+    width: 20px;
+    height: 20px;
+    animation: spin 2s linear infinite;
+    margin: 0 auto;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.score-cell, .justification-cell {
+    max-width: 150px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.score-cell {
+    font-weight: bold;
+    text-align: center;
+}
+
+.floating-buttons {
+    position: fixed;
+    bottom: 2rem;
+    right: 2rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+    z-index: 100;
+}
+
+.floating-button {
+    padding: 0.75rem;
+    border-radius: 0.5rem;
+    box-shadow: var(--shadow-md);
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    width: auto;
+    white-space: nowrap;
+}
+
+.floating-button:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-lg);
+}
+
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.5);
+    display: none;
+    justify-content: center;
+    align-items: center;
+    z-index: 1000;
+}
+
+.loading-content {
+    background-color: white;
+    padding: 2rem;
+    border-radius: 0.75rem;
+    text-align: center;
+    box-shadow: var(--shadow-lg);
+    max-width: 80%;
+}
+
+.loading-content .loading-spinner {
+    width: 40px;
+    height: 40px;
+    border-width: 4px;
+    margin-bottom: 1rem;
+}
+
+.progress-text {
+    font-size: 1rem;
+    margin-top: 0.75rem;
+    color: var(--gray-700);
+}
+
+.button-container {
+    margin-top: 1.5rem;
+    display: flex;
+    justify-content: flex-start;
+    gap: 0.75rem;
+}
+
+/* Add icons for better UX */
+.icon {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    background-size: contain;
+    background-repeat: no-repeat;
+    background-position: center;
+}
+
+.table-container {
+    margin-top: 1rem;
+    overflow-x: auto;
+    border-radius: 0.5rem;
+    border: 1px solid var(--gray-200);
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .query-container {
+        flex-direction: column;
+        align-items: stretch;
+    }
+    
+    .query-container .btn {
+        margin-top: 0.5rem;
+    }
+    
+    .floating-buttons {
+        bottom: 1rem;
+        right: 1rem;
+    }
+}
+
+.search-options {
+    margin-bottom: 20px;
+    text-align: center;
+}
+
+.checkbox-group {
+    display: flex;
+    gap: 15px;
+    margin-top: 5px;
+    justify-content: center; /* This centers the checkboxes horizontally */
+}
+
+.checkbox-item {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+}
+
+/* Adding styles for insights feature */
+.insights-container {
+    margin-top: 10px;
+    border-top: 1px dashed #ccc;
+    padding-top: 10px;
+}
+
+.insights-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 8px;
+}
+
+.insights-title {
+    font-weight: bold;
+    color: #333;
+}
+
+.insights-actions {
+    display: flex;
+    gap: 8px;
+}
+
+.insights-button {
+    font-size: 12px;
+    padding: 2px 6px;
+    background-color: #4CAF50;
+    color: white;
+    border: none;
+    border-radius: 3px;
+    cursor: pointer;
+}
+
+.insights-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-top: 8px;
+}
+
+.insight-tag {
+    background-color: #f1f1f1;
+    border: 1px solid #ddd;
+    border-radius: 15px;
+    padding: 4px 12px;
+    font-size: 12px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    user-select: none;
+}
+
+.insight-tag.selected {
+    background-color: #4CAF50;
+    color: white;
+    border-color: #4CAF50;
+}
+
+/* Styles for problem refinement functionality */
+.problem-history {
+    position: relative;
+    margin-bottom: 10px;
+}
+
+.problem-history-nav {
+    display: flex;
+    align-items: center;
+    margin-bottom: 5px;
+}
+
+.history-arrow {
+    padding: 2px 8px;
+    background-color: var(--gray-200);
+    border-radius: 3px;
+    cursor: pointer;
+    margin-right: 5px;
+    font-size: 14px;
+    color: var(--gray-700);
+}
+
+.history-arrow:hover {
+    background-color: var(--gray-300);
+}
+
+.history-arrow.disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.history-status {
+    font-size: 12px;
+    color: var(--gray-600);
+}
+
+.insight-comment-area {
+    margin-top: 10px;
+    width: 100%;
+}
+
+.insight-comment-textarea {
+    width: 100%;
+    padding: 8px;
+    border: 1px solid var(--gray-300);
+    border-radius: 4px;
+    font-size: 14px;
+    resize: vertical;
+    min-height: 60px;
+}
+
+.refined-problem-container {
+    margin-top: 20px;
+    border: 1px solid var(--gray-300);
+    border-radius: 8px;
+    overflow: hidden;
+}
+
+.refined-problem-tabs {
+    display: flex;
+    background-color: var(--gray-100);
+    border-bottom: 1px solid var(--gray-300);
+}
+
+.refined-problem-tab {
+    padding: 10px 15px;
+    cursor: pointer;
+    font-weight: 500;
+    border-right: 1px solid var(--gray-300);
+}
+
+.refined-problem-tab.active {
+    background-color: white;
+    border-bottom: 2px solid var(--primary);
+}
+
+.refined-problem-content {
+    padding: 15px;
+    background-color: white;
+}
+
+.refined-problem {
+    display: none;
+}
+
+.refined-problem.active {
+    display: block;
+}
+
+.refined-problem-title {
+    font-weight: 600;
+    margin-bottom: 10px;
+    color: var(--primary-dark);
+}
+
+.refined-problem-description {
+    line-height: 1.5;
+}
+
+.apply-problem-btn {
+    margin-top: 10px;
+    background-color: var(--primary);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 5px 10px;
+    cursor: pointer;
+    font-size: 14px;
+}
+
+.apply-problem-btn:hover {
+    background-color: var(--primary-dark);
+}
+
+.enhance-problem-button {
+    background-color: var(--warning);
+    color: white;
+}
+
+.enhance-problem-button:hover {
+    background-color: #d97706;
+}
+
+.enhance-problem-button.disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+}
+
+/* Accordion styles for collapsible search results */
+.accordion-section {
+    margin-bottom: 20px;
+    border: 1px solid var(--gray-300);
+    border-radius: 8px;
+    overflow: hidden;
+    background-color: white;
+}
+
+.accordion-header {
+    background-color: var(--gray-100);
+    padding: 10px 15px;
+    cursor: pointer;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-weight: 500;
+    border-bottom: 1px solid var(--gray-300);
+}
+
+.accordion-header:hover {
+    background-color: var(--gray-200);
+}
+
+.accordion-header .toggle-icon {
+    transition: transform 0.3s ease;
+}
+
+.accordion-header.collapsed .toggle-icon {
+    transform: rotate(-90deg);
+}
+
+.accordion-body {
+    transition: max-height 0.5s ease;
+    max-height: none; /* Changed from 2000px to none to allow full height */
+    overflow: hidden;
+}
+
+.accordion-body.collapsed {
+    max-height: 0;
+    padding: 0;
+    border-top: none;
+}
+
+/* Add padding to accordion content for better readability */
+.accordion-content {
+    padding: 15px;
+}
+
+.query-timestamp {
+    font-size: 12px;
+    color: var(--gray-500);
+    margin-left: 10px;
+}
+
+.grouped-insights-container {
+    background-color: white;
+    border-radius: 8px;
+    border: 1px solid var(--gray-300);
+    margin-top: 20px;
+    margin-bottom: 20px;
+    box-shadow: var(--shadow);
+    overflow: hidden;
+    display: none;
+}
+
+.grouped-insights-header {
+    display: flex;
+    justify-content: space-between;
+    padding: 15px;
+    background-color: var(--primary-light);
+    color: white;
+    font-weight: 600;
+    align-items: center;
+}
+
+.grouped-insights-close {
+    cursor: pointer;
+    font-size: 20px;
+    font-weight: bold;
+    margin-left: 8px;
+}
+
+.grouped-insights-content {
+    padding: 0;
+}
+
+.score-group {
+    margin-bottom: 10px;
+    border-bottom: 1px solid var(--gray-300);
+}
+
+.score-group-header {
+    padding: 10px 15px;
+    background-color: var(--gray-100);
+    font-weight: 500;
+    display: flex;
+    justify-content: space-between;
+    border-bottom: 1px solid var(--gray-200);
+}
+
+.score-group-actions {
+    display: flex;
+    gap: 8px;
+}
+
+.score-insights-list {
+    padding: 10px 15px;
+}
+
+.grouped-insight-tag {
+    background-color: #f1f1f1;
+    border: 1px solid #ddd;
+    border-radius: 15px;
+    padding: 4px 12px;
+    font-size: 12px;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    user-select: none;
+    margin: 4px;
+    display: inline-flex;
+    align-items: center;
+}
+
+.grouped-insight-tag.selected {
+    background-color: #4CAF50;
+    color: white;
+    border-color: #4CAF50;
+}
+
+.insight-source {
+    font-size: 9px;
+    background-color: var(--primary-dark);
+    color: white;
+    border-radius: 10px;
+    padding: 1px 6px;
+    margin-left: 5px;
+    display: inline-block;
+    text-decoration: none;
+}
+
+.insight-source:hover {
+    background-color: var(--primary);
+}
+
+.grouped-insights-actions {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+/* AI Select Button Styling */
+.ai-select-btn {
+    background: linear-gradient(135deg, #4b6cb7, #8e44ad);
+    color: white;
+    border: none;
+    padding: 8px 16px;
+    border-radius: 4px;
+    font-weight: 500;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+    transition: all 0.3s ease;
+}
+
+.ai-select-btn:before {
+    content: "🧠";
+    margin-right: 6px;
+    font-size: 14px;
+}
+
+.ai-select-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
+}
+
+.ai-select-btn:active {
+    transform: translateY(0);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2);
+}
+
+.ai-select-btn:disabled {
+    background: linear-gradient(135deg, #a0a0a0, #7a7a7a);
+    cursor: wait;
+    transform: none;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+@keyframes pulse {
+    0% {
+        box-shadow: 0 0 0 0 rgba(142, 68, 173, 0.7);
+    }
+    70% {
+        box-shadow: 0 0 0 10px rgba(142, 68, 173, 0);
+    }
+    100% {
+        box-shadow: 0 0 0 0 rgba(142, 68, 173, 0);
+    }
+}
+
+.pulse {
+    animation: pulse 2s infinite;
+}
+
+/* Existing styles continue below */
+.ai-select-btn {
+    background: linear-gradient(135deg, #3b82f6 0%, #8b5cf6 100%);
+    color: white;
+    font-weight: 600;
+    padding: 6px 12px;
+    border-radius: 6px;
+    border: none;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+    display: flex;
+    align-items: center;
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
+}
+
+.ai-select-btn::before {
+    content: "🧠";
+    margin-right: 6px;
+    font-size: 14px;
+}
+
+.ai-select-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
+    background: linear-gradient(135deg, #2563eb 0%, #7c3aed 100%);
+}
+
+.ai-select-btn:active {
+    transform: translateY(1px);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2);
+}
+
+/* Add pulsing effect to draw attention */
+@keyframes pulse {
+    0% {
+        box-shadow: 0 0 0 0 rgba(139, 92, 246, 0.7);
+    }
+    70% {
+        box-shadow: 0 0 0 6px rgba(139, 92, 246, 0);
+    }
+    100% {
+        box-shadow: 0 0 0 0 rgba(139, 92, 246, 0);
+    }
+}
+
+.ai-select-btn.pulse {
+    animation: pulse 2s infinite;
+}
+
+.prob-desc-container {
+    margin-top: 20px;
+    padding: 15px;
+    background-color: #f9f9f9;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.prob-desc-container {
+    margin-top: 2rem;
+    border-radius: 0.5rem;
+    overflow: hidden;
+}
+
+.prob-desc-list {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 1rem;
+    margin-top: 1rem;
+}
+
+@media (min-width: 768px) {
+    .prob-desc-list {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}
+
+.prob-desc-card {
+    background-color: white;
+    border: 1px solid var(--gray-300);
+    border-radius: 0.75rem;
+    padding: 1.5rem;
+    box-shadow: var(--shadow-sm);
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.prob-desc-card:hover {
+    border-color: var(--primary-light);
+    box-shadow: var(--shadow-md);
+}
+
+.prob-desc-card.selected {
+    border: 2px solid var(--primary);
+    background-color: rgba(37, 99, 235, 0.05);
+}
+
+.prob-desc-title {
+    font-weight: 600;
+    font-size: 1.125rem;
+    color: var(--gray-800);
+    margin-bottom: 0.5rem;
+}
+
+.prob-desc-description {
+    color: var(--gray-600);
+    margin-bottom: 1rem;
+    font-size: 0.9375rem;
+}
+
+.prob-desc-container h3 {
+    margin-top: 0;
+    color: #333;
+    font-size: 18px;
+    font-weight: 600;
+    margin-bottom: 15px;
+    border-bottom: 1px solid #ddd;
+    padding-bottom: 8px;
+}
+
+.prob-desc-list {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 15px;
+}
+
+.prob-desc-card {
+    background-color: white;
+    border: 1px solid #e0e0e0;
+    border-radius: 6px;
+    padding: 15px;
+    box-shadow: 0 2px 3px rgba(0, 0, 0, 0.05);
+    transition: all 0.3s ease;
+    cursor: pointer;
+}
+
+.prob-desc-card:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    border-color: #ccc;
+}
+
+.prob-desc-card.selected {
+    border: 2px solid #4b6cb7;
+    background-color: rgba(75, 108, 183, 0.05);
+}
+
+.prob-desc-title {
+    font-weight: 600;
+    color: #333;
+    margin-bottom: 10px;
+    font-size: 16px;
+}
+
+.prob-desc-description {
+    color: #555;
+    font-size: 14px;
+    line-height: 1.5;
+    margin-bottom: 12px;
+}
+
+.key-issues-container {
+    margin-top: 20px;
+    padding: 15px;
+    background-color: #f9f9f9;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.key-issues-container {
+    margin-top: 2rem;
+    border-radius: 0.5rem;
+    overflow: hidden;
+}
+
+.key-issues-list {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 1rem;
+    margin-top: 1rem;
+}
+
+@media (min-width: 768px) {
+    .key-issues-list {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}
+
+.key-issue-card {
+    background-color: white;
+    border: 1px solid var(--gray-300);
+    border-radius: 0.75rem;
+    padding: 1.5rem;
+    box-shadow: var(--shadow-sm);
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.key-issue-card:hover {
+    border-color: var(--primary-light);
+    box-shadow: var(--shadow-md);
+}
+
+.key-issue-card.selected {
+    border: 2px solid var(--primary);
+    background-color: rgba(37, 99, 235, 0.05);
+}
+
+.key-issue-title {
+    font-weight: 600;
+    font-size: 1.125rem;
+    color: var(--gray-800);
+    margin-bottom: 0.5rem;
+}
+
+.key-issue-description {
+    color: var(--gray-600);
+    margin-bottom: 1rem;
+    font-size: 0.9375rem;
+}
+
+.key-issue-challenges {
+    margin: 0.75rem 0;
+    padding-left: 1.5rem;
+}
+
+.key-issue-challenges li {
+    margin-bottom: 0.5rem;
+    font-size: 0.875rem;
+    color: var(--gray-700);
+}
+
+.key-issue-impact {
+    font-size: 0.875rem;
+    color: var(--gray-700);
+    font-style: italic;
+    margin-top: 0.75rem;
+}
+
+.key-issues-container h3 {
+    margin-top: 0;
+    color: #333;
+    font-size: 18px;
+    font-weight: 600;
+    margin-bottom: 15px;
+    border-bottom: 1px solid #ddd;
+    padding-bottom: 8px;
+}
+
+.key-issues-list {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 15px;
+}
+
+.key-issue-card {
+    background-color: white;
+    border: 1px solid #e0e0e0;
+    border-radius: 6px;
+    padding: 15px;
+    box-shadow: 0 2px 3px rgba(0, 0, 0, 0.05);
+    transition: all 0.3s ease;
+    cursor: pointer;
+}
+
+.key-issue-card:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    border-color: #ccc;
+}
+
+.key-issue-card.selected {
+    border: 2px solid #4b6cb7;
+    background-color: rgba(75, 108, 183, 0.05);
+}
+
+.key-issue-title {
+    font-weight: 600;
+    color: #333;
+    margin-bottom: 10px;
+    font-size: 16px;
+}
+
+.key-issue-description {
+    color: #555;
+    font-size: 14px;
+    line-height: 1.5;
+    margin-bottom: 12px;
+}
+
+.key-issue-challenges {
+    padding-left: 18px;
+    margin: 10px 0;
+}
+
+.key-issue-challenges li {
+    font-size: 13px;
+    color: #666;
+    margin-bottom: 5px;
+}
+
+.key-issue-impact {
+    font-size: 13px;
+    color: #d32f2f;
+    font-style: italic;
+}
+
+/* Accordion Ribbon Styles */
+.ribbon-accordion {
+    position: fixed;
+    bottom: 2rem;
+    right: 2rem;
+    z-index: 100;
+    width: 320px;
+    background-color: #fff;
+    border-radius: 0.75rem 0.75rem 0 0;
+    box-shadow: var(--shadow-lg);
+    overflow: hidden;
+    transition: transform 0.3s ease;
+    transform-origin: bottom center;
+}
+
+.ribbon-accordion.collapsed {
+    transform: translateY(calc(100% - 50px));
+}
+
+.ribbon-header {
+    background-color: #2563eb;
+    color: white;
+    padding: 15px;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    cursor: pointer;
+}
+
+.ribbon-title {
+    font-weight: 600;
+    font-size: 1rem;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.ribbon-icon {
+    font-size: 1.25rem;
+}
+
+.ribbon-toggle {
+    transition: transform 0.3s ease;
+}
+
+.collapsed .ribbon-toggle {
+    transform: rotate(180deg);
+}
+
+.ribbon-content {
+    padding: 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.auto-run-btn {
+    background: linear-gradient(135deg, #ff9966, #ff5e62);
+    color: white;
+    border: none;
+    border-radius: 0.5rem;
+    padding: 0.75rem;
+    font-weight: 600;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    box-shadow: var(--shadow);
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
+}
+
+.auto-run-btn::before {
+    content: "🚀";
+    font-size: 1.25rem;
+}
+
+.auto-run-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow-lg);
+    background: linear-gradient(135deg, #ff5e62, #ff9966);
+}
+
+.auto-run-btn:active {
+    transform: translateY(0);
+    box-shadow: var(--shadow);
+}
+
+/* Progress bar for auto-run */
+.progress-bar-container {
+    height: 6px;
+    background-color: #f0f0f0;
+    border-radius: 3px;
+    margin-top: 0.75rem;
+    overflow: hidden;
+    display: none;
+}
+
+.progress-bar {
+    height: 100%;
+    background: linear-gradient(90deg, #8e44ad, #3498db);
+    width: 0%;
+    transition: width 0.3s ease;
+}
+
+.progress-step {
+    font-size: 0.75rem;
+    color: var(--gray-600);
+    margin-top: 0.25rem;
+    display: none;
+}
+
+/* Hide original floating buttons when using ribbon */
+.floating-buttons {
+    display: none;
+}

templates/index.html

@@ -0,0 +1,186 @@
+<!DOCTYPE html>
+<html lang="fr">
+
+<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') }}">
+</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>
+
+        <div class="tab">
+            <button class="tablinks active" onclick="openTab(event, 'tab1')" id="defaultOpen">Problem
+                Descriptions</button>
+            <button class="tablinks" onclick="openTab(event, 'tab2')">Insights</button>
+        </div>
+
+        <div id="tab1" class="tabcontent">
+            <section class="card">
+                <form id="queryForm" onsubmit="generateQueries(event)">
+                    <div class="form-group">
+                        <label for="userInput">Technical Problem Description:</label>
+                        <div class="problem-history">
+                            <textarea id="userInput" placeholder="Describe your technical problem in detail..."
+                                required=""></textarea>
+                        </div>
+                    </div>
+
+                    <button type="submit" class="btn btn-primary">Generate Key Issues</button>
+                </form>
+
+                <div id="keyIssuesContainer" class="key-issues-container" style="display: none;">
+
+                </div>
+            </section>
+
+            <section class="card" id="probDescCards" style="display: none;">
+                <div id="probDescContainer" class="prob-desc-container">
+
+                </div>
+            </section>
+        </div>
+
+        <div id="tab2" class="tabcontent">
+
+            <section class="card">
+                <div class="form-group">
+                    <label for="userProblemDescription">Technical Problem Description:</label>
+                    <div class="problem-history">
+                        <div id="problemHistoryNav" class="problem-history-nav" style="display: none;">
+                            <div class="history-arrow history-prev disabled" onclick="navigateProblemHistory('prev')">←</div>
+                            <div class="history-arrow history-next disabled" onclick="navigateProblemHistory('next')">→</div>
+                            <div class="history-status"></div>
+                        </div>
+                        <textarea id="userProblemDescription" placeholder="Select one of the generated problem descripition..." required disabled></textarea>
+                    </div>
+                </div>
+
+                <div id="loadingIndicator">
+                    <div class="loading-spinner"></div>
+                    <p>Generating search queries... Please wait.</p>
+                </div>
+
+                <div id="refinedProblemContainer" class="refined-problem-container" style="display: none;">
+                    <div id="refinedProblemTabs" class="refined-problem-tabs"></div>
+                    <div id="refinedProblemContent" class="refined-problem-content"></div>
+                </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 class="ribbon-accordion collapsed">
+                <div class="ribbon-header">
+                    <div class="ribbon-title">
+                        <span class="ribbon-icon">🧰</span>
+                        <span>Patentability Tools</span>
+                    </div>
+                    <div class="ribbon-toggle">▲</div>
+                </div>
+                <div class="ribbon-content">
+                    <div class="progress-bar-container">
+                        <div class="progress-bar"></div>
+                    </div>
+                    <div class="progress-step">Waiting to start...</div>
+                    
+                    <button id="ribbonGenerateQueriesButton" class="btn floating-button" style="background-color: #8e44ad; color: white;" title="Generate Search Queries">
+                        Generate Search Queries
+                    </button>
+                    <button id="ribbonAnalyzeAllButton" class="btn btn-primary floating-button" title="Analyze All Unanalyzed Papers">
+                        Analyze All
+                    </button>
+                    <button id="ribbonRemoveFailedButton" class="btn btn-danger floating-button" title="Remove Papers with Failed Analyses">
+                        Remove Failed
+                    </button>
+                    <button id="ribbonExtractAllInsightsButton" class="btn btn-info floating-button" title="Extract Insights for All Analyzed Documents">
+                        Extract All Insights
+                    </button>
+                    <button id="ribbonGroupInsightsButton" class="btn btn-group-insights floating-button" title="Group All Insights by Score">
+                        Group Insights
+                    </button>
+                    <button id="ribbonEnhanceProblemButton" class="btn enhance-problem-button floating-button" title="Enhance Problem using Selected Insights">
+                        Enhance Problem
+                    </button>
+                    <button id="ribbonExportExcelButton" class="btn btn-success floating-button" title="Export All Data to Excel">
+                        Export to Excel
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <div class="floating-buttons">
+            <button id="generateQueriesButton" class="btn floating-button" style="background-color: #8e44ad; color: white;" title="Generate Search Queries">
+                Generate Search Queries
+            </button>
+            <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="extractAllInsightsButton" class="btn btn-info floating-button disabled" title="Extract Insights for All Analyzed Documents" onclick="extractAllInsights()" disabled>
+                Extract All Insights
+            </button>
+            <button id="groupInsightsByScoreButton" class="btn btn-group-insights floating-button disabled" title="Group All Insights by Score" onclick="groupInsightsByScore()" disabled>
+                Group Insights
+            </button>
+            <button id="enhanceProblemButton" class="btn enhance-problem-button floating-button disabled" title="Enhance Problem using Selected Insights" onclick="enhanceProblem()" disabled>
+                Enhance Problem
+            </button>
+            <button id="exportExcelButton" class="btn btn-success floating-button" title="Export All Data to Excel">
+                Export to Excel
+            </button>
+        </div>
+
+        <div id="globalLoadingOverlay" class="loading-overlay" style="display: none;">
+            <div class="loading-content">
+                <div class="loading-spinner"></div>
+                <div class="progress-text"></div>
+            </div>
+        </div>
+    </div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+
+</html>