Score : 45

app.py

@@ -5,7 +5,7 @@ import inspect
 import pandas as pd
 from typing import Any
 
-from src.final_assignment_template.agent import manager_agent
+from src.final_assignment_template.agent import Task_agent
 # (Keep Constants as is)
 # --- Constants ---
 
@@ -35,9 +35,9 @@ class BasicAgent:
         if task_id and file_name:
           print('With task_id')
           print(task_id)
-          fixed_answer = manager_agent.run(f"""<Task>{question_text}</Task>\n<TaskID>{task_id}</TaskID>""")
+          fixed_answer = Task_agent.run(f"""<Task>{question_text}</Task>\n<TaskID>{task_id}</TaskID>""")
         else:
-          fixed_answer = manager_agent.run(f'<Task>{question_text}</Task>')
+          fixed_answer = Task_agent.run(f'<Task>{question_text}</Task>')
           print(f'---------------------fixed_answer----------------\n{fixed_answer}')
 
         return fixed_answer
@@ -97,11 +97,9 @@ 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:
+    for item in questions_data[0:20]:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        file_name = item.get("file_name")
-        file_data = None
         #  or file_name != ''
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")

src/final_assignment_template/agent.py

@@ -1,55 +1,102 @@
-from smolagents import load_tool, Tool, tool, ToolCallingAgent, CodeAgent, GoogleSearchTool,FinalAnswerTool,PythonInterpreterTool , LiteLLMModel,  VisitWebpageTool,  DuckDuckGoSearchTool
-from litellm import completion
+from smolagents import CodeAgent,ToolCallingAgent, PythonInterpreterTool , VisitWebpageTool, DuckDuckGoSearchTool
 
-from langchain.agents import load_tools
-from langchain_community.tools.tavily_search import TavilySearchResults
 
-import os
 from src.final_assignment_template.models import openrouter_qwenCoder_model, modelLiteLLm
-from src.final_assignment_template.tools import travily_tool, Video_understanding_tool, image_understanding_tool, get_task_file
+from src.final_assignment_template.tools import travily_tool, bm25_query, BM25Tool,extract_filter_textual_info_from_textual_context, summarize_before_final_answer, Video_link_understanding_tool, image_understanding_tool, get_task_file
 # (Keep Constants as is)
 # --- Constants ---
 
 
+# retrived_context_qa_agent = ToolCallingAgent(
+#     name="retrived_context_qa_agent",
+#     description="""
+#     You are a simple QA agent for the retrived web contect.
+#       1. Pass query and context and avaialbe tools.
+#       2. If you can answer directly, respond in plain text.
+#       3. Otherwise, return an explicit action JSON, e.g.
+#          {"action": "use_tool", "tool_name": "...", "input": "..."}.
+#     """,
+#     model=modelLiteLLm,
+#     tools=[],               # no extra tools by default
+#     add_base_tools=False,   # don’t add PythonInterpreterTool, etc.
+#     verbosity_level=1,
+#     planning_interval=1,
+# )
 
 
 
+# web_agent = CodeAgent(
+#     model=openrouter_qwenCoder_model,
+#     tools=[
+#         # GoogleSearchTool(provider="serper"),
+#         # DuckDuckGoSearchTool(max_results=10),
+#         travily_tool,
+#         VisitWebpageTool(),
+#     ],
+#     name="web_agent",
+#     description="""Browses the web to find information""",
+#     verbosity_level=1,
+#     planning_interval=1,
+#     max_steps=8,
+# )
 
