Update app.py

app.py

@@ -7,14 +7,13 @@ import google.generativeai as genai
 from sentence_transformers import SentenceTransformer, util
 
 # ============================================================
-# CONFIG - DO NOT LEAK YOUR KEY!
+# CONFIG
 # ============================================================
-# Best practice: use os.environ.get("GEMINI_API_KEY") 
 GEMINI_API_KEY = "AIzaSyBrbLGXkSdXReb0lUucYqcNCNBkvS-RBFw" 
 genai.configure(api_key=GEMINI_API_KEY)
 
-# Use 1.5-flash for maximum stability on Free Tier
-MODEL = genai.GenerativeModel("gemini-1.5-flash") 
+# UPDATED: Use a supported 2026 model
+MODEL = genai.GenerativeModel("gemini-2.5-flash") 
 
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
@@ -25,86 +24,71 @@ embedder = SentenceTransformer(EMBED_MODEL, device=DEVICE)
 print("✅ Ready")
 
 # ============================================================
-# OPTIMIZED PIPELINE (ONE CALL ONLY)
+# LOGIC
 # ============================================================
-def get_rubric_and_intent(kb, question):
-    """Combines intent detection and rubric generation to save API quota."""
+def get_evaluation_data(kb, question):
+    """Gets both intent and rubric in one single API request."""
     prompt = f"""
-    You are an expert examiner. Analyze the provided Knowledge Base and Question.
+    Acting as an examiner, analyze the Knowledge Base (KB) and Question.
+    1. Determine the intent (FACTUAL, EXPLANATORY, PROCESS, or COMPARISON).
+    2. Create a rubric of 3-5 atomic grading criteria based ONLY on the KB.
     
-    1. Classify the intent: FACTUAL, EXPLANATORY, CHARACTER_ARC, PROCESS, or COMPARISON.
-    2. Create a grading rubric of 3-6 atomic criteria based ONLY on the Knowledge Base.
-
-    Knowledge Base: {kb}
+    KB: {kb}
     Question: {question}
 
-    STRICT JSON OUTPUT ONLY:
+    OUTPUT JSON ONLY:
     {{
-      "intent": "YOUR_LABEL",
-      "criteria": ["criterion 1", "criterion 2", ...]
+      "intent": "LABEL",
+      "criteria": ["criterion 1", "criterion 2"]
     }}
     """
     try:
         response = MODEL.generate_content(prompt)
-        # Handle potential safety blocks or empty responses
-        if not response.candidates or not response.candidates[0].content.parts:
-            return {"intent": "ERROR", "criteria": []}
-            
-        text = response.text.strip()
-        # Clean JSON if model adds markdown backticks
-        text = re.sub(r'^```json\s*|\s*```$', '', text, flags=re.MULTILINE)
-        return json.loads(text)
+        # Handle cases where model might wrap JSON in backticks
+        clean_text = re.sub(r'```json|```', '', response.text).strip()
+        return json.loads(clean_text)
     except Exception as e:
         print(f"API Error: {e}")
-        return {"intent": "EXPLANATORY", "criteria": []}
+        return {"intent": "ERROR", "criteria": []}
 
 def evaluate(answer, question, kb):
-    # STEP 1: Get logic from Gemini (Single Call)
-    data = get_rubric_and_intent(kb, question)
-    intent = data.get("intent", "EXPLANATORY")
+    # API Call
+    data = get_evaluation_data(kb, question)
     rubric = data.get("criteria", [])
     
     if not rubric:
-        return {"final_verdict": "⚠️ API ERROR: No rubric generated."}
+        return {"error": "Could not generate rubric. Check API status."}
 
-    # STEP 2: Semantic Matching (Local - No API cost)
+    # Semantic Matching (Local)
     sents = [s.strip() for s in re.split(r'(?<=[.!?])\s+', answer) if len(s.strip()) > 5]
     if not sents:
-        return {"final_verdict": "❌ ANSWER TOO SHORT"}
+        return {"error": "Answer is too short to evaluate."}
 
     ans_emb = embedder.encode(sents, convert_to_tensor=True)
-    scored = []
-    
+    results = []
     for crit in rubric:
         crit_emb = embedder.encode(crit, convert_to_tensor=True)
         sims = util.cos_sim(crit_emb, ans_emb)[0]
-        best = float(torch.max(sims)) if sims.numel() else 0.0
-        scored.append({"criterion": crit, "satisfied": best >= SIM_THRESHOLD})
+        score = float(torch.max(sims)) if sims.numel() else 0.0
+        results.append({"criterion": crit, "satisfied": score >= SIM_THRESHOLD})
 
-    # STEP 3: Verdict
-    hit = sum(c["satisfied"] for c in scored)
-    if hit == len(scored): verdict_text = "✅ CORRECT"
-    elif hit >= max(1, len(scored) // 2): verdict_text = "⚠️ PARTIALLY CORRECT"
-    else: verdict_text = "❌ INCORRECT"
+    # Verdict
+    hits = sum(r["satisfied"] for r in results)
+    verdict = "✅ CORRECT" if hits == len(results) else "⚠️ PARTIAL" if hits > 0 else "❌ INCORRECT"
 
     return {
-        "intent": intent,
-        "rubric": rubric,
-        "final_verdict": verdict_text
+        "intent": data.get("intent"),
+        "rubric_results": results,
+        "final_verdict": verdict
     }
 
-# ============================================================
 # UI
-# ============================================================
 with gr.Blocks() as demo:
-    gr.Markdown("## 🧠 Gemini-powered Answer Grader")
-
-    kb = gr.Textbox(label="Knowledge Base", lines=8)
-    q = gr.Textbox(label="Question")
-    a = gr.Textbox(label="Student Answer", lines=6)
-
-    out = gr.JSON(label="Evaluation")
-
-    gr.Button("Evaluate").click(evaluate, [a, q, kb], out)
-
-demo.launch()
+    gr.Markdown("## 🧠 Gemini 2.5 Answer Grader")
+    kb_input = gr.Textbox(label="Knowledge Base", lines=5)
+    q_input = gr.Textbox(label="Question")
+    a_input = gr.Textbox(label="Student Answer", lines=4)
+    out = gr.JSON(label="Evaluation Result")
+    gr.Button("Evaluate").click(evaluate, [a_input, q_input, kb_input], out)
+
+demo.launch()