Update new files

agent.py

@@ -1,259 +1,307 @@
-"""LangGraph Agent"""
 import os
-import tempfile
-import cmath
-import pandas as pd
+from langchain.tools import tool
+from typing import Union, List
+from decimal import Decimal, getcontext
 from dotenv import load_dotenv
+from langchain_community.utilities import WikipediaAPIWrapper
+import warnings
+import wikipedia
+from bs4 import BeautifulSoup
+from langchain_community.tools import DuckDuckGoSearchRun
+import requests
+from typing import Optional
+import re
+from langchain_community.document_loaders import ArxivLoader
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
+from langchain_core.messages import SystemMessage, HumanMessage
 from langgraph.graph import START, StateGraph, MessagesState
 from langgraph.prebuilt import tools_condition
 from langgraph.prebuilt import ToolNode
-from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings
-from langchain_groq import ChatGroq
-from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader
-from langchain_community.document_loaders import ArxivLoader
 from langchain_community.vectorstores import SupabaseVectorStore
-from langchain_core.messages import SystemMessage, HumanMessage
-from langchain_core.tools import tool
-from langchain.tools.retriever import create_retriever_tool
 from supabase.client import Client, create_client
-from typing import List, Dict, Any, Optional
+from langchain.tools.retriever import create_retriever_tool
 
-load_dotenv()
+# Initialize search tool
+search_tool = DuckDuckGoSearchRun()
+getcontext().prec = 10
+# Initial configuration
+load_dotenv()  # Load environment variables
 
-@tool
-def multiply(a: int, b: int) -> int:
-    """
-    Multiply two integers.
+# Fix for parser warning
+wikipedia.wikipedia._BeautifulSoup = lambda html: BeautifulSoup(html, 'html.parser')
+warnings.filterwarnings("ignore", category=UserWarning, module="wikipedia")
+
+def configure_wikipedia(language: str = 'en', top_k_results: int = 3, max_chars: int = 4000):
+    """Configure Wikipedia search settings
     
     Args:
-        a (int): The first integer.
-        b (int): The second integer.
+        language (str): Search language (default 'en')
+        top_k_results (int): Number of results to return
+        max_chars (int): Maximum character limit per result
     
     Returns:
-        int: The product of a and b.
+        WikipediaAPIWrapper: Configured WikipediaAPIWrapper instance
     """
-    return a * b
+    wikipedia.set_lang(language)
+    return WikipediaAPIWrapper(
+        wiki_client=wikipedia,
+        top_k_results=top_k_results,
+        doc_content_chars_max=max_chars
+    )
 
-@tool
-def add(a: int, b: int) -> int:
-    """
-    Add two integers.
+def format_search_result(raw_result: str) -> str:
+    """Format Wikipedia search results for better readability
     
     Args:
-        a (int): The first integer.
-        b (int): The second integer.
+        raw_result (str): Raw output from WikipediaAPIWrapper
     
     Returns:
-        int: The sum of a and b.
+        str: Formatted search result
     """
-    return a + b
+    if "Page: " in raw_result and "Summary: " in raw_result:
+        parts = raw_result.split("Summary: ")
+        page_part = parts[0].replace("Page: ", "").strip()
+        summary_part = parts[1].strip()
+        return f"📚 Page: {page_part}\n\n📝 Summary: {summary_part}"
+    return raw_result
 
-@tool
-def subtract(a: int, b: int) -> int:
-    """
-    Subtract one integer from another.
+def search_wikipedia(query: str, language: str = 'en') -> str:
+    """Perform Wikipedia searches with error handling
     
     Args:
-        a (int): The integer to subtract from.
-        b (int): The integer to subtract.
+        query (str): Search term
+        language (str): Search language (optional)
     
     Returns:
