Update app.py

app.py

@@ -126,310 +126,216 @@
 # #         return [{"error": f"Error fetching research papers: {str(e)}"}]
 
 
-# """------Applied TF-IDF for better semantic search------"""
-# import feedparser
-# import urllib.parse
-# import yaml
-# from tools.final_answer import FinalAnswerTool
-# import numpy as np
-# from sklearn.feature_extraction.text import TfidfVectorizer
-# from sklearn.metrics.pairwise import cosine_similarity
-# import gradio as gr
-# from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
-# import nltk
-
-# import datetime
-# import requests
-# import pytz
-# from tools.final_answer import FinalAnswerTool
-
-# from Gradio_UI import GradioUI
-
-# nltk.download("stopwords")
-# from nltk.corpus import stopwords
-
-# @tool  # ✅ Register the function properly as a SmolAgents tool
-# def fetch_latest_arxiv_papers(keywords: list, num_results: int = 5) -> list:
-#     """Fetches and ranks arXiv papers using TF-IDF and Cosine Similarity.
-
-#     Args:
-#         keywords: List of keywords for search.
-#         num_results: Number of results to return.
-
-#     Returns:
-#         List of the most relevant papers based on TF-IDF ranking.
-#     """
-#     try:
-#         print(f"DEBUG: Searching arXiv papers with keywords: {keywords}")
-
-#         # Use a general keyword search
-#         query = "+AND+".join([f"all:{kw}" for kw in keywords])  
-#         query_encoded = urllib.parse.quote(query)
-#         url = f"http://export.arxiv.org/api/query?search_query={query_encoded}&start=0&max_results=50&sortBy=submittedDate&sortOrder=descending"
-
-#         print(f"DEBUG: Query URL - {url}")
-
-#         feed = feedparser.parse(url)
-#         papers = []
-
-#         # Extract papers from arXiv
-#         for entry in feed.entries:
-#             papers.append({
-#                 "title": entry.title,
-#                 "authors": ", ".join(author.name for author in entry.authors),
-#                 "year": entry.published[:4],
-#                 "abstract": entry.summary,
-#                 "link": entry.link
-#             })
-
-#         if not papers:
-#             return [{"error": "No results found. Try different keywords."}]
-
-#         # Prepare TF-IDF Vectorization
-#         corpus = [paper["title"] + " " + paper["abstract"] for paper in papers]
-#         vectorizer = TfidfVectorizer(stop_words=stopwords.words('english'))  # Remove stopwords
-#         tfidf_matrix = vectorizer.fit_transform(corpus)
-
-#         # Transform Query into TF-IDF Vector
-#         query_str = " ".join(keywords)
-#         query_vec = vectorizer.transform([query_str])
-
-#         #Compute Cosine Similarity
-#         similarity_scores = cosine_similarity(query_vec, tfidf_matrix).flatten()
-
-#         #Sort papers based on similarity score
-#         ranked_papers = sorted(zip(papers, similarity_scores), key=lambda x: x[1], reverse=True)
-
-#         # Return the most relevant papers
-#         return [paper[0] for paper in ranked_papers[:num_results]]
-
-#     except Exception as e:
-#         print(f"ERROR: {str(e)}")
-#         return [{"error": f"Error fetching research papers: {str(e)}"}]
-# @tool
-# def get_current_time_in_timezone(timezone: str) -> str:
-#     """A tool that fetches the current local time in a specified timezone.
-#     Args:
-#         timezone: A string representing a valid timezone (e.g., 'America/New_York').
-#     """
-#     try:
-#         # Create timezone object
-#         tz = pytz.timezone(timezone)
-#         # Get current time in that timezone
-#         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-#         return f"The current local time in {timezone} is: {local_time}"
-#     except Exception as e:
-#         return f"Error fetching time for timezone '{timezone}': {str(e)}"
-
-
-# final_answer = FinalAnswerTool()
-
-
-# # AI Model
-# model = HfApiModel(
-#     max_tokens=2096,
-#     temperature=0.5,
-#     model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-#     custom_role_conversions=None,
-# )
-
-# # Import tool from Hub
-# image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
-
-# # Load prompt templates
-# with open("prompts.yaml", 'r') as stream:
-#     prompt_templates = yaml.safe_load(stream)
-
-# # Create the AI Agent
-# agent = CodeAgent(
-#     model=model,
-#     tools=[final_answer,fetch_latest_arxiv_papers],  # Add your tools here 
-#     max_steps=6,
-#     verbosity_level=1,
-#     grammar=None,
-#     planning_interval=None,
-#     name="ScholarAgent",
-#     description="An AI agent that fetches the latest research papers from arXiv based on user-defined keywords and filters.",
-#     prompt_templates=prompt_templates
-# )
-
-# # # Define Gradio Search Function
-# # def search_papers(user_input):
-# #     keywords = [kw.strip() for kw in user_input.split(",") if kw.strip()]  # Ensure valid keywords
-# #     print(f"DEBUG: Received input keywords - {keywords}")  # Debug user input
-    
-# #     if not keywords:
-# #         print("DEBUG: No valid keywords provided.")
-# #         return "Error: Please enter at least one valid keyword."
-    
-# #     results = fetch_latest_arxiv_papers(keywords, num_results=3)  # Fetch 3 results
-# #     print(f"DEBUG: Results received - {results}")  # Debug function output
-    
-# #     if isinstance(results, list) and results and isinstance(results[0], dict):
-# #         #Format output with better readability and clarity
-# #         formatted_results = "\n\n".join([
-# #             f"---\n\n"
-# #             f"📌 **Title:**\n{paper['title']}\n\n"
-# #             f"👨‍🔬 **Authors:**\n{paper['authors']}\n\n"
-# #             f"📅 **Year:** {paper['year']}\n\n"
-# #             f"📖 **Abstract:**\n{paper['abstract'][:500]}... *(truncated for readability)*\n\n"
-# #             f"[🔗 Read Full Paper]({paper['link']})\n\n"
-# #             for paper in results
-# #         ])
-# #         return formatted_results
-    
-# #     print("DEBUG: No results found.")
-# #     return "No results found. Try different keywords."
+"""------Applied TF-IDF for better semantic search------"""
+import feedparser
+import urllib.parse
+import yaml
+from tools.final_answer import FinalAnswerTool
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import gradio as gr
+from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+import nltk
 
