Upload 11 files

.gitignore

@@ -0,0 +1,29 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+/dist
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+package-lock.json
+*.pyc
+*.env
+*summary.tex
+finish-sami_key.pem
+

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

agents.py

@@ -0,0 +1,132 @@
+# agents.py
+import requests
+import json
+from flask import jsonify
+import os
+key = os.getenv("API-KEY")
+api_key = key
+import re  # Import the regular expressions library
+
+def generate_research_questions_and_purpose_with_gpt(objective, num_questions):
+   
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    # Construct the prompt dynamically
+    prompt_content = f"You are a helpful assistant capable of generating research questions along with their purposes for a systematic literature review.\n"
+    prompt_content = f"Given the research objective: '{objective}', generate {num_questions} distinct research questions, each followed by its specific purpose. 'To examine', or 'To investigate'."
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant capable of generating research questions along with their purposes for a systematic literature review."},
+            {"role": "user", "content": prompt_content}
+        ],
+        "temperature": 0.7
+    }
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, data=json.dumps(data))
+    if response.status_code == 200:
+        result = response.json()
+        messages = result['choices'][0]['message']['content']
+        lines = [line for line in messages.strip().split('\n') if line]
+        
+        question_purpose_objects = []
+        for i in range(0, len(lines), 2):
+            # Using regex to dynamically remove "Research question X:" where X is any number
+            question = re.sub(r"^Research question( \d+)?: ", "", lines[i], flags=re.IGNORECASE)
+            purpose = lines[i+1] if i+1 < len(lines) else "Purpose not provided"
+            # Optionally, remove the prefix from purpose if needed
+            # purpose = purpose.replace("Purpose: ", "")
+            question_purpose_objects.append({"question": question, "purpose": purpose})
+        
+        if num_questions == 1 and question_purpose_objects:
+            
+            return {"research_questions": question_purpose_objects}
+        else:
+            return {"research_questions": question_purpose_objects}
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return []
+
+
+
+def generate_summary_conclusion(papers_info):
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    prompt_parts = ["Summarize the conclusions of the following papers:"]
+    for paper in papers_info:
+        title = paper.get("title")
+        author = paper.get("creator", "An author")
+        year = paper.get("year", "A year")
+        prompt_parts.append(f"- '{title}' by {author} ({year})")
+    prompt = " ".join(prompt_parts)
+
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt},
+        ],
+    }
+
+    response = requests.post(
+        "https://api.openai.com/v1/chat/completions",
+        headers=headers,
+        data=json.dumps(data),
+    )
+
+    if response.status_code == 200:
+        result = response.json()
+        content = result["choices"][0]["message"]["content"]
+        summary_conclusion = content.strip()
+    else:
+        return jsonify({"error": "Failed to generate a summary conclusion."}), 500
+
+    return summary_conclusion
+
+
+def generate_abstract_with_openai(prompt):
+    """Generates a summary abstract using OpenAI's GPT model based on the provided prompt."""
+    # Fetching the API key from environment variables for better security practice
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",  # Using the API key from environment variables
+        "Content-Type": "application/json"
+    }
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    }
+
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, data=json.dumps(data))
+    if response.status_code == 200:
+        result = response.json()
+        content = result['choices'][0]['message']['content']
+        return content.strip()
+    else:
+        raise Exception("Failed to generate a summary abstract from OpenAI.")
+
+
+def generate_introduction_summary_with_openai(prompt):
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    }
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, data=json.dumps(data))
+    if response.status_code == 200:
+        result = response.json()
+        content = result['choices'][0]['message']['content']
+        return content.strip()
+    else:
+        raise Exception("Failed to generate the introduction summary from OpenAI.")

agents2.py

@@ -0,0 +1,38 @@
+# agents2.py
+import requests
+import json
+import os
+key = os.getenv("API-KEY")
+api_key = key
+def extract_search_string(content):
+    possible_operators = ['AND', 'OR', 'NOT', '"']
+    for line in content.split('\n'):
+        if any(op in line for op in possible_operators):
+            return line
+    return content
+def generate_search_string_with_gpt(objective, research_questions):
+   
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    # Removed the explicit instruction for logical operators
+    combined_prompt = f"Given the research objective: '{objective}', and the following research questions: {', '.join(research_questions)}, generate two concise search string for identifying relevant literature for literature review.Do not include OR. Use AND if needed."
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": combined_prompt}
+        ],
+        "temperature": 0.7
+    }
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, data=json.dumps(data))
+    if response.status_code == 200:
+        result = response.json()
+        content = result['choices'][0]['message']['content']
+        search_string = extract_search_string(content)
+        return search_string.strip()
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return "An error occurred while generating the search string."

