Upload 6 files

Agents/multi_agent.py

@@ -0,0 +1,43 @@
+from autogen import AssistantAgent
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+
+
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+os.environ['GROQ_API_KEY'] = GROQ_API_KEY
+
+class ResearchAgents:
+    def __init__(self, api_key):
+        self.groq_api_key = api_key
+        self.llm_config = {'config_list': [{'model': 'llama-3.3-70b-versatile', 'api_key': self.groq_api_key, 'api_type': "groq"}]}
+
+        self.summarizer_agent = AssistantAgent(
+            name="summarizer_agent",
+            system_message="Summarize the retrieved research papers and present concise summaries to the user, JUST GIVE THE RELEVANT SUMMARIES OF THE RESEARCH PAPER AND NOT YOUR THOUGHT PROCESS.",
+            llm_config=self.llm_config,
+            human_input_mode="NEVER",
+            code_execution_config=False
+        )
+        self.advantages_disadvantages_agent = AssistantAgent(
+            name="advantages_disadvantages_agent",
+            system_message="Analyze the summaries of the research papers and provide a list of advantages and disadvantages for each paper in a pointwise format. JUST GIVE THE ADVANTAGES AND DISADVANTAGES, NOT YOUR THOUGHT PROCESS",
+            llm_config=self.llm_config,
+            human_input_mode="NEVER",
+            code_execution_config=False
+        )
+
+    def summarize_paper(self, paper_summary):
+        """Generates a summary of the research paper."""
+        summary_response = self.summarizer_agent.generate_reply(
+            messages=[{"role": "user", "content": f"Summarize this paper: {paper_summary}"}]
+        )
+        return summary_response.get("content", "Summarization failed!") if isinstance(summary_response, dict) else str(summary_response)
+
+    def analyze_advantages_disadvantages(self, summary):
+        """Generates advantages and disadvantages of the research paper."""
+        adv_dis_response = self.advantages_disadvantages_agent.generate_reply(
+            messages=[{"role": "user", "content": f"Provide advantages and disadvantages for this paper: {summary}"}]
+        )
+        return adv_dis_response.get("content", "Advantages and disadvantages analysis failed!")

app.py

@@ -0,0 +1,47 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+from Agents.multi_agent import ResearchAgents
+from data_loaders import DataLoader
+
+load_dotenv()
+
+st.title("📚 Virtual Research Assistant")
+
+groq_api_key = os.getenv("GROQ_API_KEY")
+if not groq_api_key:
+    st.error("GROQ_API_KEY is missing. Please set it in your environment variables.")
+    st.stop()
+
+agents = ResearchAgents(groq_api_key)
+data_loader = DataLoader()
+
+query = st.text_input("Enter a research topic:")
+
+if st.button("Search"):
+    with st.spinner("Fetching research papers..."): 
+        arxiv_papers = data_loader.fetch_arxiv_papers(query)
+        all_papers = arxiv_papers
+
+        if not all_papers:
+            st.error("Failed to fetch papers. Try again!")
+        else:
+            processed_papers = []
+
+            for paper in all_papers:
+                summary = agents.summarize_paper(paper['summary'])  
+                adv_dis = agents.analyze_advantages_disadvantages(summary)  
+
+                processed_papers.append({
+                    "title": paper["title"],
+                    "link": paper["link"],
+                    "summary": summary,
+                    "advantages_disadvantages": adv_dis,
+                })
+            st.subheader("Top Research Papers:")
+            for i, paper in enumerate(processed_papers, 1):
+                st.markdown(f"### {i}. {paper['title']}") 
+                st.markdown(f"🔗 [Read Paper]({paper['link']})") 
+                st.write(f"**Summary:** {paper['summary']}") 
+                st.write(f"{paper['advantages_disadvantages']}")  
+                st.markdown("---")  

data_loaders.py

@@ -0,0 +1,67 @@
+import requests
+import xml.etree.ElementTree as ET
+from scholarly import scholarly
+
+class DataLoader:
+    def __init__(self):
+        print("DataLoader Init")
+    def fetch_arxiv_papers(self, query):
+        """
+            Fetches top 5 research papers from ArXiv based on the user query.
+            If <5 papers are found, expands the search using related topics.
+            
+            Returns:
+                list: A list of dictionaries containing paper details (title, summary, link).
+        """
+        
+        def search_arxiv(query):
+            """Helper function to query ArXiv API."""
+            url = f"http://export.arxiv.org/api/query?search_query=all:{query}&start=0&max_results=5"
+            response = requests.get(url)
+            if response.status_code == 200:
+                root = ET.fromstring(response.text)
+                return [
+                    {
+                        "title": entry.find("{http://www.w3.org/2005/Atom}title").text,
+                        "summary": entry.find("{http://www.w3.org/2005/Atom}summary").text,
+                        "link": entry.find("{http://www.w3.org/2005/Atom}id").text
+                    }
+                    for entry in root.findall("{http://www.w3.org/2005/Atom}entry")
+                ]
+            return []
+
+        papers = search_arxiv(query)
+
+        if len(papers) < 5 and self.search_agent:
+            related_topics_response = self.search_agent.generate_reply(
+                messages=[{"role": "user", "content": f"Suggest 3 related research topics for '{query}'"}]
+            )
+            related_topics = related_topics_response.get("content", "").split("\n")
+
+            for topic in related_topics:
+                topic = topic.strip()
+                if topic and len(papers) < 5:
+                    new_papers = search_arxiv(topic)
+                    papers.extend(new_papers)
+                    papers = papers[:5]  
+
+        return papers
+
+    def fetch_google_scholar_papers(self, query):
+        """
+            Fetches top 5 research papers from Google Scholar.
+            Returns:
+                list: A list of dictionaries containing paper details (title, summary, link)
+        """
+        papers = []
+        search_results = scholarly.search_pubs(query)
+
+        for i, paper in enumerate(search_results):
+            if i >= 5:
+                break
+            papers.append({
+                "title": paper["bib"]["title"],
+                "summary": paper["bib"].get("abstract", "No summary available"),
+                "link": paper.get("pub_url", "No link available")
+            })
+        return papers

requirements.txt

@@ -0,0 +1,10 @@
+langchain-community       
+langchain-core            
+streamlit                  
+langchain                  
+python-dotenv              
+langchain_groq             
+transformers              
+scholarly
+autogen
+-e .

setup.py

@@ -0,0 +1,24 @@
+from setuptools import find_packages, setup
+from typing import List
+def get_requirements() -> List[str]:
+    try:
+        with open('requirements.txt', 'r') as file:
+            requirement_list = [
+                line.strip() for line in file.readlines()
+                if line.strip() and line.strip() != '-e .'
+            ]
+        return requirement_list
+    except FileNotFoundError:
+        print("requirements.txt file not found. Make sure it exists!")
+        return []
+
+setup(
+    name="Virtual_Research_Assistant",
+    version="0.0.1",
+    author="Parthib Karak",
+    description="A virtual research assistant that fetches and summarizes research papers.",
+    author_email="[email protected]",
+    packages=find_packages(),
+    install_requires=get_requirements(),
+    python_requires=">=3.10",  
+)