Update app.py

app.py

@@ -1,9 +1,5 @@
-"""Full Hugging Face Spaces app.py for GAIA agent – includes image analysis tool.
-Copy‑paste this file as‑is to your Space.
-Requires:
-  - openai>=1.7.0  (for vision)
-  - langchain, langchain-community, langgraph, gradio, pandas, requests, tavily-python, youtube-transcript-api
-  - PILLOW (installed automatically with Gradio)
+"""Full app.py with improved Excel-handling guidelines for GAIA agent.
+Copy/paste into your Hugging Face Space.
 """
 
 import os
@@ -14,7 +10,6 @@ import operator
 from typing import Sequence, Annotated, TypedDict
 
 from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
-from langchain.agents import AgentExecutor
 from langchain_experimental.tools import PythonREPLTool
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.tools.youtube.search import YouTubeSearchTool
@@ -22,83 +17,47 @@ from langchain_openai import ChatOpenAI
 from langgraph.graph import StateGraph
 from langgraph.prebuilt import ToolNode, tools_condition
 
-# ------------------------  Vision Tool  --------------------------------------
-
-from langchain_core.tools import tool
-
-@tool("image_analysis", return_direct=True)
-def image_analysis(image_path: str, prompt: str) -> str:
-    """Analyze an image located at `image_path` according to `prompt`.
-    Example call from LLM: image_analysis{"image_path": "/mnt/data/cat.png", "prompt": "How many cats?"}
-    Returns a textual answer.
-    """
-    import openai
-    from PIL import Image
-
-    if not os.path.exists(image_path):
-        return "Image path not found."
-
-    # Read image bytes
-    with open(image_path, "rb") as f:
-        img_bytes = f.read()
-
-    client = openai.OpenAI()
-    completion = client.chat.completions.create(
-        model="gpt-4o-mini",  # vision‑capable
-        messages=[
-            {
-                "role": "user",
-                "content": [
-                    {"type": "image", "image": img_bytes},
-                    {"type": "text", "text": prompt},
-                ],
-            }
-        ],
-    )
-    return completion.choices[0].message.content.strip()
-
-# ---------------------  LangGraph Agent  -------------------------------------
+# -----------------------  Agent Definition  ----------------------------------
 
 class AgentState(TypedDict):
     messages: Annotated[Sequence[BaseMessage], operator.add]
 
 SYSTEM_PROMPT = (
-    "You are a general AI assistant. I will ask you a question. Report your thoughts, "
-    "and finish your answer with the template:\nFINAL ANSWER: [YOUR FINAL ANSWER].\n\n"
-    "YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.\n"
-    "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.\n"
-    "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.\n"
-    "If you are asked for a comma separated list, apply the above rules depending on whether the element to be put in the list is a number or a string."
+    "You are a GAIA evaluation agent. For each question, think step‑by‑step, but only output the final answer with the template:\n"
+    "FINAL ANSWER: [YOUR FINAL ANSWER]\n\n"
+    "Formatting rules: Your FINAL ANSWER must be a single number, a single short string, or a comma‑separated list, as the task dictates. No extra words.\n\n"
+    "**IMPORTANT TOOL USAGE**:\n"
+    "• You have a PythonREPL tool with pandas pre‑installed. If the task references an Excel / CSV file path (e.g. .xlsx, .xls, .csv), do the following:\n"
+    "    1. Call PythonREPL and load the file with `pd.read_excel(<path>)` or `pd.read_csv(<path>)`.\n"
+    "    2. Use pandas operations (sum, mean, filtering etc.) to compute the required value.\n"
+    "    3. Return the numeric/string result in the FINAL ANSWER template.\n\n"
+    "• Use TavilySearchResults for web look‑ups, YouTubeSearchTool for video queries.\n"
+    "• If the task involves code execution or math, use PythonREPL.\n"
 )
 
 
-def create_langgraph_agent() -> AgentExecutor:
-    print("Initializing LangGraph GAIA agent…")
-
+def create_langgraph_agent():
     llm = ChatOpenAI(model="gpt-4o", temperature=0)
 
-    # Base tools
     tools = [
         TavilySearchResults(max_results=3),
         PythonREPLTool(),
         YouTubeSearchTool(),
-        image_analysis,
     ]
 
-    # Optional FileManagement tools
+    # Optional FileManagement toolkit
     try:
         from langchain_community.agent_toolkits.file_management.toolkit import FileManagementToolkit
         tools.extend(FileManagementToolkit(root_dir=".").get_tools())
-        print("FileManagement tools loaded.")
-    except Exception as e:
-        print("FileManagement toolkit unavailable:", e)
+    except Exception:
+        pass
 
     llm_with_tools = llm.bind_tools(tools)
 
     def agent_node(state: AgentState):
-        full_msgs = [SystemMessage(content=SYSTEM_PROMPT)] + list(state["messages"])
-        response = llm_with_tools.invoke(full_msgs)
-        return {"messages": [response]}
+        msgs = [SystemMessage(content=SYSTEM_PROMPT)] + list(state["messages"])
+        reply = llm_with_tools.invoke(msgs)
+        return {"messages": [reply]}
 
     graph = StateGraph(AgentState)
     graph.add_node("agent", agent_node)
@@ -107,85 +66,77 @@ def create_langgraph_agent() -> AgentExecutor:
     graph.add_conditional_edges("agent", tools_condition)
     graph.add_edge("tools", "agent")
 
-    executor = graph.compile()
-    print("LangGraph agent compiled.")
-    return executor
+    return graph.compile()
 
-# ---------------------  Helper to run one question ---------------------------
+# ------------------  Helper to run one question  -----------------------------
 
-def run_agent(agent_executor, question: str) -> str:
-    print("New question:", question)
+def run_agent(agent_exec, question: str) -> str:
     try:
-        result = agent_executor.invoke(
+        result = agent_exec.invoke(
             {"messages": [HumanMessage(content=question)]},
             config={"recursion_limit": 15},
         )
-        answer_raw = result["messages"][-1].content
-        return answer_raw.split("FINAL ANSWER:")[-1].strip() if "FINAL ANSWER:" in answer_raw else answer_raw
-    except Exception as err:
-        print("Execution error:", err)
-        return f"Error: {err}"
+        text = result["messages"][-1].content
+        return text.split("FINAL ANSWER:")[-1].strip() if "FINAL ANSWER:" in text else text
+    except Exception as e:
+        return f"Error: {e}"
 
-# ---------------------  Evaluation / Submission ----------------------------
+# ------------------  Evaluation & Submission  --------------------------------
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
     if not profile:
-        return "Please login via the button.", None
+        return "Please login first.", None
 
-    if not (os.getenv("TAVILY_API_KEY") and os.getenv("OPENAI_API_KEY")):
-        return "Missing API keys (TAVILY / OPENAI)", None
+    for key in ("OPENAI_API_KEY", "TAVILY_API_KEY"):
+        if not os.getenv(key):
+            return f"Missing {key} env var.", None
 
     try:
         agent_exec = create_langgraph_agent()
     except Exception as e:
-        return f"Error initializing agent: {e}", None
+        return f"Init error: {e}", None
 
-    QUESTIONS_URL = "https://agents-course-unit4-scoring.hf.space/questions"
-    SUBMIT_URL = "https://agents-course-unit4-scoring.hf.space/submit"
+    Q_URL = "https://agents-course-unit4-scoring.hf.space/questions"
+    S_URL = "https://agents-course-unit4-scoring.hf.space/submit"
 
     try:
-        q_resp = requests.get(QUESTIONS_URL, timeout=20)
-        q_resp.raise_for_status()
-        questions = q_resp.json()
+        questions = requests.get(Q_URL, timeout=20).json()
     except Exception as e:
-        return f"Error fetching questions: {e}", None
+        return f"Fetch error: {e}", None
 
     answers = []
-    for item in questions:
-        tid, qtext = item.get("task_id"), item.get("question")
-        if tid and qtext:
-            answers.append({"task_id": tid, "submitted_answer": run_agent(agent_exec, qtext)})
+    for q in questions:
+        if q.get("task_id") and q.get("question"):
+            answers.append({
+                "task_id": q["task_id"],
+                "submitted_answer": run_agent(agent_exec, q["question"]),
+            })
 
     payload = {
-        "username": profile.username.strip(),
-        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
+        "username": profile.username,
+        "agent_code": "HF_Space_Link",  # not required for scoring
         "answers": answers,
     }
 
     try:
-        s_resp = requests.post(SUBMIT_URL, json=payload, timeout=240)
-        s_resp.raise_for_status()
-        r = s_resp.json()
+        res = requests.post(S_URL, json=payload, timeout=240).json()
         status = (
-            f"Submission Successful!\nUser: {r.get('username')}\n"
-            f"Score: {r.get('score', 'N/A')}% ({r.get('correct_count', '?')}/{r.get('total_attempted', '?')})\n"
-            f"Message: {r.get('message', 'No message')}"
+            f"Score: {res.get('score', 'N/A')}% ({res.get('correct_count')}/" \
+            f"{res.get('total_attempted')})\nMessage: {res.get('message', '')}"
         )
         return status, pd.DataFrame(answers)
     except Exception as e:
-        return f"Error submitting answers: {e}", pd.DataFrame(answers)
+        return f"Submit error: {e}", pd.DataFrame(answers)
 
-# ------------------------  Gradio UI  ---------------------------------------
+# -----------------------------  UI  -----------------------------------------
 
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner (Vision‑enabled)")
+    gr.Markdown("# GAIA Agent Runner – Excel‑aware")
     gr.LoginButton()
-    run_btn = gr.Button("Run & Submit All Answers")
-    status_out = gr.Textbox(label="Run Status", lines=5, interactive=False)
-    table_out = gr.DataFrame(label="Questions / Answers", wrap=True)
-
-    run_btn.click(fn=run_and_submit_all, outputs=[status_out, table_out])
+    btn = gr.Button("Run & Submit")
+    out1 = gr.Textbox(label="Status", lines=4)
+    out2 = gr.DataFrame(label="Answers", wrap=True)
+    btn.click(fn=run_and_submit_all, outputs=[out1, out2])
 
 if __name__ == "__main__":
     demo.launch()