agents3.py

@@ -0,0 +1,105 @@
+from scholarly import scholarly
+import csv
+from scholarly import ProxyGenerator, scholarly
+import os
+import requests
+
+api_key = os.getenv('ELSEVIER_API_KEY')
+# Initialize a global variable to track if the proxy setup has been done
+proxy_setup_done = False
+
+def setup_proxy():
+    global proxy_setup_done
+    # Check if the proxy setup has already been done
+    if not proxy_setup_done:
+        # Set up a ProxyGenerator object to use free proxies
+        pg = ProxyGenerator()
+        pg.FreeProxies()
+        scholarly.use_proxy(pg)
+        
+        # Mark the setup as done
+        proxy_setup_done = True
+        print("Proxy setup completed.")
+    else:
+        print("Proxy setup was already completed earlier in this session.")
+
+# Example usage
+setup_proxy()
+
+
+
+
+def fetch_papers(search_string, min_results=8):
+    search_query = scholarly.search_pubs(search_string)
+    papers_details = []
+    for _ in range(min_results):
+        try:
+            paper = next(search_query)
+            paper_details = {
+                'title': paper['bib']['title'],
+                'author': paper['bib'].get('author'),
+                'pub_year': paper['bib'].get('pub_year'),
+                'publication_url': paper.get('pub_url', 'Not Available'),
+                'journal_name': paper['bib'].get('journal', 'Not Available'),
+                # Attempting to extract DOI, publication date, and making an educated guess on paper type
+                'doi': paper.get('doi', 'Not Available'),
+                'publication_date': paper['bib'].get('pub_year', 'Not Available'), # Simplified to publication year
+                'paper_type': 'Journal' if 'journal' in paper['bib'] else 'Conference' if 'conference' in paper['bib'] else 'Primary Study' # Simplistic categorization
+            }
+            papers_details.append(paper_details)
+        except StopIteration:
+            break  # Exit if there are no more results
+    return papers_details
+
+
+def save_papers_to_csv(papers_details, filename='papers.csv'):
+    fieldnames = ['title', 'author', 'pub_year', 'publication_url', 'journal_name', 'doi', 'publication_date', 'paper_type']
+    with open(filename, mode='w', newline='', encoding='utf-8') as file:
+        writer = csv.DictWriter(file, fieldnames=fieldnames)
+        writer.writeheader()
+        for paper in papers_details:
+            writer.writerow(paper)
+
+
+
+
+def search_elsevier(search_string, start_year, end_year, limit):
+    
+    url = "https://api.elsevier.com/content/search/scopus"
+    headers = {
+        "X-ELS-APIKey": api_key,
+        "Accept": "application/json"
+    }
+    
+    query = f"TITLE-ABS-KEY({search_string}) AND PUBYEAR = {start_year}"
+    params = {
+        "query": query,
+        "count": limit,
+    }
+    
+
+    response = requests.get(url, headers=headers, params=params)
+    if response.status_code == 200:
+        response_data = response.json()
+        papers = response_data.get('search-results', {}).get('entry', [])
+        parsed_papers = []
+        for paper in papers:
+            parsed_paper = {
+                "affiliation-country": next((affil.get("affiliation-country", "Not Available") for affil in paper.get("affiliation", [])), "Not Available"),
+                "affilname": next((affil.get("affilname", "Not Available") for affil in paper.get("affiliation", [])), "Not Available"),
+                "creator": paper.get("dc:creator", "Not Available"),
+                "identifier": paper.get("dc:identifier", "Not Available"),
+                "title": paper.get("dc:title", "Not Available"),
+                "link": next((link["@href"] for link in paper.get("link", []) if link["@ref"] == "scopus"), "Not Available"),
+                "year": paper.get("prism:coverDate", "Not Available").split("-")[0],
+                "openaccess": paper.get("openaccess", "0") == "1",
+                "publicationName": paper.get("prism:publicationName", "Not Available"),
+                "aggregationType": paper.get("prism:aggregationType", "Not Available"),
+                "volume": paper.get("prism:volume", "Not Available"),
+                "doi": paper.get("prism:doi", "Not Available")
+            }
+            parsed_papers.append(parsed_paper)
+        return parsed_papers
+    else:
+        print(f"Failed to fetch papers: {response.status_code} {response.text}")
+        return {"error": "Failed to fetch papers from Elsevier", "status_code": response.status_code, "message": response.text}

agents4.py