-# #Search Papers
-# def search_papers(user_input):
-#     keywords = [kw.strip() for kw in user_input.split(",") if kw.strip()]  # Ensure valid keywords
-#     print(f"DEBUG: Received input keywords - {keywords}")  # Debug user input
-    
-#     if not keywords:
-#         print("DEBUG: No valid keywords provided.")
-#         return "Error: Please enter at least one valid keyword."
-    
-#     results = fetch_latest_arxiv_papers(keywords, num_results=3)  # Fetch 3 results
-#     print(f"DEBUG: Results received - {results}")  # Debug function output
+import datetime
+import requests
+import pytz
+from tools.final_answer import FinalAnswerTool
 
-#     # Check if the API returned an error
-#     if isinstance(results, list) and len(results) > 0 and "error" in results[0]:
-#         return results[0]["error"]  # Return the error message directly
+from Gradio_UI import GradioUI
 
-#     # Format results only if valid papers exist
-#     if isinstance(results, list) and results and isinstance(results[0], dict):
-#         formatted_results = "\n\n".join([
-#             f"---\n\n"
-#             f"📌 **Title:** {paper['title']}\n\n"
-#             f"👨‍🔬 **Authors:** {paper['authors']}\n\n"
-#             f"📅 **Year:** {paper['year']}\n\n"
-#             f"📖 **Abstract:** {paper['abstract'][:500]}... *(truncated for readability)*\n\n"
-#             f"[🔗 Read Full Paper]({paper['link']})\n\n"
-#             for paper in results
-#         ])
-#         return formatted_results
+nltk.download("stopwords")
+from nltk.corpus import stopwords
 
-#     print("DEBUG: No results found.")
-#     return "No results found. Try different keywords."
+@tool  # ✅ Register the function properly as a SmolAgents tool
+def fetch_latest_arxiv_papers(keywords: list, num_results: int = 5) -> list:
+    """Fetches and ranks arXiv papers using TF-IDF and Cosine Similarity.
 
-# # Launch Gradio UI with CodeAgent
-# GradioUI(agent).launch()
+    Args:
+        keywords: List of keywords for search.
+        num_results: Number of results to return.
 
+    Returns:
+        List of the most relevant papers based on TF-IDF ranking.
+    """
+    try:
+        print(f"DEBUG: Searching arXiv papers with keywords: {keywords}")
 
-# # # Create Gradio UI
-# # with gr.Blocks() as demo:
-# #     gr.Markdown("# ScholarAgent")
-# #     keyword_input = gr.Textbox(label="Enter keywords (comma-separated)", placeholder="e.g., deep learning, reinforcement learning")
-# #     output_display = gr.Markdown()
-# #     search_button = gr.Button("Search")
+        # Use a general keyword search
+        query = "+AND+".join([f"all:{kw}" for kw in keywords])  
+        query_encoded = urllib.parse.quote(query)
+        url = f"http://export.arxiv.org/api/query?search_query={query_encoded}&start=0&max_results=50&sortBy=submittedDate&sortOrder=descending"
 