-        int: The result of a minus b.
+        str: Formatted result or error message
     """
-    return a - b
+    try:
+        wikipedia_tool = configure_wikipedia(language=language)
+        result = wikipedia_tool.run(query)
+        return format_search_result(result)
+    except Exception as e:
+        return f"Search error: {str(e)}"
 
 @tool
-def divide(a: int, b: int) -> float:
+def add(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
+    """Add two numbers together.
+    
+    Args:
+        a (Union[int, float]): First number
+        b (Union[int, float]): Second number
+        
+    Returns:
+        Union[int, float]: Sum of a and b
     """
-    Divide one integer by another.
+    return float(Decimal(str(a)) + Decimal(str(b)))
+
+@tool
+def subtract(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
+    """Subtract b from a.
     
     Args:
-        a (int): The numerator.
-        b (int): The denominator. Must not be zero.
+        a (Union[int, float]): Minuend
+        b (Union[int, float]): Subtrahend
+        
+    Returns:
+        Union[int, float]: Difference between a and b
+    """
+    return float(Decimal(str(a)) - Decimal(str(b)))
+
+@tool
+def multiply(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
+    """Multiply two numbers.
     
+    Args:
+        a (Union[int, float]): First factor
+        b (Union[int, float]): Second factor
+        
     Returns:
-        float: The result of a divided by b.
+        Union[int, float]: Product of a and b
+    """
+    return float(Decimal(str(a)) * Decimal(str(b)))
+
+@tool
+def divide(a: Union[int, float], b: Union[int, float]) -> float:
+    """Divide a by b.
     
+    Args:
+        a (Union[int, float]): Dividend
+        b (Union[int, float]): Divisor
+        
+    Returns:
+        float: Quotient of a divided by b
+        
     Raises:
-        ValueError: If b is zero.
+        ValueError: If b is zero
     """
     if b == 0:
-        raise ValueError("Cannot divide by zero.")
-    return a / b
+        raise ValueError("Cannot divide by zero")
+    return float(Decimal(str(a)) / Decimal(str(b)))
 
 @tool
 def modulus(a: int, b: int) -> int:
-    """
-    Compute the modulus (remainder) of two integers.
+    """Find the remainder of a divided by b.
     
     Args:
-        a (int): The dividend.
-        b (int): The divisor.
-    
+        a (int): Dividend
+        b (int): Divisor
+        
     Returns:
-        int: The remainder after dividing a by b.
+        int: Remainder of a divided by b
+        
+    Raises:
+        ValueError: If b is zero
     """
+    if b == 0:
+        raise ValueError("Cannot divide by zero for modulus")
     return a % b
 
 @tool
-def power(a: float, b: float) -> float:
-    """
-    Raise a number to the power of another number.
+def power(base: Union[int, float], exponent: Union[int, float]) -> Union[int, float]:
+    """Raise base to the power of exponent.
     
     Args:
-        a (float): The base number.
-        b (float): The exponent.
-    
+        base (Union[int, float]): The base number
+        exponent (Union[int, float]): The exponent
+        
     Returns:
-        float: The result of a raised to the power of b.
+        Union[int, float]: Result of base^exponent
     """
-    return a**b
+    return float(Decimal(str(base)) ** Decimal(str(exponent)))
 
 @tool
-def square_root(a: float) -> float | complex:
-    """
-    Compute the square root of a number. Returns a complex number if input is negative.
+def square_root(x: Union[int, float]) -> float:
+    """Calculate the square root of a number.
     
     Args:
-        a (float): The number to compute the square root of.
-    
+        x (Union[int, float]): Number to find the square root of
+        
     Returns:
-        float or complex: The square root of a. Complex if a < 0.
+        float: Square root of x
+        
+    Raises:
+        ValueError: If x is negative
     """
-    if a >= 0:
-        return a**0.5
-    return cmath.sqrt(a)
-
-### =============== DOCUMENT PROCESSING TOOLS =============== ###
+    if x < 0:
+        raise ValueError("Cannot calculate square root of negative number")
+    return float(Decimal(str(x)).sqrt())
 
 @tool
-def save_and_read_file(content: str, filename: Optional[str] = None) -> str:
-    """
-    Save text content to a file and return the file path.
+def average(numbers: List[Union[int, float]]) -> float:
+    """Calculate the average of a list of numbers.
     
     Args:
-        content (str): The text content to save.
-        filename (str, optional): The name of the file. If not provided, a random name is generated.
-    
+        numbers (List[Union[int, float]]): List of numbers
+        
     Returns:
-        str: The file path where the content was saved.
+        float: Average of the numbers
+        
+    Raises:
+        ValueError: If list is empty
     """
-    temp_dir = tempfile.gettempdir()
-    if filename is None:
-        temp_file = tempfile.NamedTemporaryFile(delete=False, dir=temp_dir)
-        filepath = temp_file.name
-    else:
-        filepath = os.path.join(temp_dir, filename)
-
-    with open(filepath, "w") as f:
-        f.write(content)
-
-    return f"File saved to {filepath}. You can read this file to process its contents."
+    if not numbers:
+        raise ValueError("Cannot calculate average of empty list")
+    return float(sum(Decimal(str(n)) for n in numbers) / Decimal(len(numbers)))
 
 @tool
-def analyze_csv_file(file_path: str, query: str) -> str:
-    """
-    Analyze a CSV file and answer a question about its data.
+def percentage(value: Union[int, float], percent: Union[int, float]) -> float:
+    """Calculate percentage of a value.
     
     Args:
-        file_path (str): The path to the CSV file.
-        query (str): The question to answer about the data.
-    
+        value (Union[int, float]): Base value
+        percent (Union[int, float]): Percentage to calculate
+        
     Returns:
-        str: The analysis result or error message.
+        float: Result of value * (percent/100)
     """
-    try:
-        df = pd.read_csv(file_path)
-        result = f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
-        result += f"Columns: {', '.join(df.columns)}\n\n"
-        result += "Summary statistics:\n"
-        result += str(df.describe())
-        return result
-    except Exception as e:
-        return f"Error analyzing CSV file: {str(e)}"
+    return float(Decimal(str(value)) * (Decimal(str(percent)) / Decimal(100)))
 
 @tool
-def analyze_excel_file(file_path: str, query: str) -> str:
-    """
-    Analyze an Excel file and answer a question about its data.
+def web_search(query: str, site: Optional[str] = None, max_results: int = 5) -> str:
+    """Perform internet searches. Can search the entire web or specific websites.
     
     Args:
-        file_path (str): The path to the Excel file.
-        query (str): The question to answer about the data.
-    
+        query (str): Search terms
+        site (Optional[str]): Specific website to search (e.g., 'wikipedia.org')
+        max_results (int): Maximum number of results to return
+        
     Returns:
-        str: The analysis result or error message.
+        str: Formatted search results
     """
     try:
-        df = pd.read_excel(file_path)
-        result = (
-            f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
-        )
-        result += f"Columns: {', '.join(df.columns)}\n\n"
-        result += "Summary statistics:\n"
-        result += str(df.describe())
-        return result
+        if site and not re.match(r'^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', site.split('/')[0]):
+            return "Error: Invalid website format. Use 'domain.ext'"
+        
+        search_query = f"{query} site:{site}" if site else query
+        results = search_tool.run(search_query)
+        
+        formatted = []
+        for i, result in enumerate(results.split('\n\n')[:max_results]):
+            if result.strip():
+                formatted.append(f"{i+1}. {result.strip()}")
+        
+        header = f"Results from {site}" if site else "Search results"
+        return f"{header}:\n\n" + '\n\n'.join(formatted) if formatted else "No results found"
+    
     except Exception as e:
-        return f"Error analyzing Excel file: {str(e)}"
+        return f"Search error: {str(e)}"
 
 @tool
-def wiki_search(input: str) -> str:
-    """
-    Search Wikipedia for a query and return up to 2 results.
+def scrape_page(url: str, search_term: Optional[str] = None, max_length: int = 3000) -> str:
+    """Extract content from a specific webpage, optionally filtering by search term.
     
     Args:
-        input (str): The search query string.
-    
+        url (str): Full URL of the page to scrape
+        search_term (Optional[str]): Term to search within the page content
+        max_length (int): Maximum character length of returned content
+        
     Returns:
-        str: A formatted string containing up to 2 Wikipedia search results.
-    """
-    search_docs = WikipediaLoader(query=input, load_max_docs=2).load()
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
-            for doc in search_docs
-        ])
-    return {"wiki_results": formatted_search_docs}
-
-@tool
-def web_search(input: str) -> str:
+        str: Relevant page content with source attribution
     """
-    Search the web using Tavily and return up to 5 results.
-    
-    Args:
-        input (str): The search query string.
+    try:
+        if not re.match(r'^https?://[^\s/$.?#].[^\s]*$', url):
+            return "Error: Invalid URL format"
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        }
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        for element in soup(['script', 'style', 'nav', 'footer', 'iframe', 'img']):
+            element.decompose()
+        
+        text = '\n'.join(line.strip() for line in soup.get_text().split('\n') if line.strip())
+        
+        if search_term:
+            lines = [line for line in text.split('\n') if search_term.lower() in line.lower()]
+            text = '\n'.join(lines[:15])
+            
+        text = text[:max_length] + ('...' if len(text) > max_length else '')
+        
+        return f"Content from {url}:\n\n{text}"
     
-    Returns:
-        str: A formatted string containing up to 5 web search results.
-    """
-    search_docs = TavilySearchResults(max_results=5).invoke(input)
-    formatted_search_docs = "\n\n---\n\n".join(
-        [
-            (
-                f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
-                if hasattr(doc, "metadata") and hasattr(doc, "page_content")
-                else
-                f'<Document source="{doc.get("source", "")}" page="{doc.get("page", "")}"/>\n{doc.get("content", doc.get("page_content", ""))}\n</Document>'
-            )
-            for doc in search_docs
-        ]
-    )
-    return {"web_results": formatted_search_docs}
+    except requests.exceptions.RequestException as e:
+        return f"Network error: {str(e)}"
+    except Exception as e:
+        return f"Scraping error: {str(e)}"
 
 @tool