-web_agent = CodeAgent(
-    model=openrouter_qwenCoder_model,
+# code_agent = CodeAgent(
+#     model=openrouter_qwenCoder_model,
+#     tools=[
+#         # GoogleSearchTool(provider="serper"),
+#         # DuckDuckGoSearchTool(max_results=10),
+#       PythonInterpreterTool(additional_authorized_imports=[
+#         "json",
+#         "markdown",
+#         'numpy',
+#         'pandas'
+#         'math', 'statistics', 're', 'unicodedata', 'random', 
+#         'datetime', 'queue', 'time', 'collections', 'stat', 'itertools',
+#     ])
+#     ],
+#     name="code_agent",
+#     description="""You can execute python code using this agent""",
+#     verbosity_level=1,
+#     max_steps=3,
+# )
+
+    # - When using the Video_Link_Understanding_Tool and Image_Understanding_Tool, consider their responses and generate an answer based on the textual understanding they provide.
+    #     - Video_Link_Understanding_Tool: This tool can only return textual understanding.
+    #     - Image_Understanding_Tool: This tool can only return textual understanding.
+Task_agent = CodeAgent(
+    name="task_Agent",
+    description="""
+        - You are the Task Agent.
+        - Provide the correct answer
+        - Must call 'summarize_before_final_answer' at the end
+    """,
+    model=modelLiteLLm,
+    add_base_tools=True,
     tools=[
-        # GoogleSearchTool(provider="serper"),
-        # DuckDuckGoSearchTool(max_results=10),
+        PythonInterpreterTool(),
+        Video_link_understanding_tool,
+        image_understanding_tool,
+        get_task_file,
         travily_tool,
+        # DuckDuckGoSearchTool(),
+        # bm25_query,
         VisitWebpageTool(),
+        extract_filter_textual_info_from_textual_context,
+        # summarize_before_final_answer,
     ],
-    name="web_agent",
-    description="""Browses the web to find information""",
-    verbosity_level=1,
-    max_steps=5,
-)
-
-manager_agent = CodeAgent(
-    name="Task_Agent",
-    description="""You will be provided a task and you need to verify before giving final answer
-    You can perform tasks which are text and image based, skip all other
-    """,
-    model=modelLiteLLm,
-    tools=[PythonInterpreterTool(),Video_understanding_tool,image_understanding_tool,get_task_file],
-    managed_agents=[web_agent],
     additional_authorized_imports=[
-        "json",
-        "pandas",
-        "numpy",
-        "markdown"
-        'math', 'statistics', 're', 'unicodedata', 'random', 
-        'datetime', 'queue', 'time', 'collections', 'stat', 'itertools',
-        'PIL','requests'
+        'numpy',
+        'pandas'
+        'math',  
+        'datetime',
     ],
-    planning_interval=3,
+            # managed_agents=[web_agent],
+    planning_interval=1,
     verbosity_level=1,
+    max_steps=7,
     # final_answer_checks=[check_reasoning_and_plot],
-    max_steps=5,
 )
 
 
+
+

src/final_assignment_template/models.py

@@ -2,14 +2,24 @@ from smolagents import LiteLLMModel
 import os
 
 
+planner_model = LiteLLMModel(
+    # model_id="openrouter/openai/o4-mini-high",
+    model_id="openrouter/deepseek/deepseek-r1:free",
+    api_base="https://openrouter.ai/api/v1",
+    api_key=os.getenv("OPENROUTER_API_KEY")
+)
+
+
 openrouter_qwenCoder_model = LiteLLMModel(
     model_id="openrouter/qwen/qwen-2.5-coder-32b-instruct:free",
     api_base="https://openrouter.ai/api/v1",
     api_key=os.getenv("OPENROUTER_API_KEY")
 )
 
+# nvidia/llama-3.3-nemotron-super-49b-v1:free
+# microsoft/mai-ds-r1:free
 modelLiteLLm = LiteLLMModel(
-    model_id="openrouter/deepseek/deepseek-r1:free",
+    model_id="openrouter/microsoft/mai-ds-r1:free",
      api_base="https://openrouter.ai/api/v1",
     api_key=os.getenv("OPENROUTER_API_KEY")
 )
@@ -27,3 +37,10 @@ imageLiteLLm = LiteLLMModel(
      api_base="https://openrouter.ai/api/v1",
     api_key=os.getenv("OPENROUTER_API_KEY")
 )
+
+
+summarizeModle = LiteLLMModel(
+    model_id="openrouter/meta-llama/llama-4-maverick:free",
+     api_base="https://openrouter.ai/api/v1",
+    api_key=os.getenv("OPENROUTER_API_KEY")
+)

src/final_assignment_template/tools.py

@@ -10,11 +10,13 @@ from io import BytesIO
 import base64
 
 
-from src.final_assignment_template.models import videoLiteLLm, imageLiteLLm
+from langchain_core.documents import Document
+from langchain_community.retrievers import BM25Retriever
+from src.final_assignment_template.models import videoLiteLLm,modelLiteLLm, summarizeModle, imageLiteLLm
 
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-travily_tool = Tool.from_langchain(TavilySearchResults(max_results=25,))
+travily_tool = Tool.from_langchain(TavilySearchResults(max_results=20))
 
 from smolagents import Tool
 
@@ -40,18 +42,123 @@ from smolagents import Tool
 # model_downloads_tool = HFModelDownloadsTool()
 
 
+from langchain_core.documents import Document
+from langchain_community.retrievers import BM25Retriever
+
+@tool
+def bm25_query(texts: list[str], query: str, top_k: int = 3) -> list[str]:
+    """
+    Creates a BM25 retriever from a list of texts (e.g., web pages, articles),
+    queries it, and returns the top relevant results.
+
+    Args:
+        texts (list[str]): List of text contents (e.g., web page texts, articles, notes).
+        query (str): The search query string.
+        top_k (int): Number of top results to return (default is 3).
+    
+    Returns:
+        list[str]: List of top-k relevant page contents.
+    """
+    documents = [Document(page_content=text) for text in texts]
+    retriever = BM25Retriever.from_documents(documents)
+    results = retriever.get_relevant_documents(query)
+    print(results)
+    return [doc.page_content for doc in results[:top_k]]
+
+
+
+class BM25Tool(Tool):
+    name = "bm25"
+    description = (
+        "Retrieves relevant information from a provided list of text strings "
+        "based on a query using BM25."
+    )
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The text query to search for relevant strings."
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, texts: list[str]):
+        """
+        Args:
+            texts (list[str]): A list of text strings to index (e.g., guest bios, docs, notes).
+        """
+        documents = [Document(page_content=text) for text in texts]
+        self.retriever = BM25Retriever.from_documents(documents)
+
+    def forward(self, query: str) -> str:
+        """
+        Retrieves the top-3 most relevant strings matching the query.
+
+        Args:
+            query (str): Text query.
+
+        Returns:
+            str: Concatenated top-3 matching strings or a not-found message.
+        """
+        results = self.retriever.get_relevant_documents(query)
+        if not results:
+            return "No relevant information found."
+        top_texts = [doc.page_content for doc in results[:3]]
+        return "\n\n".join(top_texts)
+
+
+
 @tool
