Update agent.py

agent.py

@@ -1,114 +1,171 @@
-""" Basic Agent Evaluation Runner – invia sempre tutte le risposte """
-
-import os
-import requests
-import gradio as gr
-import pandas as pd
-from langchain_core.messages import HumanMessage
-from agent import build_graph
-
-
-# --- Constants ------------------------------------------------------------ #
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-
-# --- Agent wrapper -------------------------------------------------------- #
-class BasicAgent:
-    """LangGraph agent ready for evaluation."""
-    def __init__(self):
-        print("BasicAgent initialized (provider=groq).")
-        self.graph = build_graph(provider="groq")
-
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        msgs = [HumanMessage(content=question)]
-        result = self.graph.invoke({"messages": msgs})
-        answer = result["messages"][-1].content
-        # rimuove la parte "FINAL ANSWER: "
-        return answer[14:]
-
-
-# --- Main evaluation logic ------------------------------------------------ #
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    # 0. Check login
-    if not profile:
-        return "Please Login to Hugging Face with the button.", None
-    username = profile.username
-    print(f"User logged in: {username}")
-
-    # 1. Instantiate agent
-    try:
-        agent = BasicAgent()
-    except Exception as e:
-        return f"Error initializing agent: {e}", None
-
-    # 2. Fetch questions
-    try:
-        resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
-        resp.raise_for_status()
-        questions_data = resp.json()
-        if not questions_data:
-            return "Fetched questions list is empty.", None
-    except Exception as e:
-        return f"Error fetching questions: {e}", None
-
-    # 3. Run agent and build payload
-    answers_payload = []
-    results_log = []
-
-    for item in questions_data:
-        task_id = item.get("task_id")
-        q_text = item.get("question")
-
-        submitted_answer = "errore"  # default in caso di failure
-        try:
-            submitted_answer = agent(q_text)
-        except Exception as e:
-            print(f"Error running agent on task {task_id}: {e}")
-
-        # in ogni caso inseriamo la risposta (successo o errore)
-        answers_payload.append(
-            {"task_id": task_id, "submitted_answer": submitted_answer}
-        )
-        results_log.append(
-            {
-                "Task ID": task_id,
-                "Question": q_text,
-                "Submitted Answer": submitted_answer,
-            }
+"""LangGraph Agent – retry 5s, 30s, 60s; senza Supabase"""
+
+import os, time
+from dotenv import load_dotenv
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode, tools_condition
+
+# LLM providers
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+
+# Tools & loaders
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool
+
+load_dotenv()
+
+# --------------------------------------------------------------------------- #
+#  TOOLS                                                                      #
+# --------------------------------------------------------------------------- #
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers and return the product."""
+    return a * b
+
+@tool
+def add(a: int, b: int) -> int:
+    """Add two integers and return the sum."""
+    return a + b
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """Subtract the second integer from the first and return the difference."""
+    return a - b
+
+@tool
+def divide(a: int, b: int) -> float:
+    """Divide a by b and return the quotient (error if b == 0)."""
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Return the remainder of the division of a by b."""
+    return a % b
+
+@tool
+def wiki_search(query: str) -> str:
+    """Search Wikipedia (max 2 docs) and return formatted content."""
+    docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    return "\n\n---\n\n".join(
+        f'<Document source="{d.metadata["source"]}" page="{d.metadata.get("page","")}"/>\n'
+        f"{d.page_content}\n</Document>"
+        for d in docs
+    )
+
+@tool
+def web_search(query: str) -> str:
+    """Perform a web search with Tavily (max 3 docs) and return formatted content."""
+    docs = TavilySearchResults(max_results=3).invoke(query=query)
+    return "\n\n---\n\n".join(
+        f'<Document source="{d.metadata["source"]}" page="{d.metadata.get("page","")}"/>\n'
+        f"{d.page_content}\n</Document>"
+        for d in docs
+    )
+
+@tool
+def arxiv_search(query: str) -> str:
+    """Search ArXiv (max 3 docs) and return first 1000 characters per paper."""
+    docs = ArxivLoader(query=query, load_max_docs=3).load()
+    return "\n\n---\n\n".join(
+        f'<Document source="{d.metadata["source"]}" page="{d.metadata.get("page","")}"/>\n'
+        f"{d.page_content[:1000]}\n</Document>"
+        for d in docs
+    )
+
+# --------------------------------------------------------------------------- #
+#  System prompt                                                              #
+# --------------------------------------------------------------------------- #
+with open("system_prompt.txt", "r", encoding="utf-8") as f:
+    system_prompt = f.read()
+sys_msg = SystemMessage(content=system_prompt)
+
+tools = [
+    multiply, add, subtract, divide, modulus,
+    wiki_search, web_search, arxiv_search,
+]
+
+# --------------------------------------------------------------------------- #
+#  Retry parameters                                                           #
+# --------------------------------------------------------------------------- #
+RETRY_DELAYS = [0, 5, 30, 60]        # secondi: tentativo 0, 1, 2, 3
+MAX_ATTEMPTS = len(RETRY_DELAYS)
+
+# --------------------------------------------------------------------------- #
+#  Build LangGraph                                                            #
+# --------------------------------------------------------------------------- #
+def build_graph(provider: str = "groq"):
+    """Return a LangGraph graph with explicit retry logic (5s, 30s, 60s)."""
+
+    # ----------- LLM selection -------------------------------------------- #
+    if provider == "google":
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+
+    elif provider == "groq":
+        llm = ChatGroq(
+            model="qwen-qwq-32b",
+            temperature=0,
+            max_retries=0,      # disabilitiamo i retry interni
         )
 
-    # 4. Submit answers
-    submission = {
-        "username": username,
-        "agent_code": f"https://huggingface.co/spaces/{os.getenv('SPACE_ID', '')}/tree/main",
-        "answers": answers_payload,
-    }
-
-    try:
-        resp = requests.post(f"{DEFAULT_API_URL}/submit", json=submission, timeout=60)
-        resp.raise_for_status()
-        data = resp.json()
-        status_msg = (
-            f"Submission Successful!\nUser: {data.get('username')}\n"
-            f"Overall Score: {data.get('score', 'N/A')}% "
-            f"({data.get('correct_count', '?')}/{data.get('total_attempted', '?')} correct)\n"
-            f"Message: {data.get('message', 'No message received.')}"
+    elif provider == "huggingface":
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                url="https://api-inference.huggingface.co/models/Meta-DeepLearning/llama-2-7b-chat-hf",
+                temperature=0,
+            )
         )