-# #     search_button.click(search_papers, inputs=[keyword_input], outputs=[output_display])
+        print(f"DEBUG: Query URL - {url}")
 
-# #     print("DEBUG: Gradio UI is running. Waiting for user input...")
+        feed = feedparser.parse(url)
+        papers = []
 
-# # # Launch Gradio App
-# # demo.launch()
+        # Extract papers from arXiv
+        for entry in feed.entries:
+            papers.append({
+                "title": entry.title,
+                "authors": ", ".join(author.name for author in entry.authors),
+                "year": entry.published[:4],
+                "abstract": entry.summary,
+                "link": entry.link
+            })
 
-import os
-import datetime
-import requests
-import pytz
-import yaml
-from smolagents import CodeAgent, HfApiModel, load_tool, tool
-from tools.final_answer import FinalAnswerTool
-from Gradio_UI import GradioUI
+        if not papers:
+            return [{"error": "No results found. Try different keywords."}]
 
-# Step 1: Set Hugging Face API Token
-os.environ["HUGGINGFACEHUB_API_TOKEN"] = "your_huggingface_api_token"
+        # Prepare TF-IDF Vectorization
+        corpus = [paper["title"] + " " + paper["abstract"] for paper in papers]
+        vectorizer = TfidfVectorizer(stop_words=stopwords.words('english'))  # Remove stopwords
+        tfidf_matrix = vectorizer.fit_transform(corpus)
 
-# Step 2: Define ScholarAgent's Paper Search Functionality
-@tool
-def fetch_arxiv_papers(query: str) -> str:
-    """Fetches the top 3 most recent research papers from ArXiv based on a keyword search.
+        # Transform Query into TF-IDF Vector
+        query_str = " ".join(keywords)
+        query_vec = vectorizer.transform([query_str])
 
-    Args:
-        query: A string containing keywords or a full sentence describing the research topic.
-    
-    Returns:
-        A formatted string with the top 3 recent papers, including title, authors, and ArXiv links.
-    """
-    base_url = "http://export.arxiv.org/api/query"
-    params = {
-        "search_query": query,
-        "start": 0,
-        "max_results": 3,
-        "sortBy": "submittedDate",
-        "sortOrder": "descending",
-    }
+        #Compute Cosine Similarity
+        similarity_scores = cosine_similarity(query_vec, tfidf_matrix).flatten()
 
-    try:
-        response = requests.get(base_url, params=params)
-        if response.status_code == 200:
-            papers = response.text.split("<entry>")
-            results = []
-            for paper in papers[1:4]:  # Extract top 3 papers
-                title = paper.split("<title>")[1].split("</title>")[0].strip()
-                authors = paper.split("<author><name>")[1].split("</name>")[0].strip()
-                link = paper.split("<id>")[1].split("</id>")[0].strip()
-                results.append(f"- **{title}**\n  - 📖 Authors: {authors}\n  - 🔗 [Read here]({link})\n")
-            return "\n".join(results) if results else "No relevant papers found."
-        else:
-            return "Error: Unable to retrieve papers from ArXiv."
-    except Exception as e:
-        return f"API Error: {str(e)}"
+        #Sort papers based on similarity score
+        ranked_papers = sorted(zip(papers, similarity_scores), key=lambda x: x[1], reverse=True)
 
-# Step 3: Add a Timezone Utility Tool
+        # Return the most relevant papers
+        return [paper[0] for paper in ranked_papers[:num_results]]
+
+    except Exception as e:
+        print(f"ERROR: {str(e)}")
+        return [{"error": f"Error fetching research papers: {str(e)}"}]
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """Fetches the current local time in a specified timezone.
-
+    """A tool that fetches the current local time in a specified timezone.
     Args:
         timezone: A string representing a valid timezone (e.g., 'America/New_York').
