Upload 14 files

agents/__init__.py

@@ -0,0 +1,7 @@
+# agents/__init__.py
+from .search_agent import SearchAgent
+from .qa_agent import QAAgent
+from .future_works_agent import FutureWorksAgent
+from .intent_agent import IntentAgent
+from .summarization_agent import SummarizationAgent
+__all__ = ["IntentAgent" , "SearchAgent", "QAAgent", "FutureWorksAgent" , "SummarizationAgent"]

agents/future_works_agent.py

@@ -0,0 +1,93 @@
+from langchain.vectorstores import FAISS
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+import os
+from agents import  SearchAgent
+import streamlit as st
+from config.config import model
+
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+
+class FutureWorksAgent:
+    def __init__(self):
+        self.model = model
+        self.prompt = """Analyze the research context and provide targeted insights based on the specific task type.
+        
+        Previous conversation:
+        {chat_history}
+        
+        Current research context:
+        {context}
+        
+        Task Type Detection:
+        1. Review Paper Future Work:
+           If the query involves generating future work for a review paper:
+           - Identify emerging trends and unexplored areas
+           - Suggest potential research questions
+           - Outline methodology gaps
+           - Propose innovative approaches
+        
+        2. Structured Review Summary:
+           If the query involves creating a review paper summary:
+           - Synthesize key findings across papers
+           - Identify major research themes
+           - Highlight methodological approaches
+           - Present conflicting results or debates
+           - Suggest future research opportunities
+        
+        3. Improvement Plan:
+           If the query involves generating an improvement plan:
+           - Analyze existing solutions and their limitations
+           - Identify potential enhancements
+           - Suggest novel technical contributions
+           - Propose validation approaches
+           - Outline implementation steps
+        
+        4. Research Direction Synthesis:
+           If the query involves combining multiple papers:
+           - Identify common themes and patterns
+           - Highlight complementary approaches
+           - Suggest novel combinations of methods
+           - Propose new research directions
+           - Outline potential experimental designs
+        
+        Format Guidelines:
+        - Begin with identifying the specific task type
+        - Provide structured, section-wise response
+        - Include specific examples from papers
+        - List concrete action items or suggestions
+        - Acknowledge limitations and assumptions
+        - Suggest validation approaches
+        
+        Note: Focus on providing actionable, specific suggestions rather than general statements.
+        Consider both theoretical advances and practical implementations.
+        """
+        
+        self.papers = None
+        self.search_agent_response  = ""
+
+    def solve(self, query):
+
+        # Check if search has been performed
+        if not os.path.exists("vector_db"):
+            st.warning("No papers loaded. Performing search first...")
+            search_agent = SearchAgent()
+            self.search_agent_response , self.papers = search_agent.solve(query)
+            
+        # Load vector store
+        vector_db = FAISS.load_local("vector_db", embeddings, index_name="base_and_adjacent", allow_dangerous_deserialization=True)
+        
+        # Get chat history
+        chat_history = st.session_state.get("chat_history", [])
+        chat_history_text = "".join([f"{sender}: {msg}" for sender, msg in chat_history[-5:]])
+        
+        # Get relevant chunks
+        retrieved = vector_db.as_retriever().get_relevant_documents(query)
+        context = "".join([f"{doc.page_content}\n Source: {doc.metadata['source']}" for doc in retrieved])
+        
+        # Generate response
+        full_prompt = self.prompt.format(
+            chat_history=chat_history_text,
+            context=context
+        )
+        response = self.model.generate_content(str(self.search_agent_response) + full_prompt)
+        return response.text , self.papers

agents/intent_agent.py

@@ -0,0 +1,38 @@
+from config.config import model
+
+class IntentAgent:
+    def __init__(self):
+        self.model = model
+        self.prompt = """You are an intent classifier for a research paper assistant. Given a user query, classify it into one of these categories:
+        
+        - "search": User wants to find relevant research papers on a topic
+        - "qa": User has questions about specific papers or content
+        - "future_works": User wants to:
+            * Generate future work ideas for a review paper
+            * Create a structured review paper summary
+            * Generate improvement plans from research works
+            * Combine multiple papers for new research directions
+            * Review paper generation
+            * Synthesize multiple papers
+        - "summarize": User wants to:
+            * Summarize findings from multiple papers over a given timeframe
+            * Extract key information from multiple papers and present it
+        
+        Example queries and their intents:
+        "Find papers about machine learning" -> "search"
+        "What does the paper say about the methodology?" -> "qa"
+        "What future directions can I include in my review?" -> "future_works"
+        "Can you help me write a literature review?" -> "future_works"
+        "How can I combine these papers into an improvement plan?" -> "future_works"
+        "What are the gaps in current research?" -> "future_works"
+        "Summarize findings on neural networks from these papers" -> "summarize"
+        "Extract key points from these papers" -> "summarize"
+        
+        Respond with just the intent category.
+        
+        Query: {query}"""
+
+    
+    def get_intent(self, query):
+        response = self.model.generate_content(self.prompt.format(query=query))
+        return response.text.strip().lower()

