Update app.py

app.py

@@ -12,17 +12,19 @@ import pdfplumber
 # ==== CONFIG ====
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 HF_TOKEN = os.getenv("HF_TOKEN")
-GROK_API_KEY = os.getenv("GROK_API_KEY") 
 
+# SOTA models: for general and code queries
 CONVERSATIONAL_MODELS = [
-    "deepseek-ai/DeepSeek-LLM",
-    "HuggingFaceH4/zephyr-7b-beta",
-    "mistralai/Mistral-7B-Instruct-v0.2"
+    "deepseek-ai/DeepSeek-V2-Chat",
+    "Qwen/Qwen2-72B-Instruct",
+    "mistralai/Mixtral-8x22B-Instruct-v0.1",
+    "meta-llama/Meta-Llama-3-70B-Instruct"
 ]
+CODING_MODEL = "deepseek-ai/DeepSeek-Coder-33B-Instruct"
 
 wiki_api = wikipediaapi.Wikipedia(language="en", user_agent="SmartAgent/1.0 (chockqoteewy@gmail.com)")
 
-# ==== UTILITY: Link/file detection ====
+# ==== UTILITIES ====
 def extract_links(text):
     url_pattern = re.compile(r'(https?://[^\s\)\],]+)')
     return url_pattern.findall(text or "")
@@ -40,36 +42,26 @@ def download_file(url, out_dir="tmp_files"):
     except Exception:
         return None
 
-# ==== File/Link Analyzers ====
 def analyze_file(file_path):
-    if file_path.endswith((".xlsx", ".xls")):
-        try:
+    try:
+        if file_path.endswith((".xlsx", ".xls")):
             df = pd.read_excel(file_path)
             return f"Excel summary: {df.head().to_markdown(index=False)}"
-        except Exception as e:
-            return f"Excel error: {e}"
-    elif file_path.endswith(".csv"):
-        try:
+        elif file_path.endswith(".csv"):
             df = pd.read_csv(file_path)
             return f"CSV summary: {df.head().to_markdown(index=False)}"
-        except Exception as e:
-            return f"CSV error: {e}"
-    elif file_path.endswith(".pdf"):
-        try:
+        elif file_path.endswith(".pdf"):
             with pdfplumber.open(file_path) as pdf:
                 first_page = pdf.pages[0].extract_text()
                 return f"PDF text sample: {first_page[:1000]}"
-        except Exception as e:
-            return f"PDF error: {e}"
-    elif file_path.endswith(".txt"):
-        try:
+        elif file_path.endswith(".txt"):
             with open(file_path, encoding='utf-8') as f:
                 txt = f.read()
             return f"TXT file sample: {txt[:1000]}"
-        except Exception as e:
-            return f"TXT error: {e}"
-    else:
-        return f"Unsupported file type: {file_path}"
+        else:
+            return f"Unsupported file type: {file_path}"
+    except Exception as e:
+        return f"File analysis error: {e}"
 
 def analyze_webpage(url):
     try:
@@ -82,7 +74,6 @@ def analyze_webpage(url):
     except Exception as e:
         return f"Webpage error: {e}"
 
-# ==== SEARCH TOOLS ====
 def duckduckgo_search(query):
     try:
         with DDGS() as ddgs:
@@ -101,39 +92,6 @@ def wikipedia_search(query):
         return None
     return None
 
