Upload 9 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Agentic[[:space:]]AI/.cache/41/cache.db filter=lfs diff=lfs merge=lfs -text

Agentic AI/.cache/41/cache.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:282d19e371aba488bebb35f9272cb6fa758d0e50874892c6b559d46b205acc17
+size 151552

Agentic AI/.env

@@ -0,0 +1 @@
+GROQ_API_KEY="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"

Agentic AI/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': 'deepseek-r1-distill-qwen-32b', '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!")

Agentic AI/app.py

@@ -0,0 +1,66 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+from agents import ResearchAgents
+from data_loader import DataLoader
+
+load_dotenv()
+
+print("ok")
+
+# Streamlit UI Title
+st.title("📚 Virtual Research Assistant")
+
+# 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()
+
+# Input field for the user to enter a research topic
+query = st.text_input("Enter a research topic:")
+
+# When the user clicks "Search"
+if st.button("Search"):
+    with st.spinner("Fetching research papers..."):  # Show a loading spinner
+        
+        # Fetch research papers from ArXiv and Google Scholar
+        arxiv_papers = data_loader.fetch_arxiv_papers(query)
+        #google_scholar_papers = data_loader.fetch_google_scholar_papers(query)
+        #all_papers = arxiv_papers + google_scholar_papers  # Combine results from both sources
+        all_papers = arxiv_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

Agentic AI/data_loader.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:  # 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
+
+        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

Agentic AI/requirements.txt

@@ -0,0 +1,5 @@
+autogen
+scholarly
+python-dotenv
+streamlit
+streamlit-chat