Add full langgraph agent with all tools

app.py

@@ -3,21 +3,302 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import io
+import contextlib
+from typing import TypedDict, Annotated
+import torch
+
+# --- Multimodal & Web Tool Imports ---
+from transformers import pipeline
+from youtube_transcript_api import YouTubeTranscriptApi
+import requests
+from bs4 import BeautifulSoup
+
+# --- LangChain & LangGraph Imports ---
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, ToolMessage
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_huggingface import ChatHuggingFace
+from langchain_huggingface import HuggingFaceEndpoint
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_core.tools import tool
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+# --- Initialize ASR Pipeline (for Audio Tool) ---
+# Load the model once when the app starts for efficiency
+try:
+    asr_pipeline = pipeline(
+        "automatic-speech-recognition", 
+        model="openai/whisper-base",
+        torch_dtype=torch.float16, # Use float16 for faster inference
+        device_map="auto" # Use GPU if available
+    )
+    print("✅ ASR (Whisper) pipeline loaded successfully.")
+except Exception as e:
+    print(f"⚠️ Warning: Could not load ASR pipeline. Audio tool will not work. Error: {e}")
+    asr_pipeline = None
+
+# --- Tool Definitions ---
+
+@tool
+def search_tool(query: str) -> str:
+    """Calls DuckDuckGo search and returns the results."""
+    print(f"--- Calling Search Tool with query: {query} ---")
+    try:
+        search = DuckDuckGoSearchRun()
+        return search.run(query)
+    except Exception as e:
+        return f"Error running search: {e}"
+
+@tool
+def code_interpreter(code: str) -> str:
+    """
+    Executes a string of Python code and returns its stdout, stderr, and any error.
+    Use this for calculations, data manipulation, or any other Python operation.
+    The code runs in a sandboxed environment.
+    Note: 'pandas' and 'openpyxl' are available.
+    """
+    print(f"--- Calling Code Interpreter with code:\n{code}\n---")
+    output_stream = io.StringIO()
+    error_stream = io.StringIO()
+    
+    try:
+        # Use contextlib to redirect stdout and stderr
+        with contextlib.redirect_stdout(output_stream), contextlib.redirect_stderr(error_stream):
+            # Execute the code. Provide 'pd' (pandas) in the globals
+            exec(code, {"pd": pd}, {})
+        
+        stdout = output_stream.getvalue()
+        stderr = error_stream.getvalue()
+        
+        if stderr:
+            return f"Error: {stderr}\nStdout: {stdout}"
+        return f"Success:\n{stdout}"
+    
+    except Exception as e:
+        # Capture any exception during exec
+        return f"Execution failed with error: {str(e)}"
+
+@tool
+def read_file(path: str) -> str:
+    """Reads the content of a file at the specified path."""
+    print(f"--- Calling Read File Tool at path: {path} ---")
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        return f"Error reading file {path}: {str(e)}"
+
+@tool
+def write_file(path: str, content: str) -> str:
+    """Writes the given content to a file at the specified path."""
+    print(f"--- Calling Write File Tool at path: {path} ---")
+    try:
+        # Ensure the directory exists
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return f"Successfully wrote to file {path}."
+    except Exception as e:
+        return f"Error writing to file {path}: {str(e)}"
+
+@tool
+def list_directory(path: str = ".") -> str:
+    """Lists the contents of a directory at the specified path."""
+    print(f"--- Calling List Directory Tool at path: {path} ---")
+    try:
+        files = os.listdir(path)
+        return "\n".join(files) if files else "Directory is empty."
+    except Exception as e:
+        return f"Error listing directory {path}: {str(e)}"
+
+@tool
+def audio_transcription_tool(file_path: str) -> str:
+    """
+    Transcribes an audio file (like .mp3 or .wav) and returns the text.
+    """
+    print(f"--- Calling Audio Transcription Tool at path: {file_path} ---")
+    if not asr_pipeline:
+        return "Error: Audio transcription pipeline is not available."
+    try:
+        if not os.path.exists(file_path):
+            # GAIA questions might provide relative paths, so we check
+            if os.path.exists(os.path.basename(file_path)):
+                file_path = os.path.basename(file_path)
+            else:
+                return f"Error: File not found at {file_path}"
+        
+        # The pipeline handles file loading
+        transcription = asr_pipeline(file_path)
+        print("--- Transcription Complete ---")
+        return transcription["text"]
+    except Exception as e:
+        return f"Error during audio transcription: {str(e)}"
+
+@tool
+def get_youtube_transcript(video_url: str) -> str:
+    """
+    Fetches the transcript for a given YouTube video URL.
+    """
+    print(f"--- Calling YouTube Transcript Tool for URL: {video_url} ---")
+    try:
+        # Extract video ID from URL
+        video_id = video_url.split("v=")[1].split("&")[0]
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+        
+        # Combine all transcript parts into one string
+        full_transcript = " ".join([item["text"] for item in transcript_list])
+        print("--- Transcript Fetched ---")
+        return full_transcript
+    except Exception as e:
+        return f"Error fetching YouTube transcript: {str(e)}"
+
+@tool
+def scrape_web_page(url: str) -> str:
+    """
+    Fetches the full text content of a given web page URL.
+    """
+    print(f"--- Calling Web Scraper Tool for URL: {url} ---")
+    try:
+        response = requests.get(url, headers={'User-Agent': 'Mozilla/5.0'}, timeout=10)
+        response.raise_for_status() # Raise an error for bad responses
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        # Remove script/style tags
+        for script in soup(["script", "style", "nav", "footer", "aside"]):
+            script.extract()
+            
+        text = soup.get_text()
+        
+        # Clean up whitespace
+        lines = (line.strip() for line in text.splitlines())
+        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+        text = '\n'.join(chunk for chunk in chunks if chunk)
+        print("--- Web Page Scraped ---")
+        return text[:8000] # Return first 8000 chars to avoid overload
+    except Exception as e:
+        return f"Error scraping web page: {str(e)}"
+
+# --- End of Tool Definitions ---
+
+
+# --- LangGraph Agent State ---
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
+    
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("BasicAgent (LangGraph) initialized.")
+        
+        # 1. Get API Token from Space Secrets
+        # Go to your Space's Settings -> Secrets and add HUGGINGFACEHUB_API_TOKEN
+        HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+        if not HUGGINGFACEHUB_API_TOKEN:
+            raise ValueError("HUGGINGFACEHUB_API_TOKEN secret is not set! Please add it to your Space secrets.")
+
+        # 2. Initialize Tools
+        self.tools = [
+            search_tool,
+            code_interpreter,
+            read_file,
+            write_file,
+            list_directory,
+            audio_transcription_tool,
+            get_youtube_transcript,
+            scrape_web_page
+        ]
+        
+        # 3. Initialize the LLM
+        # We wrap HuggingFaceEndpoint in ChatHuggingFace for LangChain compatibility
+        llm = HuggingFaceEndpoint(
+            repo_id="HuggingFaceH4/zephyr-7b-beta", # A good, fast model for tool use
+            # repo_id="Qwen/Qwen2.5-Coder-32B-Instruct", # Your chosen model
+            huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN,
+            max_new_tokens=1500,
+            temperature=0.1,
+        )
+        chat_llm = ChatHuggingFace(llm=llm)
+
+        # 4. Bind tools to the LLM
+        self.llm_with_tools = chat_llm.bind_tools(self.tools)
+
+        # 5. Define the Agent Node
+        def agent_node(state: AgentState):
+            print("--- Running Agent Node ---")
+            ai_message = self.llm_with_tools.invoke(state["messages"])
+            print(f"AI Message: {ai_message.pretty_repr()}")
+            return {"messages": [ai_message]}
+
+        # 6. Define the Tool Node
+        tool_node = ToolNode(self.tools)
+        
+        # 7. Create the Graph
+        graph_builder = StateGraph(AgentState)
+        
+        # Add the nodes
+        graph_builder.add_node("agent", agent_node)
+        graph_builder.add_node("tools", tool_node)
+        
+        # Define the edges
+        graph_builder.add_edge(START, "agent")
+        
+        # Add the conditional edge
+        graph_builder.add_conditional_edges(
+            "agent",
+            tools_condition,
+            {
+                "tools": "tools",
+                "__end__": "__end__",
+            },
+        )
+        graph_builder.add_edge("tools", "agent")
+        
+        # 8. Compile the graph and store it
+        self.graph = graph_builder.compile()
+        print("Graph compiled successfully with all tools.")
+
     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