-def Video_understanding_tool(query:str)->str:
-  """
-    This tool for understanding or finding something in the video link.
+def summarize_before_final_answer(
+    context: str,
+    question: str,
+) -> str:
+    """
+    Given a whole context(all logs) and question sends it to the LLM, and returns the paragraph overview for the answer.
 
     Args:
-        query: link with your query.
-  """
-  print("processcing vidoe ",query)
-  messages =[ {"role": "user", "content": [{"type": "text", "text": query}]} ]
-  resp = videoLiteLLm(messages)
-  return resp.content or 'No data'
+        context (str): The full context or background information.
+        question (str): The user's specific question about that context.
+
+    Returns:
+        str: Summarization of whole process for generating final answer.
+    """
+    # build a single user prompt
+    prompt = (
+        context.strip()
+        + "\n\n"
+        + "Question: "
+        + question.strip()
+        + "\n\n"
+        + "Give the summarize of all steps for generating final answer in next step:"
+    )
+
+
+    # call the model
+    response = summarizeModle(
+        messages=[{"role": "user", "content": prompt}],
+    )
+
+    # the .content attribute holds the generated text
+    return response.content.strip()
+
+
+
+@tool
+def Video_link_understanding_tool(query: str) -> str:
+    """
+    A tool that processes a video link (e.g., YouTube) and returns a textual understanding of its content using an LLM.
+
+    Args:
+        query: A video URL along with an optional query for context or specific focus.
+
+    Returns:
+        A text-based summary or understanding of the video content.
+    """
+    print("Processing video:", query)
+    messages = [{"role": "user", "content": [{"type": "text", "text": query}]}]
+    resp = videoLiteLLm(messages)
+    return resp.content or 'No data'
+
 
 
 