-
-    Returns:
-        A formatted string with the current time.
     """
     try:
+        # Create timezone object
         tz = pytz.timezone(timezone)
+        # Get current time in that timezone
         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
         return f"The current local time in {timezone} is: {local_time}"
     except Exception as e:
         return f"Error fetching time for timezone '{timezone}': {str(e)}"
 
-# Step 4: Define Final Answer Tool (Required)
+
 final_answer = FinalAnswerTool()
 
-# Step 5: Configure Hugging Face Model with API Token
+
+# AI Model
 model = HfApiModel(
     max_tokens=2096,
     temperature=0.5,
-    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',  # Default model
+    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
     custom_role_conversions=None,
-    
 )
 
-# Step 6: Load Additional Tools
+# Import tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
-# Step 7: Load Prompt Templates
+
+# Load prompt templates
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
-# Step 8: Define ScholarAgent (AI Agent)
+# Create the AI Agent
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, fetch_arxiv_papers, get_current_time_in_timezone],  # ScholarAgent tools
+    tools=[final_answer,fetch_latest_arxiv_papers],  # Add your tools here 
     max_steps=6,
     verbosity_level=1,
     grammar=None,
     planning_interval=None,
     name="ScholarAgent",
-    description="An AI-powered research assistant that fetches top research papers from ArXiv.",
+    description="An AI agent that fetches the latest research papers from arXiv based on user-defined keywords and filters.",
     prompt_templates=prompt_templates
 )
 
-# Step 9: Launch Gradio UI with CodeAgent
-GradioUI(agent).launch()
+
+
+# #Search Papers
+# def search_papers(user_input):
+#     keywords = [kw.strip() for kw in user_input.split(",") if kw.strip()]  # Ensure valid keywords
+#     print(f"DEBUG: Received input keywords - {keywords}")  # Debug user input
+    
+#     if not keywords:
+#         print("DEBUG: No valid keywords provided.")
+#         return "Error: Please enter at least one valid keyword."
+    
+#     results = fetch_latest_arxiv_papers(keywords, num_results=3)  # Fetch 3 results
+#     print(f"DEBUG: Results received - {results}")  # Debug function output
+
+#     # Check if the API returned an error
+#     if isinstance(results, list) and len(results) > 0 and "error" in results[0]:
+#         return results[0]["error"]  # Return the error message directly
+
+#     # Format results only if valid papers exist
+#     if isinstance(results, list) and results and isinstance(results[0], dict):
+#         formatted_results = "\n\n".join([
+#             f"---\n\n"
+#             f"📌 **Title:** {paper['title']}\n\n"
+#             f"👨‍🔬 **Authors:** {paper['authors']}\n\n"
+#             f"📅 **Year:** {paper['year']}\n\n"
+#             f"📖 **Abstract:** {paper['abstract'][:500]}... *(truncated for readability)*\n\n"
+#             f"[🔗 Read Full Paper]({paper['link']})\n\n"
+#             for paper in results
+#         ])
+#         return formatted_results
+
+#     print("DEBUG: No results found.")
+#     return "No results found. Try different keywords."
+
+def search_papers(user_input):
+    keywords = [kw.strip() for kw in user_input.split(",") if kw.strip()]  # Ensure valid keywords
+    print(f"DEBUG: Received input keywords - {keywords}")  # Debug user input
+    
+    if not keywords:
+        print("DEBUG: No valid keywords provided.")
+        return "Error: Please enter at least one valid keyword."
+    
+    # Use CodeAgent to process the request
+    response = agent.run(user_input)  # Now it actually uses CodeAgent
+    print(f"DEBUG: Agent Response - {response}")  # Debug response from the agent
+
+    # Check if response is valid
+    if isinstance(response, list) and len(response) > 0 and "error" in response[0]:
+        return response[0]["error"]  # Return the error message directly
+
+    # Format results only if valid papers exist
+    if isinstance(response, list) and response and isinstance(response[0], dict):
+        formatted_results = "\n\n".join([
+            f"---\n\n"
+            f"📌 **Title:** {paper['title']}\n\n"
+            f"👨‍🔬 **Authors:** {paper['authors']}\n\n"
+            f"📅 **Year:** {paper['year']}\n\n"
+            f"📖 **Abstract:** {paper['abstract'][:500]}... *(truncated for readability)*\n\n"
+            f"[🔗 Read Full Paper]({paper['link']})\n\n"
+            for paper in response
+        ])
+        return formatted_results
+
+    print("DEBUG: No results found.")
+    return "No results found. Try different keywords."
+
+
+# # Launch Gradio UI with CodeAgent
+# GradioUI(agent).launch()
+
+
+# Create Gradio UI
+with gr.Blocks() as demo:
+    gr.Markdown("# ScholarAgent")
+    keyword_input = gr.Textbox(label="Enter keywords (comma-separated)", placeholder="e.g., deep learning, reinforcement learning")
+    output_display = gr.Markdown()
+    search_button = gr.Button("Search")
+
+    search_button.click(search_papers, inputs=[keyword_input], outputs=[output_display])
+
+    print("DEBUG: Gradio UI is running. Waiting for user input...")
+
+# Launch Gradio App
+demo.launch()