Update app.py

app.py

@@ -1,10 +1,10 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import base64
-import nest_asyncio
-from llama_index.core import VectorStoreIndex
+import time
+import pandas as pd
+from dotenv import load_dotenv
 from llama_index.readers.web import SimpleWebPageReader
 from llama_index.llms.gemini import Gemini
 from llama_index.tools.wikipedia import WikipediaToolSpec
@@ -13,14 +13,6 @@ from llama_index.core.tools import FunctionTool
 from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
 from llama_index.tools.arxiv import ArxivToolSpec
 from llama_index.core.agent.workflow import AgentWorkflow
-from llama_index.vector_stores.chroma import ChromaVectorStore
-from llama_index.core.schema import Document
-import pandas as pd
-import asyncio
-import chromadb
-from dotenv import load_dotenv
-
-nest_asyncio.apply()
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -29,8 +21,11 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         # Initialize LLM
+        load_dotenv()
         self.llm = Gemini(
-            model_name="models/gemini-2.0-flash"
+            model_name="models/gemini-2.0-flash",
+            temperature=0.1,
+            max_tokens=4096
         )
         
         # Define tools
@@ -101,111 +96,39 @@ class BasicAgent:
             description="Search Wikipedia and convert the results into a high-quality response."
         )
         
-        def search_arxiv(query: str, max_results: int = 3) -> dict:
-            """Search scientific articles on arXiv."""
-            try:
-                tool_spec = ArxivToolSpec()
-                papers = tool_spec.query_papers(query, max_results=max_results)
-                
-                results = []
-                for paper in papers:
-                    results.append(f"Title: {paper.title}\nAuthors: {', '.join(paper.authors)}\n"
-                                 f"Published: {paper.published}\nSummary: {paper.summary}\n"
-                                 f"URL: {paper.pdf_url}")
-                
-                return {"arxiv_results": "\n\n".join(results)}
-            except Exception as e:
-                return {"arxiv_results": f"Error searching arXiv: {str(e)}"}
-        
-        arxiv_search_tool = FunctionTool.from_defaults(
-            search_arxiv,
-            name="search_arxiv",
-            description="Search scientific articles on arXiv about a given topic."
-        )
-        
-        # Define basic math tools
-        def add(a: int, b: int) -> int:
-            """Add two numbers."""
-            return a + b
-        
-        def subtract(a: int, b: int) -> int:
-            """Subtract b from a."""
-            return a - b
-        
-        def multiply(a: int, b: int) -> int:
-            """Multiply two numbers."""
-            return a * b
-        
-        def divide(a: int, b: int) -> float:
-            """Divide a by b."""
-            if b == 0:
-                raise ValueError("Cannot divide by zero.")
-            return a / b
-        
-        def modulus(a: int, b: int) -> int:
-            """Get the modulus of a divided by b."""
-            if b == 0:
-                raise ValueError("Cannot calculate modulus with zero.")
-            return a % b
-        
         # Create a list of all tools
         tools = [
             duckduckgo_search_tool,
             load_video_transcript_tool, 
             wikipedia_search_tool, 
-            web_page_reader_tool,
-            arxiv_search_tool,
-            FunctionTool.from_defaults(add),
-            FunctionTool.from_defaults(subtract),
-            FunctionTool.from_defaults(multiply),
-            FunctionTool.from_defaults(divide),
-            FunctionTool.from_defaults(modulus)
+            web_page_reader_tool
         ]
         
         # Create system prompt
         system_prompt = """
         You're an AI agent designed for question answering. Keep your answers concise or even one word when possible. 
         You have access to a bunch of tools, utilize them well to reach answers.
-        
-        Your answer should only start with "FINAL ANSWER: ", then follows with the answer. 
         """
         
         # Initialize the agent workflow
         self.agent = AgentWorkflow.from_tools_or_functions(tools, llm=self.llm, system_prompt=system_prompt)
-        print("BasicAgent initialized with all tools.")
+        print("BasicAgent initialized.")
 
-    async def run_agent(self, question: str):
-        # Check if question contains file data
-        if "file_data:" in question:
-            try:
-                # Split question and file data
-                parts = question.split("file_data:", 1)
-                question_text = parts[0].strip()
-                file_data_base64 = parts[1].strip()
-                
-                # Process file data (just mentioning it for now)
-                question = f"{question_text}\n[This question includes attached file data]"
-            except Exception as e:
-                print(f"Error processing file data: {e}")
-        
-        # Run agent and return response
-        return await self.agent.run(question)
-    
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         
         try:
-            response = asyncio.run(self.run_agent(question=question))
+            # Process file data if present
+            if "file_data:" in question:
+                parts = question.split("file_data:", 1)
+                question_text = parts[0].strip()
+                question = f"{question_text}\n[This question includes attached file data]"
             
-            # Extract final answer
-            if hasattr(response.response, 'blocks') and response.response.blocks:
-                final_answer = response.response.blocks[0].text
-            else:
-                final_answer = response.response
+            # Run the agent
+            response = self.agent.run(question)
             
-            # Extract final answer if it contains the marker
-            if "FINAL ANSWER:" in final_answer:
-                final_answer = final_answer.split("FINAL ANSWER:")[1].strip()
+            # Extract final answer
+            final_answer = response.response
             
             print(f"Agent returning answer: {final_answer[:50]}...")
             return final_answer
@@ -214,7 +137,7 @@ class BasicAgent:
             print(error_message)
             return error_message
 
-async def run_and_submit_all(profile: gr.OAuthProfile | None):
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
@@ -223,7 +146,7 @@ async def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        username = f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -270,7 +193,7 @@ async def run_and_submit_all(profile: gr.OAuthProfile | None):
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
-        await asyncio.sleep(20)  # Added delay between questions
+        time.sleep(20)  # Added delay between questions
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
@@ -397,4 +320,5 @@ if __name__ == "__main__":
     print("-"*(60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    # Use a different port to avoid conflicts
+    demo.launch(debug=True, share=False, server_port=7861)