+        
+        # Prepare the input for the graph
+        graph_input = {"messages": [HumanMessage(content=question)]}
+        
+        final_answer = ""
+        
+        # Stream the graph's execution
+        try:
+            # We use stream_mode="values" to get the full state at each step
+            for event in self.graph.stream(graph_input, stream_mode="values"):
+                last_message = event["messages"][-1]
+                
+                # Update the final answer with the latest AI message
+                if isinstance(last_message, AIMessage):
+                    if last_message.content:
+                        print(f"AI: {last_message.content[:200]}...")
+                        final_answer = last_message.content
+                elif isinstance(last_message, ToolMessage):
+                     print(f"Tool Result: {last_message.content[:200]}...")
+
+            print(f"Agent returning final answer: {final_answer}")
+            return final_answer
+        
+        except Exception as e:
+            print(f"Error running agent graph: {e}")
+            return f"AGENT ERROR: {e}"
+
+
+# --- (Original Template Code Starts Here) ---
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -26,27 +307,29 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
-
     if profile:
         username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
-
+    
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
     # 1. Instantiate Agent ( modify this part to create your agent)
+    print("Initializing agent...")
     try:
         agent = BasicAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
+    print("Agent initialized successfully.")
+
     # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
+    print(f"Agent code URL: {agent_code}")
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
@@ -73,20 +356,27 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
+    
+    # Set a limit for testing. Remove '[:question_limit]' for the full submission.
+    # question_limit = 10 
+    
+    for item in questions_data: # [:question_limit]: # Using limit here
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+        
+        print(f"\n--- Running Task {task_id} ---")
         try:
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            print(f"--- Task {task_id} Complete ---")
         except Exception as e:
              print(f"Error running agent on task {task_id}: {e}")
              results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
-
+    
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
@@ -139,33 +429,27 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
-
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
     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).
         This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
         """
     )
-
     gr.LoginButton()
-
     run_button = gr.Button("Run Evaluation & Submit All Answers")
-
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
+    
     run_button.click(
         fn=run_and_submit_all,
         outputs=[status_output, results_table]
@@ -173,24 +457,25 @@ with gr.Blocks() as demo:
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
+    
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
     space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
-
+    
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
         print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-
+    
     if space_id_startup: # Print repo URLs if SPACE_ID is found
         print(f"✅ SPACE_ID found: {space_id_startup}")
         print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
         print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
     else:
         print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-
+    
     print("-"*(60 + len(" App Starting ")) + "\n")
-
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)
+

requirements.txt

@@ -1,2 +1,15 @@
 gradio
-requests
+requests
+pandas
+langchain
+langgraph
+langchain-huggingface
+langchain-community
+duckduckgo-search
+torch
+transformers
+torchaudio
+librosa
+youtube-transcript-api
+beautifulsoup4
+openpyxl