-def arvix_search(input: str) -> str:
-    """
-    Search Arxiv for a query and return up to 3 results.
+def arvix_search(query: str) -> str:
+    """Search Arxiv for a query and return maximum 3 results.
     
     Args:
-        input (str): The search query string.
-    
+        query (str): The search query
+        
     Returns:
-        str: A formatted string containing up to 3 Arxiv search results.
+        str: Formatted search results
     """
-    search_docs = ArxivLoader(query=input, load_max_docs=3).load()
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
     formatted_search_docs = "\n\n---\n\n".join(
         [
             f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
@@ -261,24 +309,22 @@ def arvix_search(input: str) -> str:
         ])
     return {"arvix_results": formatted_search_docs}
 
-# load the system prompt from the file
-with open("system_prompt.txt", "r", encoding="utf-8") as f:
+# Load system prompt
+with open("prompt.txt", "r", encoding="utf-8") as f:
     system_prompt = f.read()
 
-# System message
 sys_msg = SystemMessage(content=system_prompt)
 
-# build a retriever
-embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2") #  dim=768
-#embeddings = GoogleGenerativeAIEmbeddings(model="models/gemini-embedding-exp-03-07")
+# Build retriever
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
 supabase: Client = create_client(
     os.environ.get("SUPABASE_URL"), 
-    os.environ.get("SUPABASE_KEY"))
+    os.environ.get("SUPABASE_SERVICE_KEY"))
 vector_store = SupabaseVectorStore(
     client=supabase,
-    embedding= embeddings,
+    embedding=embeddings,
     table_name="documents",
-    query_name="match_documents_langchain",
+    query_name="match_documents",
 )
 create_retriever_tool = create_retriever_tool(
     retriever=vector_store.as_retriever(),
@@ -287,34 +333,27 @@ create_retriever_tool = create_retriever_tool(
 )
 
 tools = [
+    arvix_search,
+    scrape_page,
+    web_search,
+    percentage,
+    average,
+    square_root,
+    power,
+    modulus,
+    divide,
     multiply,
-    add,
     subtract,
-    divide,
-    modulus,
-    power,
-    square_root,
-    wiki_search,
-    web_search,
-    arvix_search,
-    save_and_read_file,
-    analyze_csv_file,
-    analyze_excel_file,
-    # create_retriever_tool
+    add,
 ]
 
-# Build graph function
 def build_graph(provider: str = "groq"):
     """Build the graph"""
-    # Load environment variables from .env file
     if provider == "google":
-        # Google Gemini
         llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
     elif provider == "groq":
-        # Groq https://console.groq.com/docs/models
-        llm = ChatGroq(model="qwen-qwq-32b", temperature=0) # optional : qwen-qwq-32b gemma2-9b-it
+        llm = ChatGroq(model="qwen-qwq-32b", temperature=0)
     elif provider == "huggingface":
-        # TODO: Add huggingface endpoint
         llm = ChatHuggingFace(
             llm=HuggingFaceEndpoint(
                 url="https://api-inference.huggingface.co/models/Meta-DeepLearning/llama-2-7b-chat-hf",
@@ -323,26 +362,17 @@ def build_graph(provider: str = "groq"):
         )
     else:
         raise ValueError("Invalid provider. Choose 'google', 'groq' or 'huggingface'.")
-    # Bind tools to LLM
+    
     llm_with_tools = llm.bind_tools(tools)
 
-    # Node
     def assistant(state: MessagesState):
-        """Assistant node"""
         return {"messages": [llm_with_tools.invoke(state["messages"])]}
     
     def retriever(state: MessagesState):
-        """Retriever node"""
         similar_question = vector_store.similarity_search(state["messages"][0].content)
-        # similar_question = "What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?"
-        if similar_question:
-            example_msg = HumanMessage(
-                content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
-            )
-        else:
-            example_msg = HumanMessage(
-                content="No similar questions found in the database.",
-            )
+        example_msg = HumanMessage(
+            content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+        )
         return {"messages": [sys_msg] + state["messages"] + [example_msg]}
 
     builder = StateGraph(MessagesState)
@@ -357,17 +387,10 @@ def build_graph(provider: str = "groq"):
     )
     builder.add_edge("tools", "assistant")
 
-    # Compile graph
     return builder.compile()
 
-# test
 if __name__ == "__main__":
-    #question = "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect?"
-    question = "What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?"
-    # Build the graph
-    graph = build_graph(provider="groq")
-    # Run the graph
-    messages = [HumanMessage(content=question)]
-    messages = graph.invoke({"messages": messages})
-    for m in messages["messages"]:
-        m.pretty_print()
+    app = build_graph(provider="groq")
+    inputs = {"messages": [HumanMessage(content="I was reading this book last year, and it had this really cool description where it referred to something as looking like a manta ray. I\u2019m trying to figure out when I read that part, but I can\u2019t find what book it\u2019s from. This file I attached has a list of the books I read last year, with the date I started and finished reading each one. I\u2019d like for you to tell me the month in which I likely read the passage about the manta ray.")]}
+    result = app.invoke(inputs)
+    print(result)

app.py

@@ -1,24 +1,18 @@
-""" Basic Agent Evaluation Runner"""
 import os
-import inspect
 import gradio as gr
 import requests
+import inspect
 import pandas as pd
 from langchain_core.messages import HumanMessage
 from agent import build_graph
 
-
-
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-
-
 class BasicAgent:
-    """A langgraph agent."""
     def __init__(self):
         print("BasicAgent initialized.")
         self.graph = build_graph()
@@ -159,9 +153,11 @@ with gr.Blocks() as demo:
     gr.Markdown(
         """
         **Instructions:**
+
         1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
         2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
         3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+
         ---
         **Disclaimers:**
         Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).

prompt.txt

@@ -0,0 +1,5 @@
+You are a helpful assistant tasked with answering questions using a set of tools. 
+Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
+FINAL ANSWER: [YOUR FINAL ANSWER]. 
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer. 

requirements.txt

@@ -1,18 +1,14 @@
-radio
+gradio
 requests
+dotenv
 langchain
 langchain-community
-langchain-core
-langchain-google-genai
-langchain-huggingface
+wikipedia
+langchain_experimental
+duckduckgo-search
+langchain_google_genai
 langchain-groq
-langchain-tavily
-langchain-chroma
 langgraph
-huggingface_hub
 supabase
-arxiv
-pymupdf
-wikipedia
-pgvector
-python-dotenv
+langchain-huggingface
+itsdangerous