test 2

app.py

@@ -3,21 +3,39 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from myagent_langraph import build_graph 
+from dotenv import load_dotenv
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
 
-# (Keep Constants as is)
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+# Charger les variables d'environnement depuis le fichier .env
+load_dotenv()
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
+class WalidzAgent:
+    """A langgraph agent."""
     def __init__(self):
         print("BasicAgent initialized.")
+        self.graph = build_graph()
+
     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
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        # Find the last occurrence of "FINAL ANSWER:" in the response
+        if "FINAL ANSWER:" in answer:
+            # Split by "FINAL ANSWER:" and take the last part
+            final_answer_parts = answer.split("FINAL ANSWER:")
+            answer = final_answer_parts[-1].strip()
+        else:
+            # If "FINAL ANSWER:" is not found, return the original answer
+            print("Warning: 'FINAL ANSWER:' not found in response")
+        return answer
+
+# (Keep Constants as is)
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -40,7 +58,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = WalidzAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -73,7 +91,7 @@ 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:
+    for item in questions_data[0:1]:
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
@@ -141,6 +159,70 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             return status_message, results_df
             
 
+def run_evaluation_only(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, but does not submit answers.
+    Only displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID")
+
+    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"
+
+    # 1. Instantiate Agent
+    try:
+        agent = WalidzAgent()
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+        print(f"Error decoding JSON response from questions endpoint: {e}")
+        print(f"Response text: {response.text[:500]}")
+        return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    for item in questions_data[0:1]:
+        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
+        try:
+            submitted_answer = agent(question_text)
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+        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}"})
+
+    results_df = pd.DataFrame(results_log)
+    return "Evaluation completed. Answers not submitted.", results_df
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
@@ -151,7 +233,8 @@ with gr.Blocks() as demo:
 
         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.
+        3.  Click 'Run Evaluation (& Submit All Answers)' to fetch questions, run your agent, submit answers, and see the score.
+        4.  Click 'Run Evaluation Only' to test your agent without submitting answers.
 
         ---
         **Disclaimers:**
@@ -162,10 +245,11 @@ with gr.Blocks() as demo:
 
     gr.LoginButton()
 
-    run_button = gr.Button("Run Evaluation (& Submit All Answers)")
+    with gr.Row():
+        run_button = gr.Button("Run Evaluation (& Submit All Answers)")
+        run_eval_only_button = gr.Button("Run Evaluation Only")
 
     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(
@@ -173,6 +257,11 @@ with gr.Blocks() as demo:
         outputs=[status_output, results_table]
     )
 
+    run_eval_only_button.click(
+        fn=run_evaluation_only,
+        outputs=[status_output, results_table]
+    )
+
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information

myagent_langraph.py