-def llm_conversational(query):
-    last_error = None
-    for model_id in CONVERSATIONAL_MODELS:
-        try:
-            hf_client = InferenceClient(model_id, token=HF_TOKEN)
-            # Try conversational if available, else fallback to text_generation
-            if hasattr(hf_client, "conversational"):
-                try:
-                    result = hf_client.conversational(
-                        messages=[{"role": "user", "content": query}],
-                        max_new_tokens=384,
-                    )
-                    if isinstance(result, dict) and "generated_text" in result:
-                        return result["generated_text"]
-                    elif hasattr(result, "generated_text"):
-                        return result.generated_text
-                    elif isinstance(result, str):
-                        return result
-                except Exception:
-                    pass
-            # Fallback to text_generation
-            try:
-                result = hf_client.text_generation(query, max_new_tokens=384)
-                if isinstance(result, dict) and "generated_text" in result:
-                    return result["generated_text"]
-                elif isinstance(result, str):
-                    return result
-            except Exception:
-                pass
-        except Exception as e:
-            last_error = f"{model_id}: {e}"
-    return None
-
 def is_coding_question(text):
     code_terms = [
         "python", "java", "c++", "code", "function", "write a", "script", "algorithm",
@@ -145,28 +103,31 @@ def is_coding_question(text):
         return True
     return False
 
-def grok_completion(question, system_prompt=None):
-    url = "https://api.x.ai/v1/chat/completions"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {GROK_API_KEY}"
-    }
-    payload = {
-        "messages": [
-            {"role": "system", "content": system_prompt or "You are a helpful coding and research assistant."},
-            {"role": "user", "content": question}
-        ],
-        "model": "grok-3-latest",
-        "stream": False,
-        "temperature": 0
-    }
+def llm_coder(query):
     try:
-        r = requests.post(url, headers=headers, json=payload, timeout=45)
-        r.raise_for_status()
-        data = r.json()
-        return data['choices'][0]['message']['content']
-    except Exception:
-        return None
+        hf_client = InferenceClient(CODING_MODEL, token=HF_TOKEN)
+        result = hf_client.text_generation(query, max_new_tokens=1024)
+        if isinstance(result, dict) and "generated_text" in result:
+            return f"[{CODING_MODEL}] {result['generated_text']}"
+        elif isinstance(result, str):
+            return f"[{CODING_MODEL}] {result}"
+        return "Unknown result format from coder model."
+    except Exception as e:
+        return f"Coder Model Error: {e}"
+
+def llm_conversational(query):
+    last_error = None
+    for model_id in CONVERSATIONAL_MODELS:
+        try:
+            hf_client = InferenceClient(model_id, token=HF_TOKEN)
+            result = hf_client.text_generation(query, max_new_tokens=512)
+            if isinstance(result, dict) and "generated_text" in result:
+                return f"[{model_id}] {result['generated_text']}"
+            elif isinstance(result, str):
+                return f"[{model_id}] {result}"
+        except Exception as e:
+            last_error = f"{model_id}: {e}"
+    return f"LLM Error (all advanced models): {last_error or 'Unknown error'}"
 
 # ==== SMART AGENT ====
 class SmartAgent:
@@ -191,31 +152,28 @@ class SmartAgent:
             if results:
                 return "\n\n".join(results)
 
-        # 2. Coding or algorithmic problems? Try Grok FIRST
+        # 2. Code/coding questions: use coder model
         if is_coding_question(question):
-            grok_response = grok_completion(question)
-            if grok_response:
-                return f"[Grok] {grok_response}"
+            result = llm_coder(question)
+            if result:
+                return result
 
-        # 3. DuckDuckGo for web knowledge
+        # 3. DuckDuckGo for fresh web results
         result = duckduckgo_search(question)
         if result:
             return result
-        # 4. Wikipedia for encyclopedic queries
+
+        # 4. Wikipedia for encyclopedic facts
         result = wikipedia_search(question)
         if result:
             return result
-        # 5. Grok again for hard/reasoning/general (if not already tried)
-        if not is_coding_question(question):
-            grok_response = grok_completion(question)
-            if grok_response:
-                return f"[Grok] {grok_response}"
 
-        # 6. Fallback to LLM conversational
+        # 5. General QA, reasoning, or fallback: conversational SOTA models
         result = llm_conversational(question)
         if result:
             return result
-        return "No answer could be found by available tools."
+
+        return "No answer could be found by available models."
 
 # ==== SUBMISSION LOGIC ====
 def run_and_submit_all(profile: gr.OAuthProfile | None):