agents/qa_agent.py

@@ -0,0 +1,62 @@
+import os
+import streamlit as st 
+from agents import  SearchAgent
+from langchain.vectorstores import FAISS
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from config.config import model
+
+
+
+            
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+
+class QAAgent:
+    def __init__(self):
+        
+        self.model = model
+        self.prompt = """You are a research assistant answering questions about academic papers. Use the following context from papers and chat history to provide accurate, specific answers.
+
+        Previous conversation:
+        {chat_history}
+
+        Paper context:
+        {context}
+
+        Question: {question}
+
+        Guidelines:
+        1. Reference specific papers when making claims
+        2. Use direct quotes when relevant
+        3. Acknowledge if information isn't available in the provided context
+        4. Maintain academic tone and precision
+        """
+        self.papers = None
+        self.search_agent_response  = ""
+
+    def solve(self, query):
+        # Check if search has been performed
+        if not os.path.exists("vector_db"):
+            st.warning("No papers loaded. Performing search first...")
+            search_agent = SearchAgent()
+            self.search_agent_response , self.papers = search_agent.solve(query)
+            
+        # Load vector store
+        vector_db = FAISS.load_local("vector_db", embeddings, index_name="base_and_adjacent", allow_dangerous_deserialization=True)
+        
+        # Get chat history
+        chat_history = st.session_state.get("chat_history", [])
+        chat_history_text = "".join([f"{sender}: {msg}" for sender, msg in chat_history[-5:]])  # Last 5 messages
+        
+        # Get relevant chunks
+        retrieved = vector_db.as_retriever().get_relevant_documents(query)
+        context = "".join([f"{doc.page_content}\n Source: {doc.metadata['source']}" for doc in retrieved])
+        
+        # Generate response
+        full_prompt = self.prompt.format(
+            chat_history=chat_history_text,
+            context=context,
+            question=query
+        )
+        
+        response = self.model.generate_content(str(self.search_agent_response)  + full_prompt)
+        return response.text , self.papers

agents/search_agent.py