@@ -0,0 +1,107 @@
+# agent4.py
+import requests
+import os
+api_key = os.getenv("API-KEY")
+import re
+
+def check_paper_relevance_and_keywords(title, search_string):
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    # Adjust the prompt to ask for relevance and keywords
+    prompt = (f"Determine if the paper titled '{title}' is relevant to the topic '{search_string}'. "
+              "and in return just informed paper is relevant or paper is not relevant, to the point.")
+
+    data = {
+        "model": "gpt-3.5-turbo",
+        "messages": [
+            {"role": "system", "content": "You are a knowledgeable assistant."},
+            {"role": "user", "content": prompt}
+        ]
+    }
+
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=data)
+    if response.status_code == 200:
+        result = response.json()
+        response_text = result['choices'][0]['message']['content'].strip().lower()
+        print(response_text)
+        # Check for explicit confirmation of relevance
+        if "not relevant" in response_text:
+            return False
+        else:
+            # Assuming the model lists keywords after confirming relevance
+            # Extracting keywords from the response assuming they are listed after "key words:" phrase
+            return True
+    else:
+        print(f"Error: {response.status_code}, Detail: {response.text}")
+    
+    return (False, [])
+
+def filter_papers_with_gpt_turbo(search_string, papers):
+
+    filtered_papers = []
+
+    for paper in papers:
+        title = paper['title']
+        if check_paper_relevance_and_keywords(title, search_string):
+            filtered_papers.append(paper)
+            
+    return filtered_papers
+
+
+def is_response_relevant(response):
+    # Define a pattern that matches sentences indicating irrelevance
+    irrelevance_pattern = re.compile(r"does not appear to be directly relevant", re.IGNORECASE)
+    
+    # Define a pattern that matches sentences indicating relevance
+    relevance_pattern = re.compile(r"topics related", re.IGNORECASE)
+    
+    # Check for irrelevance
+    if irrelevance_pattern.search(response):
+        return False  # Irrelevant based on the matched pattern
+    
+    # Check for relevance
+    if relevance_pattern.search(response):
+        return True  # Relevant based on the matched pattern
+    
+    # If neither pattern is matched, you might decide based on other criteria or default assumption
+    return None  # Or False/True based on your default assumption
+
+
+def generate_response_gpt4_turbo(question, papers_info):
+    messages = [{
+        "role": "system",
+        "content": "You are a knowledgeable assistant who can answer research questions based on provided papers information."
+    }]
+
+    papers_context = "\n".join([f"- Title: '{paper['title']}', Author: {paper['creator']}, Year: {paper['year']}'." for paper in papers_info])
+    messages.append({
+        "role": "system",
+        "content": f"Research Question: {question}\n\nPapers Information:\n{papers_context}"
+    })
+    
+    messages.append({
+        "role": "user",
+        "content": "Based on the provided papers information, please answer the research question and cite relevant references for cross-verification."
+    })
+    
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    
+    data = {
+        "model": "gpt-4-turbo-preview",
+        "messages": messages,
+        "temperature": 0.7,
+        "max_tokens": 256
+    }
+    
+    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=data, timeout=800)
+    
+    if response.status_code == 200:
+        result = response.json()
+        latest_response = result['choices'][0]['message']['content']
+        return latest_response
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return "An error occurred while generating the response."

index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "init",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@ant-design/icons": "^5.3.1",
+    "antd": "^5.15.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.56",
+    "@types/react-dom": "^18.2.19",
+    "@vitejs/plugin-react": "^4.2.1",
+    "eslint": "^8.56.0",
+    "eslint-plugin-react": "^7.33.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.5",
+    "vite": "^5.1.4"
+  }
+}

requirements.txt

@@ -0,0 +1,58 @@
+alabaster==0.7.16
+anyio==4.3.0
+arrow==1.3.0
+attrs==23.2.0
+Babel==2.14.0
+beautifulsoup4==4.12.3
+bibtexparser==1.4.1
+blinker==1.7.0
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+Deprecated==1.2.14
+docutils==0.20.1
+fake-useragent==1.5.0
+Flask==3.0.2
+Flask-Cors==4.0.0
+free-proxy==1.1.1
+h11==0.14.0
+httpcore==1.0.4
+httpx==0.27.0
+idna==3.6
+imagesize==1.4.1
+itsdangerous==2.1.2
+Jinja2==3.1.3
+lxml==5.1.0
+MarkupSafe==2.1.5
+outcome==1.3.0.post0
+packaging==24.0
+Pygments==2.17.2
+pyparsing==3.1.2
+PySocks==1.7.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+requests==2.31.0
+scholarly==1.7.11
+selenium==4.18.1
+six==1.16.0
+sniffio==1.3.1
+snowballstemmer==2.2.0
+sortedcontainers==2.4.0
+soupsieve==2.5
+Sphinx==7.2.6
+sphinx-rtd-theme==2.0.0
+sphinxcontrib-applehelp==1.0.8
+sphinxcontrib-devhelp==1.0.6
+sphinxcontrib-htmlhelp==2.0.5
+sphinxcontrib-jquery==4.1
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.7
+sphinxcontrib-serializinghtml==1.1.10
+trio==0.24.0
+trio-websocket==0.11.1
+types-python-dateutil==2.8.19.20240106
+typing_extensions==4.10.0
+urllib3==2.2.1
+Werkzeug==3.0.1
+wrapt==1.16.0
+wsproto==1.2.0