-    except Exception as e:
-        status_msg = f"Submission Failed: {e}"
-
-    return status_msg, pd.DataFrame(results_log)
-
-
-# --- Gradio UI ------------------------------------------------------------ #
-with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner (retry & error-safe)")
-    gr.LoginButton()
-    run_btn = gr.Button("Run Evaluation & Submit All Answers")
-    status_box = gr.Textbox(lines=5, label="Run Status / Submission Result")
-    results_tbl = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-    run_btn.click(fn=run_and_submit_all, outputs=[status_box, results_tbl])
-
+    else:
+        raise ValueError("Invalid provider. Choose 'google', 'groq' or 'huggingface'.")
+
+    llm_with_tools = llm.bind_tools(tools)
+
+    # ---------------- Retry wrapper -------------------------------------- #
+    def invoke_with_retry(messages):
+        last_err = None
+        for attempt, delay in enumerate(RETRY_DELAYS):
+            if delay > 0:
+                print(f"[Retry {attempt}/{MAX_ATTEMPTS-1}] waiting {delay}s")
+                time.sleep(delay)
+            try:
+                return llm_with_tools.invoke(messages)
+            except Exception as e:
+                err_text = str(e)
+                if ("503" in err_text or "Service Unavailable" in err_text) and attempt < MAX_ATTEMPTS - 1:
+                    last_err = e
+                    continue   # passa al prossimo tentativo
+                raise  # altro errore o ultimi tentativo esaurito
+        # se per qualche motivo esce dal loop senza raise
+        raise last_err or RuntimeError("Unknown error during LLM invocation")
+
+    # ---------------- Nodes ---------------------------------------------- #
+    def assistant(state: MessagesState):
+        messages = [sys_msg] + state["messages"]
+        return {"messages": [invoke_with_retry(messages)]}
+
+    # ---------------- Graph ---------------------------------------------- #
+    builder = StateGraph(MessagesState)
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges("assistant", tools_condition)
+    builder.add_edge("tools", "assistant")
+
+    return builder.compile()
+
+# --------------------------------------------------------------------------- #
+#  Test rapido                                                                #
+# --------------------------------------------------------------------------- #
 if __name__ == "__main__":
-    demo.launch(debug=True, share=False)
+    g = build_graph(provider="groq")
+    q = "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect?"
+    msgs = [HumanMessage(content=q)]
+    res = g.invoke({"messages": msgs})
+    for m in res["messages"]:
+        m.pretty_print()