@@ -0,0 +1,115 @@
+
+import requests
+import os
+from langchain.document_loaders import PDFMinerLoader
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from langchain.vectorstores import FAISS
+from langchain_community.document_loaders import ArxivLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import faiss
+from langchain_community.docstore.in_memory import InMemoryDocstore
+from config.config import model
+import urllib.request as libreq
+import xml.etree.ElementTree as ET
+
+os.makedirs("papers", exist_ok=True)
+
+            
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+index = faiss.IndexFlatL2(len(embeddings.embed_query("dummy query")))
+
+text_splitter   =   RecursiveCharacterTextSplitter(
+            chunk_size=700, 
+            chunk_overlap=0,
+            length_function=len 
+        )
+
+class SearchAgent:
+    def __init__(self):
+     
+        self.model = model
+        self.p = """You are an assistant designed to extract research topics or titles from user queries. When a user asks about a specific topic, identify the central subject of their query and provide a concise, clear title or topic related to that area of research. If the query refers to a particular research paper, include the paper's title, author(s), and publication year.
+                    Here are the instructions you should follow:
+                    General Topics: If the query mentions a general topic without referring to a specific paper, identify the primary research area or topic. For example, if the query is "What are the advancements in text-to-SQL models?" your response should be simply "Text-to-SQL Models."
+                    Specific Research Papers: If the query mentions a particular paper, extract the title, author(s), and year of the paper. For example, if the query is "What did the paper by John Doe in 2022 say about AI in healthcare?" your response should be "AI in Healthcare (John Doe, 2022)."
+                    Abstract or General Query: If the query is an abstract or general inquiry into a topic, return the main theme or title of that topic. For instance, "What are the advancements in natural language processing?" would result in "Natural Language Processing Advancements."
+                    Examples:
+                    User Query: "Tell me about recent advancements in text-to-SQL models." Response: "Text-to-SQL Models."
+                    User Query: "What does the paper 'Deep Learning for Text-to-SQL by Jane Smith, 2021' cover?" Response: "'Deep Learning for Text-to-SQL' (Jane Smith, 2021)."
+                    User Query: "Can you summarize the paper by Alice Brown on quantum computing from 2020?" Response: "'Quantum Computing: A New Frontier' (Alice Brown, 2020)." """
+
+    def solve(self, task):
+        print(f"Searching for information on: {task}")
+        response = model.generate_content(self.p+task)
+        query =  response.text.strip()
+
+        r=query.split(" ")
+        query_="%20".join(r)
+        
+        with libreq.urlopen(f'''http://export.arxiv.org/api/query?search_query=all:{query_}&sortBy=relevance&sortOrder=descending&start=0&max_results=5''') as url:
+            r = url.read()
+            
+            
+
+        xml_content = r
+        root = ET.fromstring(xml_content)
+        ns = {'atom': 'http://www.w3.org/2005/Atom'}
+        ids = [entry.find('atom:id', ns).text for entry in root.findall('atom:entry', ns)]
+        pdf_urls = [url.replace("abs", "pdf") for url in ids]
+
+        # Create list to store paper information
+        papers = []
+        
+        # Extract information for each paper
+        for entry in root.findall('atom:entry', ns):
+            paper_info = {}
+            
+            # Get paper title
+            title = entry.find('atom:title', ns).text
+            paper_info['title'] = title
+            
+            # Get paper ID and create PDF link
+            paper_id = entry.find('atom:id', ns).text
+            pdf_link = paper_id.replace("abs", "pdf")
+            paper_info['link'] = pdf_link
+            
+            # Get publication year from published date
+            published = entry.find('atom:published', ns).text
+            year = published[:4]  # Extract year from date string
+            paper_info['year'] = year
+            
+            papers.append(paper_info)
+
+        all_papers = []
+
+        def download_pdf_paper_from_url(url):
+            paper_number = os.path.basename(url).strip(".pdf")
+            res = requests.get(url)
+            pdf_path = f"papers/{paper_number}.pdf"
+            with open(pdf_path, 'wb') as f:
+                f.write(res.content)
+            return paper_number
+            
+        for paper in papers:
+            paper_number = download_pdf_paper_from_url(paper['link'])
+            all_papers.append(paper_number)
+            # Add paper number to paper info
+            paper['paper_number'] = paper_number
+
+        vector_db = FAISS(
+            embedding_function=embeddings,
+            index=index,
+            docstore=InMemoryDocstore(),
+            index_to_docstore_id={}
+        )
+        
+        for pdf_number in all_papers:
+            docs = ArxivLoader(query=pdf_number)
+            docs = PDFMinerLoader(f"papers/{pdf_number}.pdf").load()
+            docs = text_splitter.split_documents(docs)
+            vector_db.add_documents(docs)
+        
+        vector_db.save_local("vector_db", index_name="base_and_adjacent")
+        
+        return ["Here are the papers on" + query] , papers # Return the list of paper dictionaries
+

agents/summarization_agent.py