server.py

@@ -0,0 +1,209 @@
+from dotenv import load_dotenv
+import os
+import tempfile
+from flask import Flask, render_template,send_file, send_from_directory, request, jsonify
+import datetime
+from agents import generate_research_questions_and_purpose_with_gpt, generate_abstract_with_openai, generate_summary_conclusion, generate_introduction_summary_with_openai
+import json
+from agents2 import generate_search_string_with_gpt
+from agents3 import fetch_papers, save_papers_to_csv, search_elsevier
+from agents4 import filter_papers_with_gpt_turbo, generate_response_gpt4_turbo
+from flask_cors import CORS
+import requests
+from datetime import datetime
+
+load_dotenv()
+# x = datetime.datetime.now()
+
+key = os.getenv("ELSEVIER_API_KEY")
+
+app = Flask(__name__, static_folder='dist')
+CORS(app)
+@app.route('/api/generate_search_string', methods=['POST'])
+def generate_search_string_route():
+    data = request.json
+    objective = data.get('objective')
+    research_questions = data.get('research_questions', [])  # Default to an empty list if not provided
+
+    if not objective or not research_questions:
+        return jsonify({"error": "Objective and research questions are required."}), 400
+
+    search_string = generate_search_string_with_gpt(objective, research_questions)
+    return jsonify({"search_string": search_string})
+@app.route('/api/generate_research_questions_and_purpose', methods=['POST'])
+
+def generate_research_questions_and_purpose():
+    print("request:", request.method)
+    data = request.json
+    objective = data.get('objective')
+    num_questions = int(data.get('num_questions', 1))  # Ensure num_questions is treated as an integer
+
+    # Validate input
+    if not objective:
+        return jsonify({"error": "Objective is required"}), 400
+    if num_questions < 1:
+        return jsonify({"error": "Number of questions must be at least 1"}), 400
+
+    questions_and_purposes = generate_research_questions_and_purpose_with_gpt(objective, num_questions)
+    print(questions_and_purposes)
+    return jsonify({"research_questions": questions_and_purposes})
+
+
+# Agent 4 
+
+@app.route('/api/filter_papers', methods=['POST'])
+def filter_papers_route():
+    data = request.json
+    search_string = data.get('search_string', '')
+    papers = data.get('papers', [])  # Expecting only titles in papers
+    
+    filtered_papers = filter_papers_with_gpt_turbo(search_string, papers)
+    return jsonify({"filtered_papers": filtered_papers})
+
+
+@app.route('/api/answer_question', methods=['POST'])
+def answer_question():
+    data = request.json
+    questions = data.get('questions')  # This should now be a list of questions
+    papers_info = data.get('papers_info', [])
+ 
+    if not questions or not papers_info:
+        return jsonify({"error": "Both questions and papers information are required."}), 400
+    
+    answers = []
+    for question in questions:
+        answer = generate_response_gpt4_turbo(question, papers_info)
+        answers.append({"question": question, "answer": answer})
+    
+    return jsonify({"answers": answers})
+
+
+@app.route('/api/generate-summary-abstract', methods=['POST'])
+def generate_summary_abstract():
+    try:
+        data = request.json
+        
+        research_questions = data.get('research_questions', 'No research questions provided.')
+        objective = data.get('objective', 'No objective provided.')
+        search_string = data.get('search_string', 'No search string provided.')
+
+        # Constructing the prompt for AI abstract generation
+        prompt = f"Based on the research questions '{research_questions}', the objective '{objective}', and the search string '{search_string}', generate a comprehensive abstract."
+
+        # Generate the abstract using OpenAI's GPT model
+        summary_abstract = generate_abstract_with_openai(prompt)
+
+        return jsonify({"summary_abstract": summary_abstract})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/generate-summary-conclusion", methods=["POST"])
+def generate_summary_conclusion_route():
+    data = request.json
+    papers_info = data.get("papers_info", [])
+    try:
+        summary_conclusion = generate_summary_conclusion(papers_info)
+        return jsonify({"summary_conclusion": summary_conclusion})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/generate-introduction-summary', methods=['POST'])
+def generate_introduction_summary():
+    try:
+        data = request.json
+        total_papers = len(data.get("all_papers", []))
+        filtered_papers_count = len(data.get("filtered_papers", []))
+        research_questions = data.get("research_questions", [])
+        objective = data.get("objective", "")
+        search_string = data.get("search_string", "")
+        answers = data.get("answers", [])
+
+        # Constructing the introduction based on the provided data
+        prompt_intro = f"This document synthesizes findings from {total_papers} papers related to \"{search_string}\". Specifically, {filtered_papers_count} papers were thoroughly examined. The primary objective is {objective}."
+        
+        prompt_questions = "\n\nResearch Questions:\n" + "\n".join([f"- {q}" for q in research_questions])
+        
+        prompt_answers = "\n\nSummary of Findings:\n" + "\n".join([f"- {ans['question']}: {ans['answer'][:250]}..." for ans in answers])  # Brief summary of answers
+        
+        prompt = prompt_intro + prompt_questions + prompt_answers + "\n\nGenerate a coherent introduction and summary based on this compilation."
+
+        # Generating the introduction summary using OpenAI's GPT model
+        introduction_summary = generate_introduction_summary_with_openai(prompt)
+
+        return jsonify({"introduction_summary": introduction_summary})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/generate-summary-all", methods=["POST"])
+def generate_summary_all_route():
+    data = request.json
+    abstract_summary = data.get("abstract_summary", "")
+    intro_summary = data.get("intro_summary", "")  # Corrected key to "intro_summary"
+    conclusion_summary = data.get("conclusion_summary", "")  # Corrected key to "conclusion_summary"
+
+    try:
+        # Assuming you have a LaTeX template named 'latex_template.tex' in the 'templates' folder
+        print("inside")
+        latex_content = render_template(
+            "latex_template.tex",
+            abstract=abstract_summary,
+            introduction=intro_summary,
+            conclusion=conclusion_summary,
+        )
+
+        # Save the LaTeX content to a file in the same directory as this script
+        current_time = datetime.now().strftime('%Y%m%d%H%M%S')
+        milliseconds = datetime.now().microsecond // 1000
+        file_path = os.path.join(os.path.dirname(__file__), f"{current_time}_{milliseconds}summary.tex")
+        print(file_path)
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write(latex_content)
+        with tempfile.NamedTemporaryFile(mode='w+', suffix='.tex', delete=False, encoding='utf-8') as temp_file:
+            temp_file.write(latex_content)
+            temp_file_path = temp_file.name
+        return send_file(temp_file_path, as_attachment=True, download_name='paper_summary.tex')
+        # return jsonify({"latex_file_path": file_path})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# # Route for serving static files (like manifest.json)
+@app.route('/')
+def index():
+    return send_from_directory(app.static_folder, 'index.html')
+@app.route('/<path:path>')
+def serve(path):
+    print("filename:", app.static_folder+ "/" + path)
+    if path != "" and os.path.exists(app.static_folder+ "/" + path):
+        return send_from_directory(app.static_folder, path)
+    else:
+        return send_from_directory(app.static_folder, 'index.html')
+    # return send_from_directory('templates/static/', filename)
+# # Route for rendering the React app
+# @app.route('/')
+# def index():
+#     print("calling")
+#     return render_template('index.html')
+
+
+
+
+
+@app.route('/api/search_papers', methods=['POST'])
+def search_papers():
+    data = request.json
+    search_string = data.get('search_string', '')
+    start_year = data.get('start_year', '')
+    end_year = data.get('end_year', '')
+    limit = data.get('limit', 4)  # Default limit to 10 papers if not specified
+    
+    if not search_string or not start_year:
+        return jsonify({'error': 'Search string and start year are required.'}), 400
+    
+    results = search_elsevier(search_string, start_year, end_year, limit)
+    return jsonify(results)
+
+# Running app
+if __name__ == '__main__':
+    app.run(debug=True)

vite.config.js

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  server:{
+    proxy: {
+      '/api': {
+        target: 'http://127.0.0.1:5000',
+           changeOrigin: true,
+           secure: false,      
+          //  rewrite: (path) => {console.log("path:", path)
+          //   return path.replace(/^\/api/, "")}
+          }
+  }
+  }
+})