update

agent.py

@@ -0,0 +1,103 @@
+from llama_index.core.workflow import (
+    Event,
+    StartEvent,
+    StopEvent,
+    Workflow,
+    step,
+)
+from llama_index.llms.deepseek import DeepSeek
+from llama_index.llms.openai import OpenAI 
+import sys
+from pathlib import Path
+project_root = str(Path(__file__).parent)
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+import os
+from tools import web_search, math_tools
+#from memory import set_memory
+from llama_index.core.agent.workflow import FunctionAgent, AgentWorkflow, ToolCall, ToolCallResult, ReActAgent
+#from llama_index.core.memory import Memory
+import asyncio
+from datetime import datetime
+from llama_index.core.chat_engine.types import ChatMessage
+from llama_index.core import Settings
+from llama_index.core.callbacks import CallbackManager
+from llama_index.utils.workflow import (
+    draw_most_recent_execution,
+)
+llm_gpt4o_mini = OpenAI(
+        model="gpt-4o-mini",
+        api_key=os.getenv("OPENAI_API_KEY"),
+        temperature=0.3,
+        max_retries=5,
+        timeout=100
+    )
+llm_deepseek_r1 = DeepSeek(
+        model="deepseek-chat",
+        api_key=os.getenv("DEEPSEEK_API_KEY"),
+        temperature=0.2,
+        max_retries=5,
+        timeout=100
+    )
+#test the llm
+#answerr = llm_deepseek_r1.complete("What is the capital of France?")
+#print(answerr)
+
+researcher_agent = FunctionAgent(
+    llm=llm_deepseek_r1,
+    name = "Viktor",
+    description="An agent that researches local documentation and the web, and creates succint reports about a given topic based on the information it found",
+    system_prompt=f"""Viktor is a multi-step reasoning assistant designed to provide comprehensive answers to user questions through systematic analysis and research. Viktor excels at breaking down complex queries and approaching them methodically.
+
+Available tools for Viktor:
+1. 'web_search' tool - Viktor uses this to search the web for current information, facts, data, and real-time updates on any topic.
+2. Math tools - Viktor can perform mathematical calculations including addition, subtraction, multiplication, division, and modulus operations.
+
+Viktor's Multi-Step Reasoning Workflow:
+1. **Query Analysis**: When given a user query, Viktor first analyzes and understands what information is needed to provide a complete answer.
+
+2. **Planning Phase**: Viktor develops a structured plan by:
+   - Breaking complex questions into smaller, specific sub-questions
+   - Identifying what types of information are needed (facts, recent updates, multiple perspectives, etc.)
+   - Determining the logical sequence for gathering information
+
+3. **Information Gathering**: Viktor systematically searches for information by:
+   - Formulating targeted search queries for each aspect of the question
+   - Conducting multiple searches to gather comprehensive information
+   - Seeking current and relevant data to ensure accuracy
+
+4. **Analysis and Synthesis**: Viktor processes the gathered information by:
+   - Analyzing different sources and perspectives
+   - Identifying patterns, connections, and key insights
+   - Cross-referencing information for consistency and accuracy
+
+5. **Structured Response**: Viktor provides a well-organized answer that:
+   - Directly addresses the user's question
+   - Presents information in a logical, easy-to-follow structure
+   - Uses clear headings and formatting when appropriate
+   - Includes relevant details while maintaining focus
+
+Reasoning Approach:
+- Viktor approaches each question methodically, thinking through multiple angles
+- For complex topics, Viktor gathers information from different perspectives
+- Viktor considers both current information and broader context
+- Viktor reasons through cause-and-effect relationships and implications
+- Viktor provides balanced, well-researched responses
+
+Response Guidelines:
+- STRICT!!! Only answer the question directly, concisely. For example, if the question is "What is the capital of France?", the answer should be "Paris".
+- No elaboration or explanation, only straight answer to the question.
+- Plain text response formatting.
+""",
+    tools = [
+        web_search,
+        math_tools.add,
+        math_tools.subtract,
+        math_tools.multiply,
+        math_tools.divide,
+        math_tools.modulus
+    ]
+)
+
+workflow_agent = AgentWorkflow(agents = [researcher_agent], root_agent=researcher_agent.name, verbose=True)
+

app.py

@@ -3,7 +3,13 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from llama_index.core.llms import ChatMessage
+from dotenv import load_dotenv
+from Final_Assignment_Agent.agent import workflow_agent
+# Load environment variables from .env file
+load_dotenv()
 
+HF_TOKEN = os.getenv("HF_TOKEN")
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -12,12 +18,28 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
+        self.agent = workflow_agent
         print("BasicAgent initialized.")
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        try:
+            # Use asyncio.run() to properly handle the async workflow
+            import asyncio
+            
+            async def run_agent():
+                # For AgentWorkflow, use the correct method to run the workflow
+                # Based on test results, this is the correct way to call it
+                result = await self.agent.run(user_msg=question)
+                return result
+            
+            # Use asyncio.run() which handles event loop creation/cleanup
+            answer = asyncio.run(run_agent())
+            print(f"Agent returning answer: {answer}")
+            return str(answer)
+        except Exception as e:
+            error_msg = f"Error running agent: {str(e)}"
+            print(error_msg)
+            return error_msg
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

requirements.txt

@@ -1,2 +1,4 @@
-gradio
-requests
+gradio[oauth]
+requests
+pandas
+python-dotenv

tools.py

@@ -0,0 +1,89 @@
+from linkup import LinkupClient
+from dotenv import load_dotenv
+import os
+load_dotenv()
+linkup_client = LinkupClient(api_key=os.getenv("LINKUP_API_KEY"))
+
+async def web_search(query: str) -> dict:
+    """Search the web for information about a given topic, or access real-time data through the web_search tool about anything on the internet. Returns a dictionary containing the answer and a list of sources."""
+    response = linkup_client.search(
+        query=query,
+        depth='standard',
+        output_type="sourcedAnswer"
+    )
+    answer = response.answer
+    # Format sources as a list of markdown links
+    sources = [f"- [{source.name}]({source.url})" for source in response.sources]
+    return {"answer": answer, "sources": sources}
+
+# MathTools
+class MathTools:
+    """A class containing basic mathematical operations."""
+    
+    def multiply(self, a: float, b: float) -> float:
+        """Multiply two numbers.
+        Args:
+            a: first number
+            b: second number
+        Returns:
+            The product of a and b
+        """
+        return a * b
+
+    def add(self, a: float, b: float) -> float:
+        """Add two numbers.
+        
+        Args:
+            a: first number
+            b: second number
+        Returns:
+            The sum of a and b
+        """
+        return a + b
+
+    def subtract(self, a: float, b: float) -> float:
+        """Subtract two numbers.
+        
+        Args:
+            a: first number
+            b: second number
+        Returns:
+            The difference of a and b
+        """
+        return a - b
+
+    def divide(self, a: float, b: float) -> float:
+        """Divide two numbers.
+        
+        Args:
+            a: dividend
+            b: divisor
+        Returns:
+            The quotient of a divided by b
+        Raises:
+            ValueError: If b is zero
+        """
+        if b == 0:
+            raise ValueError("Cannot divide by zero.")
+        return a / b
+
+    def modulus(self, a: int, b: int) -> int:
+        """Get the modulus of two numbers.
+        
+        Args:
+            a: dividend
+            b: divisor
+        Returns:
+            The remainder of a divided by b
+        Raises:
+            ValueError: If b is zero
+        """
+        if b == 0:
+            raise ValueError("Cannot perform modulus with zero.")
+        return a % b
+
+# Create an instance for easy importing
+math_tools = MathTools()
+
+
+