@@ -0,0 +1,109 @@
+from langchain.vectorstores import FAISS
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+import os
+import streamlit as st
+from agents import SearchAgent
+from config.config import model
+
+
+            
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+
+class SummarizationAgent:
+    def __init__(self):
+        self.model = model
+        self.prompt = """You are a research assistant tasked with synthesizing findings from multiple academic papers over time. Your goal is to create a comprehensive summary that highlights key trends, thematic developments, and methodological evolution within a given timeframe.
+
+                        Given the following context, analyze the papers to produce a structured summary:
+
+                        Previous conversation:
+                        {chat_history}
+
+                        Papers context:
+                        {context}
+
+                        Guidelines for timeline-based summarization:
+
+                        Key Findings and Trends Over Time
+
+                        Identify major discoveries and conclusions, highlighting how they have developed chronologically.
+                        Note emerging trends, consensus, and any evolving contradictions across papers, especially in response to new technologies or shifts in the field.
+                        Present statistical evidence and experimental results in relation to time, pointing out any measurable improvements or declines over the years.
+                        Methodological Evolution
+
+                        Compare and contrast research approaches across different time periods, emphasizing changes or advances in data collection, analysis techniques, or tools.
+                        Identify and describe innovative methodological contributions and how these may have impacted research outcomes over time.
+                        Theoretical Progression
+
+                        Outline the theoretical foundations and highlight their chronological development.
+                        Connect findings to existing theories, noting how interpretations or theoretical perspectives have evolved.
+                        Identify theoretical advances, challenges, or shifts and their relationship to the timeline.
+                        Practical Applications and Temporal Shifts
+
+                        Discuss real-world applications over time, noting how findings have influenced industry practices or technology adoption.
+                        Highlight evolving practical use cases and how implementation considerations have changed with advances in research.
+                        Research Gaps and Future Directions
+
+                        Identify limitations in studies across time periods, noting any improvement or persistent gaps.
+                        Point out unexplored areas and suggest specific future research directions informed by chronological developments in the field.
+                        Formatting and Style:
+
+                        Organize the summary with clear sections that reflect the temporal progression.
+                        Maintain an academic tone, using specific examples, dates, and quotes where relevant.
+                        Clearly identify and label sections to enhance readability, and acknowledge any limitations in the available context.
+        """
+        
+        self.papers = None
+        self.search_agent_response = ""
+
+    def solve(self, query):
+        # Check if search has been performed
+        if not os.path.exists("vector_db"):
+            st.warning("No papers loaded. Performing search first...")
+            search_agent = SearchAgent()
+            self.search_agent_response, self.papers = search_agent.solve(query)
+            
+        # Load vector store
+        vector_db = FAISS.load_local("vector_db", embeddings, index_name="base_and_adjacent", allow_dangerous_deserialization=True)
+        
+        # Get chat history
+        chat_history = st.session_state.get("chat_history", [])
+        chat_history_text = "\n".join([f"{sender}: {msg}" for sender, msg in chat_history[-5:]])
+        
+        # Get relevant chunks from all papers
+        retrieved = vector_db.as_retriever(
+            search_kwargs={"k": 10}  # Increase number of chunks to get broader context
+        ).get_relevant_documents(query)
+        
+        # Organize context by paper
+        context = self._organize_context(retrieved)
+        
+        # Generate summary
+        full_prompt = self.prompt.format(
+            chat_history=chat_history_text,
+            context=context
+        )
+        
+        response = self.model.generate_content(str(self.search_agent_response) + full_prompt)
+        return response.text, self.papers
+
+    def _organize_context(self, documents):
+        """
+        Organizes retrieved chunks by paper and creates a structured context.
+        """
+        # Group chunks by paper
+        paper_chunks = {}
+        for doc in documents:
+            paper_id = doc.metadata.get('source', 'unknown')
+            if paper_id not in paper_chunks:
+                paper_chunks[paper_id] = []
+            paper_chunks[paper_id].append(doc.page_content)
+
+        # Create structured context
+        organized_context = []
+        for paper_id, chunks in paper_chunks.items():
+            paper_context = f"\nPaper: {paper_id}\n"
+            paper_context += "\n".join(chunks)
+            organized_context.append(paper_context)
+
+        return "\n\n".join(organized_context)

app.py

