Update app.py

app.py

@@ -4,107 +4,76 @@ import requests
 import pandas as pd
 from huggingface_hub import InferenceClient
 from duckduckgo_search import DDGS
-from datasets import load_dataset
 import wikipediaapi
-from llama_index.core import VectorStoreIndex, Document, StorageContext, load_index_from_storage
-from llama_index.llms.huggingface import HuggingFaceLLM
 
+# ==== CONFIG ====
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-llm_model_id = "deepseek-ai/DeepSeek-V2"
-llm_fallback_id = "mistralai/Mistral-7B-Instruct-v0.2"
-
-# Setup HF LLM client
-hf_client = InferenceClient(llm_model_id, token=HF_TOKEN)
-hf_fallback = InferenceClient(llm_fallback_id, token=HF_TOKEN)
-
-# Wikipedia API with user agent
-wiki_api = wikipediaapi.Wikipedia(
-    language='en',
-    user_agent='SmartAgent/1.0 ([email protected])'
-)
-
-# Build or load LlamaIndex for fast retrieval (optional, for small Wikipedia sample)
-try:
-    wiki_dataset = load_dataset("wikipedia", "20220301.en", split="train[:5000]", trust_remote_code=True)
-    docs = [Document(text=doc['text']) for doc in wiki_dataset]
-    index = VectorStoreIndex.from_documents(docs)
-except Exception as e:
-    index = None
+HF_TOKEN = os.getenv("HF_TOKEN")
 
+CONVERSATIONAL_MODELS = [
+    "deepseek-ai/DeepSeek-LLM",
+    "HuggingFaceH4/zephyr-7b-beta",
+    "mistralai/Mistral-7B-Instruct-v0.2"
+]
+
+wiki_api = wikipediaapi.Wikipedia(language="en", user_agent="SmartAgent/1.0 ([email protected])")
+
+# ==== SEARCH TOOLS ====
 def duckduckgo_search(query):
     with DDGS() as ddgs:
         results = [r for r in ddgs.text(query, max_results=3)]
-        return "\n".join([r["body"] for r in results if r.get("body")]) or "No results found."
+        return "\n".join([r.get("body", "") for r in results if r.get("body")]) or "No DuckDuckGo results found."
 
 def wikipedia_search(query):
     page = wiki_api.page(query)
-    return page.summary if page.exists() else None
-
-def index_search(query):
-    if index is None:
-        return None
-    res = index.as_query_engine().query(query)
-    return str(res) if res else None
-
-def handle_excel(file_url):
-    # Download and sum food (not drinks)
-    try:
-        fname = "tmp.xlsx"
-        r = requests.get(file_url)
-        with open(fname, "wb") as f:
-            f.write(r.content)
-        df = pd.read_excel(fname)
-        # Assume drinks have 'drink' or 'beverage' in a column called 'Item' or 'Category'
-        if "Item" in df.columns:
-            food_df = df[~df["Item"].str.contains("drink|beverage", case=False, na=False)]
-            total = food_df["Total"].sum()
-            return f"${total:.2f}"
-        if "Category" in df.columns:
-            food_df = df[df["Category"].str.lower() == "food"]
-            total = food_df["Total"].sum()
-            return f"${total:.2f}"
-        return "File parsed but could not find food sales."
-    except Exception as e:
-        return f"Excel error: {e}"
+    return page.summary if page.exists() and page.summary else "No Wikipedia page found."
 
+def hf_chat_model(question):
+    last_error = ""
+    for model_id in CONVERSATIONAL_MODELS:
+        try:
+            hf_client = InferenceClient(model_id, token=HF_TOKEN)
+            result = hf_client.conversational(
+                messages=[{"role": "user", "content": question}],
+                max_new_tokens=384,
+            )
+            # Acceptable result types: dict, obj with 'generated_text', or str
+            if isinstance(result, dict) and "generated_text" in result:
+                return f"[{model_id}] " + result["generated_text"]
+            elif hasattr(result, "generated_text"):
+                return f"[{model_id}] " + result.generated_text
+            elif isinstance(result, str):
+                return f"[{model_id}] " + result
+            else:
+                return f"[{model_id}] " + str(result)
+        except Exception as e:
+            last_error = f"({model_id}) {e}"
+    return f"HF LLM error: {last_error}"
+
+# ==== SMART AGENT ====
 class SmartAgent:
     def __init__(self):
         pass
 
     def __call__(self, question: str) -> str:
         q_lower = question.lower()
-
-        # DuckDuckGo for current events/recent/live
-        if any(term in q_lower for term in ["current", "latest", "2024", "2025", "who is the president", "recent", "live"]):
-            return duckduckgo_search(question)
-
-        # Wikipedia summary
+        # DuckDuckGo for current/event/internet questions
+        if any(term in q_lower for term in ["current", "latest", "2024", "2025", "who is the president", "recent", "live", "now", "today"]):
+            duck_result = duckduckgo_search(question)
+            if duck_result and "No DuckDuckGo" not in duck_result:
+                return duck_result
+        # Wikipedia for encyclopedic knowledge
         wiki_result = wikipedia_search(question)
-        if wiki_result:
+        if wiki_result and "No Wikipedia page found" not in wiki_result:
             return wiki_result
+        # Fallback to LLMs
+        return hf_chat_model(question)
 
-        # LlamaIndex retrieval
-        rag_result = index_search(question)
-        if rag_result:
-            return rag_result
-
-        # LLM generation
-        try:
-            resp = hf_client.text_generation(question, max_new_tokens=256)
-            return resp
-        except Exception:
-            try:
-                resp = hf_fallback.text_generation(question, max_new_tokens=256)
-                return resp
-            except Exception as e:
-                return f"HF LLM error: {e}"
-
+# ==== SUBMISSION LOGIC ====
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
     if profile:
         username = profile.username
-        print(f"User logged in: {username}")
     else:
         return "Please Login to Hugging Face with the button.", None
 
@@ -128,17 +97,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        file_url = item.get("file_url", None)
         if not task_id or not question_text:
             continue
-
-        # Handle Excel task
-        if file_url and ("excel" in question_text.lower() or "file" in question_text.lower()):
-            submitted_answer = handle_excel(file_url)
-        else:
-            submitted_answer = agent(question_text)
-
-        # Final answer extraction/formatting if needed (TODO: Add regex/extract logic)
+        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})
 
@@ -146,7 +107,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
 
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
@@ -164,7 +124,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     except Exception as e:
         return f"Submission Failed: {e}", pd.DataFrame(results_log)
 
-# Gradio interface
+# ==== GRADIO UI ====
 with gr.Blocks() as demo:
     gr.Markdown("# Smart Agent Evaluation Runner")
     gr.Markdown("""
@@ -177,6 +137,7 @@ with gr.Blocks() as demo:
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":