@@ -0,0 +1,253 @@
+import base64
+from typing import List, TypedDict, Annotated, Optional
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
+from langgraph.graph.message import add_messages
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+from IPython.display import Image, display
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+from dotenv import load_dotenv
+import os
+import sys
+
+# Do not modify stdout/stdin as it can cause issues
+import codecs
+
+# Load environment variables
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+# Validate API key
+if not OPENAI_API_KEY:
+    print("Warning: OPENAI_API_KEY environment variable not found or empty!")
+
+class AgentState(TypedDict):
+    # The document provided
+    question_text: Optional[str]
+    messages: Annotated[list[AnyMessage], add_messages]
+
+### TOOLS ###
+def search_wikipedia(query: str) -> str:
+    """Searches Wikipedia for a given query and returns maximum 1 results."""
+    try:
+        # Ensure query is properly encoded
+        if isinstance(query, bytes):
+            query = query.decode('utf-8')
+        
+        # Use WikipediaLoader with the encoded query
+        search_docs = WikipediaLoader(
+            query=query, 
+            load_max_docs=1, 
+            doc_content_chars_max=10000
+        ).load()
+        
+        # Format the results with proper encoding
+        formatted_docs = []
+        for doc in search_docs:
+            source = doc.metadata.get("source", "").encode('utf-8', errors='replace').decode('utf-8')
+            page = doc.metadata.get("page", "").encode('utf-8', errors='replace').decode('utf-8')
+            content = doc.page_content.encode('utf-8', errors='replace').decode('utf-8')
+            formatted_docs.append(
+                f'<Document source="{source}" page="{page}"/>\n{content}\n</Document>'
+            )
+        
+        return "\n\n---\n\n".join(formatted_docs)
+    except Exception as e:
+        print(f"Error in search_wikipedia: {e}")
+        return f"Error searching Wikipedia: {str(e)}"
+
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers.
+    Args:
+        a: first int
+        b: second int
+    """
+    return a * b
+
+def add(a: int, b: int) -> int:
+    """Add two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+def subtract(a: int, b: int) -> int:
+    """Subtract two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a - b
+
+def divide(a: int, b: int) -> int:
+    """Divide two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers.
+    
+    Args:
+        a: first int
+        b: second int
+    """
+    return a % b
+
+
+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}
+
+# Equip the butler with tools
+tools = [
+    multiply,
+    subtract,
+    add,
+    divide,
+    modulus,
+    search_wikipedia,
+    web_search
+]
+
+# Initialize the OpenAI model with explicit encoding parameters
+try:
+    # Use encoding='utf-8' to ensure proper handling of special characters
+    llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        openai_api_key=OPENAI_API_KEY,
+        default_headers={"Content-Type": "application/json; charset=utf-8"}
+    )
+    llm_with_tools = llm.bind_tools(tools, parallel_tool_calls=False)
+except Exception as e:
+    print(f"Error initializing OpenAI model: {e}")
+    raise
+
+#### THE NODES #####
+def assistant(state: AgentState):
+    try:
+        # Get the question text from state and ensure it's properly encoded
+        question = state.get("question_text", "")
+        
+        # Build the system prompt piece by piece
+        parts = [
+            "You are a helpful assistant tasked with answering questions using a set of tools.",
+            "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.",
+            
+            # Tool descriptions
+            "You can use these provided tools:",
+            "search_wikipedia(query: str) -> str:",
+            "    Searches Wikipedia for a given query and returns maximum 1 results.",
+            "divide(a: int, b: int) -> float:",
+            "    Divide a and b"
+        ]
+        
+        # Add the question
+        parts.append(f"The question you have to answer is: {question}")
+        
+        # Join all parts with newlines and ensure proper encoding
+        sys_prompt = "\n".join(parts).encode('utf-8', errors='replace').decode('utf-8')
+        
+        # Create system message with explicit encoding
+        sys_msg = SystemMessage(content=sys_prompt)
+        
+        # Invoke the model with proper error handling
+        messages = llm_with_tools.invoke([sys_msg] + state["messages"])
+        return {
+            "messages": messages,
+            "question_text": question
+        }
+    except Exception as e:
+        error_msg = f"Error in assistant node: {str(e)}"
+        print(error_msg)
+        return {
+            "messages": [SystemMessage(content=f"An error occurred: {error_msg}")],
+            "question_text": state.get("question_text", "")
+        }
+
+def build_graph():
+    # The graph
+    builder = StateGraph(AgentState)
+
+    # Define nodes: these do the work
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+
+    # Define edges: these determine how the control flow moves
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        # If the latest message requires a tool, route to tools
+        # Otherwise, provide a direct response
+        tools_condition,
+    )
+    builder.add_edge("tools", "assistant")
+    react_graph = builder.compile()
+    return react_graph
+
+
+if __name__ == "__main__":
+    react_graph = build_graph()
+    # Show the butler's thought process
+    # Save the graph visualization to disk
+    graph_image = react_graph.get_graph(xray=True).draw_mermaid_png()
+    with open("graph_visualization.png", "wb") as f:
+        f.write(graph_image)
+    print("Graph visualization saved to 'graph_visualization.png'")
+
+    # Also display it if in an environment that supports display
+    #display(Image(graph_image))
+
+
+    question_sample = "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia."
+    #question_sample = question_sample.encode('utf-8', errors='replace').decode('utf-8')
+
+    print("Running with sample question:", question_sample)
+
+    try:
+        # Create message with proper encoding
+        human_msg = HumanMessage(content=question_sample)
+        
+        # Prepare input state
+        input_state = {
+            "messages": [human_msg],
+            "question_text": question_sample
+        }
+        
+        # Invoke graph with proper encoding handling
+        print("Invoking graph...")
+        messages = react_graph.invoke(input_state)
+        
+        # Show the messages
+        for m in messages['messages']:
+            m.pretty_print()
+    except Exception as e:
+        print(f"Error in Agent execution: {str(e)}")
+        import traceback
+        traceback.print_exc()
+

requirements.txt

@@ -1,2 +1,7 @@
 gradio
-requests
+requests
+python-dotenv
+langchain
+langchain-community
+wikipedia
+smolagents