@@ -1,277 +1,277 @@
-import streamlit as st
-import os
-import sys
-from typing import Tuple, List, Dict, Optional
-from router import Router
-
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-class AcademicResearchAssistant:
-    def __init__(self):
-      
-        self.router = Router()
-        self.setup_streamlit_config()
-        self.initialize_session_state()
-
-    def setup_streamlit_config(self):
-    
-        st.set_page_config(
-            page_title="Academic Research Assistant",
-            page_icon="📚",
-            layout="wide",
-            initial_sidebar_state="expanded",
-            menu_items={
-                'Get Help': 'https://github.com/yourusername/academic-research-assistant',
-                'Report a bug': "https://github.com/yourusername/academic-research-assistant/issues",
-                'About': "# Academic Research Assistant v1.0\nYour intelligent research companion."
-            }
-        )
-
-        # Custom CSS to enhance the UI
-        st.markdown("""
-            <style>
-            .stApp {
-                background: linear-gradient(to bottom right, #f5f7fa, #eef2f7);
-            }
-            .stButton>button {
-                background-color: #1f4287;
-                color: white;
-                border-radius: 5px;
-                padding: 0.5rem 1rem;
-            }
-            .stProgress .st-bo {
-                background-color: #1f4287;
-            }
-            .chat-message {
-                padding: 10px;
-                border-radius: 5px;
-                margin: 5px 0;
-                animation: fadeIn 0.5s ease-in;
-            }
-            .user-message {
-                background-color: #e6f3ff;
-            }
-            .bot-message {
-                background-color: #f0f2f6;
-            }
-            @keyframes fadeIn {
-                from {opacity: 0;}
-                to {opacity: 1;}
-            }
-            .paper-card {
-                background-color: white;
-                padding: 1.5rem;
-                border-radius: 10px;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-                margin-bottom: 1rem;
-            }
-            .paper-title {
-                color: #1f4287;
-                font-size: 1.1rem;
-                font-weight: bold;
-                margin-bottom: 0.5rem;
-            }
-            .paper-metadata {
-                font-size: 0.9rem;
-                color: #666;
-                margin-bottom: 0.5rem;
-            }
-            .paper-abstract {
-                font-size: 0.95rem;
-                line-height: 1.5;
-                margin-top: 1rem;
-                padding-left: 1rem;
-                border-left: 3px solid #1f4287;
-            }
-            .download-button {
-                background-color: #4CAF50;
-                color: white;
-                padding: 0.5rem 1rem;
-                border-radius: 5px;
-                text-decoration: none;
-                display: inline-block;
-                margin-top: 1rem;
-            }
-            .metric-card {
-                background-color: white;
-                padding: 1rem;
-                border-radius: 8px;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-                text-align: center;
-            }
-            </style>
-        """, unsafe_allow_html=True)
-
-    def initialize_session_state(self):
-       
-        if "chat_history" not in st.session_state:
-            st.session_state.chat_history = []
-        if "fetched_papers" not in st.session_state:
-            st.session_state.fetched_papers = []
-        if "search_count" not in st.session_state:
-            st.session_state.search_count = 0
-        if "total_searches" not in st.session_state:
-            st.session_state.total_searches = 0
-
-    def display_welcome_message(self):
-
-        st.title("📚 Academic Research Paper Assistant")
-        
-        # Create three columns for metrics
-        col1, col2, col3, col4 = st.columns([2, 1, 1, 1])
-        
-        with col1:
-            st.markdown("""
-            Welcome to your intelligent research companion! This tool helps you:
-            - 🔍 Find relevant academic papers
-            - 📊 Analyze research trends
-            - 📖 Access paper summaries
-            - 📥 Download full papers
-            """)
-        
-        # Display metrics in cards
-        with col3:
-            st.markdown("""
-                <div class="metric-card">
-                    <h3>Papers Found</h3>
-                    <h2>{}</h2>
-                </div>
-            """.format(len(st.session_state.fetched_papers)), unsafe_allow_html=True)
-            
-        with col4:
-            st.markdown("""
-                <div class="metric-card">
-                    <h3>Total Searches</h3>
-                    <h2>{}</h2>
-                </div>
-            """.format(st.session_state.total_searches), unsafe_allow_html=True)
-      
-        
-
-    def create_chat_interface(self) -> Tuple[str, bool]:
-       
-        with st.container():
-            st.write("### 💬 Research Query Interface")
-            
-            # Create columns for better layout
-            col1, col2 = st.columns([4, 1])
-            
-            with col1:
-                user_input = st.text_input(
-                    "Enter your research query (e.g., 'Recent advances in quantum computing')",
-                    key="user_input",
-                    placeholder="Type your research question here...",
-                    max_chars=500
-                )
-            
-            col3, col4, col5 = st.columns([2, 1, 1])
-            with col3:
-                send_button = st.button("🔍 Search ", use_container_width=True)
-            with col4:
-                clear_button = st.button("🗑️ Clear History", use_container_width=True)
-            
-            if clear_button:
-                st.session_state.chat_history = []
-                st.session_state.fetched_papers = []
-                st.session_state.search_count = 0
-                st.session_state.total_searches = 0
-                st.rerun()
-                
-        return user_input, send_button
-
-    def process_user_input(self, user_input: str):
-        
-        with st.spinner('🔍 Working on response...'):
-            # Update search metrics
-            st.session_state.search_count = len(st.session_state.fetched_papers)
-            st.session_state.total_searches += 1
-            
-            try:
-                # Get response from router
-                response, papers = self.router.route_query(user_input)
-                
-                # Update papers in session state
-                if papers:
-                    unique_papers = {paper['paper_number']: paper for paper in papers}
-                    st.session_state.fetched_papers = list(unique_papers.values())
-                
-                # Add bot response and use message to chat history
-                if response:
-                    st.session_state.chat_history.append(("Bot", response))
-                    st.session_state.chat_history.append(("User", user_input))
-                else:
-                    st.session_state.chat_history.append(
-                        ("Bot", "I couldn't find relevant papers for your query. Please try rephrasing or use more specific terms.")
-                    )
-            except Exception as e:
-                st.session_state.chat_history.append(
-                    ("Bot", f"An error occurred while processing your request: {str(e)}")
-                )
-                st.error("There was an error processing your request. Please try again.")
-
-    def display_chat_history(self):
-        """Display the chat history with user and bot messages"""
-        for sender, message in reversed(st.session_state.chat_history):
-            if sender == "User":
-                st.markdown(
-                    "<div class='chat-message user-message'>"
-                    f"<strong>👤 You:</strong> {message}"
-                    "</div>",
-                    unsafe_allow_html=True
-                )
-            else:
-                st.markdown(
-                    "<div class='chat-message bot-message'>"
-                    f"<strong>🤖 Assistant:</strong> {message[0]}"
-                    "</div>",
-                    unsafe_allow_html=True
-                )
-
-    def display_papers(self):
-        """Display the list of fetched papers with download links"""
-        st.write("### 📄 Retrieved Research Papers")
-        if st.session_state.fetched_papers:
-            for paper in st.session_state.fetched_papers:
-                with st.expander(f"📑 {paper.get('title', 'Untitled Paper')}"):
-                    st.markdown(
-                        "<div class='paper-card'>"
-                        f"<div class='paper-title'>{paper.get('title', '').replace('\n', ' ').strip()}</div>"
-                        f"<div class='paper-metadata'>Year: {paper.get('year', 'N/A')} | Paper ID: {paper.get('paper_number', 'N/A')}</div>"
-                        f"""{'<div class="paper-abstract">' + paper.get('abstract', '') + '</div>' if paper.get('abstract') else ''}"""
-                        "</div>",
-                        unsafe_allow_html=True
-                    )
-                    
-                    download_link = paper.get('link')
-                    if download_link:
-                        st.markdown(f"[📥 Download PDF]({download_link})")
-                    else:
-                        st.warning("⚠️ No download link available")
-        else:
-            st.info("🔍 No papers fetched yet. Start by entering a research query above!")
-
-    def run(self):
-        """Main method to run the application"""
-        self.display_welcome_message()
-        
-
-        user_input, send_button = self.create_chat_interface()
-
-        st.markdown("### 💬 Chat History")
-        self.display_chat_history()
-        
-
-        if user_input and send_button:
-            self.process_user_input(user_input)
-            st.rerun()
-        
-        st.markdown("---")
-        self.display_papers()
-
-def main():
-
-    app = AcademicResearchAssistant()
-    app.run()
-
-if __name__ == "__main__":
+import streamlit as st
+import os
+import sys
+from typing import Tuple, List, Dict, Optional
+from router import Router
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+class AcademicResearchAssistant:
+    def __init__(self):
+      
+        self.router = Router()
+        self.setup_streamlit_config()
+        self.initialize_session_state()
+
+    def setup_streamlit_config(self):
+    
+        st.set_page_config(
+            page_title="Academic Research Assistant",
+            page_icon="📚",
+            layout="wide",
+            initial_sidebar_state="expanded",
+            menu_items={
+                'Get Help': 'https://github.com/yourusername/academic-research-assistant',
+                'Report a bug': "https://github.com/yourusername/academic-research-assistant/issues",
+                'About': "# Academic Research Assistant v1.0\nYour intelligent research companion."
+            }
+        )
+
+        # Custom CSS to enhance the UI
+        st.markdown("""
+            <style>
+            .stApp {
+                background: linear-gradient(to bottom right, #f5f7fa, #eef2f7);
+            }
+            .stButton>button {
+                background-color: #1f4287;
+                color: white;
+                border-radius: 5px;
+                padding: 0.5rem 1rem;
+            }
+            .stProgress .st-bo {
+                background-color: #1f4287;
+            }
+            .chat-message {
+                padding: 10px;
+                border-radius: 5px;
+                margin: 5px 0;
+                animation: fadeIn 0.5s ease-in;
+            }
+            .user-message {
+                background-color: #e6f3ff;
+            }
+            .bot-message {
+                background-color: #f0f2f6;
+            }
+            @keyframes fadeIn {
+                from {opacity: 0;}
+                to {opacity: 1;}
+            }
+            .paper-card {
+                background-color: white;
+                padding: 1.5rem;
+                border-radius: 10px;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                margin-bottom: 1rem;
+            }
+            .paper-title {
+                color: #1f4287;
+                font-size: 1.1rem;
+                font-weight: bold;
+                margin-bottom: 0.5rem;
+            }
+            .paper-metadata {
+                font-size: 0.9rem;
+                color: #666;
+                margin-bottom: 0.5rem;
+            }
+            .paper-abstract {
+                font-size: 0.95rem;
+                line-height: 1.5;
+                margin-top: 1rem;
+                padding-left: 1rem;
+                border-left: 3px solid #1f4287;
+            }
+            .download-button {
+                background-color: #4CAF50;
+                color: white;
+                padding: 0.5rem 1rem;
+                border-radius: 5px;
+                text-decoration: none;
+                display: inline-block;
+                margin-top: 1rem;
+            }
+            .metric-card {
+                background-color: white;
+                padding: 1rem;
+                border-radius: 8px;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+                text-align: center;
+            }
+            </style>
+        """, unsafe_allow_html=True)
+
+    def initialize_session_state(self):
+       
+        if "chat_history" not in st.session_state:
+            st.session_state.chat_history = []
+        if "fetched_papers" not in st.session_state:
+            st.session_state.fetched_papers = []
+        if "search_count" not in st.session_state:
+            st.session_state.search_count = 0
+        if "total_searches" not in st.session_state:
+            st.session_state.total_searches = 0
+
+    def display_welcome_message(self):
+
+        st.title("📚 Academic Research Paper Assistant")
+        
+        # Create three columns for metrics
+        col1, col2, col3, col4 = st.columns([2, 1, 1, 1])
+        
+        with col1:
+            st.markdown("""
+            Welcome to your intelligent research companion! This tool helps you:
+            - 🔍 Find relevant academic papers
+            - 📊 Analyze research trends
+            - 📖 Access paper summaries
+            - 📥 Download full papers
+            """)
+        
+        # Display metrics in cards
+        with col3:
+            st.markdown("""
+                <div class="metric-card">
+                    <h3>Papers Found</h3>
+                    <h2>{}</h2>
+                </div>
+            """.format(len(st.session_state.fetched_papers)), unsafe_allow_html=True)
+            
+        with col4:
+            st.markdown("""
+                <div class="metric-card">
+                    <h3>Total Searches</h3>
+                    <h2>{}</h2>
+                </div>
+            """.format(st.session_state.total_searches), unsafe_allow_html=True)
+      
+        
+
+    def create_chat_interface(self) -> Tuple[str, bool]:
+       
+        with st.container():
+            st.write("### 💬 Research Query Interface")
+            
+            # Create columns for better layout
+            col1, col2 = st.columns([4, 1])
+            
+            with col1:
+                user_input = st.text_input(
+                    "Enter your research query (e.g., 'Recent advances in quantum computing')",
+                    key="user_input",
+                    placeholder="Type your research question here...",
+                    max_chars=500
+                )
+            
+            col3, col4, col5 = st.columns([2, 1, 1])
+            with col3:
+                send_button = st.button("🔍 Search ", use_container_width=True)
+            with col4:
+                clear_button = st.button("🗑️ Clear History", use_container_width=True)
+            
+            if clear_button:
+                st.session_state.chat_history = []
+                st.session_state.fetched_papers = []
+                st.session_state.search_count = 0
+                st.session_state.total_searches = 0
+                st.rerun()
+                
+        return user_input, send_button
+
+    def process_user_input(self, user_input: str):
+        
+        with st.spinner('🔍 Working on response...'):
+            # Update search metrics
+            st.session_state.search_count = len(st.session_state.fetched_papers)
+            st.session_state.total_searches += 1
+            
+            try:
+                # Get response from router
+                response, papers = self.router.route_query(user_input)
+                
+                # Update papers in session state
+                if papers:
+                    unique_papers = {paper['paper_number']: paper for paper in papers}
+                    st.session_state.fetched_papers = list(unique_papers.values())
+                
+                # Add bot response and use message to chat history
+                if response:
+                    st.session_state.chat_history.append(("Bot", response))
+                    st.session_state.chat_history.append(("User", user_input))
+                else:
+                    st.session_state.chat_history.append(
+                        ("Bot", "I couldn't find relevant papers for your query. Please try rephrasing or use more specific terms.")
+                    )
+            except Exception as e:
+                st.session_state.chat_history.append(
+                    ("Bot", f"An error occurred while processing your request: {str(e)}")
+                )
+                st.error("There was an error processing your request. Please try again.")
+
+    def display_chat_history(self):
+        """Display the chat history with user and bot messages"""
+        for sender, message in reversed(st.session_state.chat_history):
+            if sender == "User":
+                st.markdown(
+                    "<div class='chat-message user-message'>"
+                    f"<strong>👤 You:</strong> {message}"
+                    "</div>",
+                    unsafe_allow_html=True
+                )
+            else:
+                st.markdown(
+                    "<div class='chat-message bot-message'>"
+                    f"<strong>🤖 Assistant:</strong> {message[0]}"
+                    "</div>",
+                    unsafe_allow_html=True
+                )
+
+    def display_papers(self):
+        """Display the list of fetched papers with download links"""
+        st.write("### 📄 Retrieved Research Papers")
+        if st.session_state.fetched_papers:
+            for paper in st.session_state.fetched_papers:
+                with st.expander(f"📑 {paper.get('title', 'Untitled Paper')}"):
+                    st.markdown(
+                        "<div class='paper-card'>"
+                        f"<div class='paper-title'>{paper.get('title', '').replace('\n', ' ').strip()}</div>"
+                        f"<div class='paper-metadata'>Year: {paper.get('year', 'N/A')} | Paper ID: {paper.get('paper_number', 'N/A')}</div>"
+                        f"""{'<div class="paper-abstract">' + paper.get('abstract', '') + '</div>' if paper.get('abstract') else ''}"""
+                        "</div>",
+                        unsafe_allow_html=True
+                    )
+                    
+                    download_link = paper.get('link')
+                    if download_link:
+                        st.markdown(f"[📥 Download PDF]({download_link})")
+                    else:
+                        st.warning("⚠️ No download link available")
+        else:
+            st.info("🔍 No papers fetched yet. Start by entering a research query above!")
+
+    def run(self):
+        """Main method to run the application"""
+        self.display_welcome_message()
+        
+
+        user_input, send_button = self.create_chat_interface()
+
+        st.markdown("### 💬 Chat History")
+        self.display_chat_history()
+        
+
+        if user_input and send_button:
+            self.process_user_input(user_input)
+            st.rerun()
+        
+        st.markdown("---")
+        self.display_papers()
+
+def main():
+
+    app = AcademicResearchAssistant()
+    app.run()
+
+if __name__ == "__main__":
     main()

