Update agent.py

agent.py

@@ -1,219 +1,146 @@
 import os
-from dotenv import load_dotenv
-from langgraph.graph import START, StateGraph, MessagesState
-from langgraph.prebuilt import tools_condition
-from langgraph.prebuilt import ToolNode
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_openai import ChatOpenAI
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_huggingface import ChatHuggingFace
-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
-
-load_dotenv()
+import tempfile
 
-@tool
-def multiply(a: int, b: int) -> int:
-    """Multiply two numbers.
-    Args:
-        a: first int
-        b: second int
-    """
-    return a * b
+import requests
+from google import genai
+from google.genai import types
+from smolagents import tool
 
-@tool
-def add(a: int, b: int) -> int:
-    """Add two numbers.
-    
-    Args:
-        a: first int
-        b: second int
-    """
-    return a + b
 
 @tool
-def subtract(a: int, b: int) -> int:
-    """Subtract two numbers.
-    
+def download_file_of_task_id(task_id: str, file_name: str) -> str:
+    """
+    Download a file associated with a specific task ID and save it to a temporary location.
     Args:
-        a: first int
-        b: second int
+        task_id (str): The unique identifier of the task associated with the file to download.
+        file_name (str): The name to assign to the downloaded file.
+    Returns:
+        str: Path to the downloaded file or an error message if the download fails.
     """
-    return a - b
+
+    try:
+        # Create temporary file
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, file_name)
+
+        # Download the file
+        response = requests.get(f"https://agents-course-unit4-scoring.hf.space/files/{task_id}",
+                                stream=True)
+        response.raise_for_status()
+
+        # Save the file
+        with open(filepath, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        return filepath
+    except Exception as e:
+        return f"Error downloading file: {e!s}"
+
 
 @tool
-def divide(a: int, b: int) -> int:
-    """Divide two numbers.
-    
+def analyze_audio_file(path_file_audio: str, query: str) -> str:
+    """
+    Analyzes an MP3 audio file to answer a specific query.
     Args:
-        a: first int
-        b: second int
+        path_file_audio (str): Path to the MP3 audio file to be analyzed.
+        query (str): Question or query to analyze the content of the audio file.
+    Returns:
+        str: The result of the analysis of audio.
     """
-    if b == 0:
-        raise ValueError("Cannot divide by zero.")
-    return a / b
+
+    client = genai.Client(api_key=os.getenv("API_KEY"))
+
+    myfile = client.files.upload(file=path_file_audio)
+
+    response = client.models.generate_content(
+        model=os.getenv("GOOGLE_MODEL_ID"),
+        contents=[f"Carefully analyze the audio to answer the question correctly.\n\n The question is {query}",
+                  myfile]
+    )
+
+    return response.text
+
 
 @tool
-def modulus(a: int, b: int) -> int:
-    """Get the modulus of two numbers.
-    
+def analyze_youtube_video(url_youtube_video: str, query: str) -> str:
+    """
+    Analyzes a YouTube video using the provided query.
     Args:
-        a: first int
-        b: second int
+        url_youtube_video (str): URL of the YouTube video to analyze.
+        query (str): Query or question to analyze the content of the video.
+    Returns:
+        str: Result of the video analysis.
     """
-    return a % b
 
-@tool
-def wiki_search(query: str) -> str:
-    """Search Wikipedia for a query and return maximum 2 results.
-    
-    Args:
-        query: The search query."""
-    search_docs = WikipediaLoader(query=query, 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}
+    client = genai.Client(api_key=os.getenv("API_KEY"))
+
+    response = client.models.generate_content(
+        model=f"models/{os.getenv('GOOGLE_MODEL_ID')}",
+        contents=types.Content(
+            parts=[
+                types.Part(
+                    file_data=types.FileData(file_uri=url_youtube_video)
+                ),
+                types.Part(text=f"Carefully analyze each frame of the video to answer the question correctly.\n\n The question is {query}")
+            ]
+        )
+    )
+
+    return response.text
 
-@tool
-def web_search(query: str) -> str:
-    """Search Tavily for a query and return maximum 3 results.
-    
-    Args:
-        query: The search query."""
-    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
-    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 {"web_results": formatted_search_docs}
 
 @tool
-def arvix_search(query: str) -> str:
-    """Search Arxiv for a query and return maximum 3 result.
-    
+def analyze_image_file(path_file_image: str, query: str) -> str:
+    """
+    Analyzes an image file to answer a specific query.
     Args:
-        query: The search query."""
-    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>'
-            for doc in search_docs
-        ])
-    return {"arvix_results": formatted_search_docs}
-
-
-
-# load the system prompt from the file
-with open("system_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
-supabase: Client = create_client(
-    os.environ.get("SUPABASE_URL"), 
-    os.environ.get("SUPABASE_SERVICE_KEY"))
-vector_store = SupabaseVectorStore(
-    client=supabase,
-    embedding= embeddings,
-    table_name="documents",
-    query_name="match_documents_langchain",
-)
-create_retriever_tool = create_retriever_tool(
-    retriever=vector_store.as_retriever(),
-    name="Question Search",
-    description="A tool to retrieve similar questions from a vector store.",
-)
-
-
-
-tools = [
-    multiply,
-    add,
-    subtract,
-    divide,
-    modulus,
-    wiki_search,
-    web_search,
-    arvix_search,
-]
-
-# Build graph function
-def build_graph(provider: str = "huggingface", huggingface_model: str = "mistral"):
-    """Build the graph with tool binding."""
-
-    if provider == "google":
-        llm = ChatGoogleGenerativeAI(
-            model="gemini-2.0-flash",
-            temperature=0,
-            google_api_key=os.getenv("GOOGLE_API_KEY")
-        )
+        path_file_image (str): Path to the image file to be analyzed.
+        query (str): Question or query to analyze the content of the image file.
+    Returns:
+        str: The result of the analysis of audio.
+    """
 
-    elif provider == "huggingface":
-        if huggingface_model == "mistral":
-            repo_id = "mistralai/Mistral-7B-Instruct-v0.1"
-        elif huggingface_model == "llama":
-            repo_id = "Meta-DeepLearning/llama-2-7b-chat-hf"
-        else:
-            raise ValueError("Unsupported Hugging Face model")
-
-        hf_token = os.getenv("HF_TOKEN")
-        headers = {"Authorization": f"Bearer {hf_token}"} if hf_token else {}
-
-        llm = ChatHuggingFace(
-            llm=HuggingFaceEndpoint(
-                repo_id=repo_id,
-                temperature=0,
-                )
-        )
+    client = genai.Client(api_key=os.getenv("API_KEY"))
+
+    myfile = client.files.upload(file=path_file_image)
 
-    else:
-        raise ValueError("Invalid provider. Choose 'google' or 'huggingface'.")
+    response = client.models.generate_content(
+        model=os.getenv('GOOGLE_MODEL_ID'),
+        contents=[myfile,
+                  f"Carefully analyze the image file and think to answer the question correctly.\n\n The question is {query}"]
+    )
 
-    return llm
+    return response.text
 
-    # ✅ Bind tools if defined
-    llm_with_tools = llm.bind_tools(tools)  # Make sure `tools` is defined/imported
-    return llm_with_tools
 
-    # Node
-    def assistant(state: MessagesState):
-        """Assistant node"""
-        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+@tool
+def analyze_xlsx_file(file_path: str, query: str) -> str:
+    """
+    Analyze an Excel file using pandas and answer a question about it.
+    Args:
+        file_path: Path to the Excel file
+        query: Question about the data
+    Returns:
+        Analysis result or error message
+    """
     
-    def retriever(state: MessagesState):
-        """Retriever node"""
-        similar_question = vector_store.similarity_search(state["messages"][0].content)
-        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)
-    builder.add_node("retriever", retriever)
-    builder.add_node("assistant", assistant)
-    builder.add_node("tools", ToolNode(tools))
-    builder.add_edge(START, "retriever")
-    builder.add_edge("retriever", "assistant")
-    builder.add_conditional_edges(
-        "assistant",
-        tools_condition,
-    )
-    builder.add_edge("tools", "assistant")
+    try:
+        import pandas as pd
+
+        # Read the Excel file
+        df = pd.read_excel(file_path)
+
+        # Run various analyses based on the query
+        result = f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        result += f"Columns: {', '.join(df.columns)}\n\n"
 
-    # Compile graph
-    return builder.compile()
+        # Add summary statistics
+        result += "Summary statistics:\n"
+        result += str(df.describe())
 
+        return result
+    except ImportError:
+        return "Error: pandas and openpyxl are not installed. Please install them with 'pip install pandas openpyxl'."
+    except Exception as e:
+        return f"Error analyzing Excel file: {e!s}"