@@ -74,28 +181,31 @@ def get_task_file(task_id:str)->requests.models.Response:
     return response
 
 @tool
-def image_understanding_tool(query:str,response:requests.models.Response)->str:
-  """
-    This tool for understanding or perform any query on the image.
-    Provide the image base64 image data
-    
+def image_understanding_tool(query: str, response: requests.models.Response) -> str:
+    """
+    A tool for analyzing and understanding the content of an image based on a given query.
+
+    This tool processes the image provided in the response (from get_task_file), encodes it into base64,
+    and queries a lightweight image LLM to generate insights or answers about the image.
 
     Args:
-        query: Query for the image.
-        response : The return value from the get_task_file which returns the response.
-  """
-  print("processcing image ")
-  
-  
-  image = Image.open(BytesIO(response.content)).convert("RGB")
-
-  buffered = BytesIO()
-  image.save(buffered, format="PNG")  # change format if necessary
-  img_bytes = buffered.getvalue()
-  img_b64 = base64.b64encode(img_bytes).decode('utf-8')
-
-  print(img_b64)
-  messages =[ {
+        query: The query or instruction related to the image content.
+        response: The HTTP response object containing the image data.
+
+    Returns:
+        A text-based understanding or interpretation of the image.
+    """
+    print("Processing image...")
+
+    image = Image.open(BytesIO(response.content)).convert("RGB")
+
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    img_bytes = buffered.getvalue()
+    img_b64 = base64.b64encode(img_bytes).decode('utf-8')
+
+    # print(img_b64)
+    messages = [{
         "role": "user",
         "content": [
             {"type": "text", "text": query},
@@ -103,13 +213,49 @@ def image_understanding_tool(query:str,response:requests.models.Response)->str:
                 "type": "image_url",
                 "image_url": {
                     "url": img_b64,
-                    "format": "image/png"  # Adjust MIME type if necessary
+                    "format": "image/png"
                 }
             }
         ]
-    } ]
-  resp = imageLiteLLm(messages)
-  print(resp.content)
-  return resp.content or 'No data'
+    }]
+    
+    resp = imageLiteLLm(messages)
+    print(resp.content)
+    return resp.content or 'No data'
+
+
+
+
+
+@tool
+def extract_filter_textual_info_from_textual_context(
+    context: str,
+    question: str,
+) -> str:
+    """
+    Tool to pull out targeted details from a large body of text.
+
+    Combines the context and an questoin into a single prompt,
+    queries the llm, and returns the resulting extract.
+
+    Args:
+        context (str): The full background text (e.g., long document, webpage, notes).
+        question (str): What you want to extract (e.g., “list all dates mentioned”).
+
+    Returns:
+        str: The extracted information, trimmed of whitespace.
+    """
+    # Build the extraction prompt
+    prompt = (
+        "Context:\n" + context.strip() +
+        "\n\nQuestion: " + question.strip() +
+        "\n\nExtracted Information:"
+    )
 
 
+    # Call the model to perform extraction
+    response = modelLiteLLm(
+        messages=[{"role": "user", "content": prompt}],
+    )
+    print(response)
+    return response.content