Upload 4 files

agents.py

@@ -0,0 +1,43 @@
+import os
+from autogen import AssistantAgent
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+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"}]}
+
+        # Summarizer Agent - Summarizes research papers
+        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
+        )
+
+        # Advantages and Disadvantages Agent - Analyzes pros and cons
+        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,118 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+from agents import ResearchAgents
+from data_loader import DataLoader
+
+load_dotenv()
+
+# Move set_page_config() to be the first Streamlit command.
+st.set_page_config(
+    page_title="Autogen Agent",
+    page_icon="⚡",
+    initial_sidebar_state="expanded"
+)
+
+# --- Added Custom CSS for a Professional Look ---
+custom_css = """
+<style>
+    body {
+        background-color: #f5f5f5;
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .css-18e3th9, .css-1d391kg {  /* Streamlit title and header adjustments */
+        color: #333333;
+    }
+    .stButton>button {
+        background-color: #4a90e2;
+        color: #ffffff;
+        border-radius: 5px;
+        border: none;
+    }
+    .sidebar .sidebar-content {
+        background-color: #ffffff;
+    }
+    .stMarkdown, .css-1d391kg {
+        color: #555555;
+    }
+</style>
+"""
+st.markdown(custom_css, unsafe_allow_html=True)
+
+# Streamlit UI Title
+st.title("📚 Virtual Research Assistant")
+
+num_results = 5
+source_choice = st.sidebar.multiselect("Select Data Sources", options=["ArXiv", "Google Scholar"], default=["ArXiv"])
+# Sidebar with features and footer
+with st.sidebar:
+    st.divider()
+    st.markdown("<h3 style='text-align: center; color: #333;'>Key Features</h3>", unsafe_allow_html=True)
+    st.markdown("""
+    <ul style='list-style: none; padding: 0;'>
+        <li style='margin-bottom: 8px;'>🔍 <strong>Multi-Source Research Retrieval</strong></li>
+        <li style='margin-bottom: 8px;'>🤖 <strong>Integrated Chatbot Interaction</strong></li>
+        <li style='margin-bottom: 8px;'>✨ <strong>Advanced Summarization</strong></li>
+        <li style='margin-bottom: 8px;'>🔄 <strong>Automatic Query Expansion & Refinement</strong></li>
+        <li style='margin-bottom: 8px;'>📊 <strong>Visual Data Presentation</strong></li>
+    </ul>
+    """, unsafe_allow_html=True)
+    st.divider()
+    st.markdown("<p style='text-align: center;'><em>Built with Groq | Autogen</em></p>", unsafe_allow_html=True)
+
+# Retrieve the API key from environment variables
+groq_api_key = os.getenv("GROQ_API_KEY")
+
+# Check if API key is set, else stop execution
+if not groq_api_key:
+    st.error("GROQ_API_KEY is missing. Please set it in your environment variables.")
+    st.stop()
+
+# Initialize AI Agents for summarization and analysis
+agents = ResearchAgents(groq_api_key)
+
+# Initialize DataLoader for fetching research papers
+data_loader = DataLoader()
+
+# Use chat_input instead of text_input for entering the research topic.
+query = st.chat_input("Enter a research topic:")
+
+# Trigger the search automatically if a query is provided.
+if query:
+    with st.spinner("Fetching research papers..."):  # Show a loading spinner
+        
+        all_papers = []
+        # Fetch from selected sources based on sidebar choices
+        if "ArXiv" in source_choice:
+            arxiv_papers = data_loader.fetch_arxiv_papers(query, limit=num_results)
+            all_papers.extend(arxiv_papers)
+        if "Google Scholar" in source_choice:
+            google_scholar_papers = data_loader.fetch_google_scholar_papers(query)
+            all_papers.extend(google_scholar_papers)
+
+        # If no papers are found, display an error message
+        if not all_papers:
+            st.error("Failed to fetch papers. Try again!")
+        else:
+            processed_papers = []
+
+            # Process each paper: generate summary and analyze advantages/disadvantages
+            for paper in all_papers:
+                summary = agents.summarize_paper(paper['summary'])  # Generate summary
+                adv_dis = agents.analyze_advantages_disadvantages(summary)  # Analyze pros/cons
+
+                processed_papers.append({
+                    "title": paper["title"],
+                    "link": paper["link"],
+                    "summary": summary,
+                    "advantages_disadvantages": adv_dis,
+                })
+
+            # Display the processed research papers
+            st.subheader("Top Research Papers:")
+            for i, paper in enumerate(processed_papers, 1):
+                st.markdown(f"### {i}. {paper['title']}")  # Paper title
+                st.markdown(f"🔗 [Read Paper]({paper['link']})")  # Paper link
+                st.write(f"**Summary:** {paper['summary']}")  # Paper summary
+                st.write(f"{paper['advantages_disadvantages']}")  # Pros/cons analysis
+                st.markdown("---")  # Separator between papers

data_loader.py

@@ -0,0 +1,70 @@
+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, limit=None):  # Updated signature
+        """
+            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:  # If fewer than 5 papers, expand search
+            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]  # Ensure max 5 papers
+
+        if limit is not None:
+            papers = papers[:limit]
+            
+        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,9 @@
+langchain-community        # Extends LangChain with community-built tools
+langchain-core             # Core components for building LLM apps
+streamlit                  # Creates user-friendly web interfaces 
+langchain                  # Enables LLM-based workflows and integrations
+python-dotenv              # Manages environment variables securely
+langchain_groq             # Integrates GROQ features with LangChain
+transformers               # to calculate get_token_ids.
+scholarly
+autogen