config/config.py

@@ -0,0 +1,13 @@
+import google.generativeai as genai
+import os
+GEMINI_API_KEY = "AIzaSyD6OXS89hHRqzGCY1klK9A8qNlG0sJEvAU"
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+if "GOOGLE_API_KEY" not in os.environ:
+    os.environ["GOOGLE_API_KEY"] = GEMINI_API_KEY
+
+model = genai.GenerativeModel(model_name="gemini-1.5-flash")
+
+
+

router.py

@@ -0,0 +1,24 @@
+from agents import IntentAgent, SearchAgent, QAAgent, FutureWorksAgent , SummarizationAgent
+import streamlit as st
+class Router:
+    def __init__(self):
+        self.intent_agent = IntentAgent()
+        self.agents = {
+            "search": SearchAgent(),
+            "qa": QAAgent(),
+            "future_works": FutureWorksAgent(),
+            "summarize": SummarizationAgent()
+        }
+
+    def route_query(self, query):
+        
+        intent = self.intent_agent.get_intent(query)
+        agent = self.agents.get(intent)
+        st.write(f"Using {intent} agent...")
+        if agent:
+            if intent == "search":
+                ans , d = agent.solve(query)
+                return ans , d
+            return agent.solve(query) , None
+        else:
+            return "Sorry, I couldn't understand your query. Please give valid question" , None