Update app.py

app.py

@@ -1,4 +1,5 @@
-# 🎓 AI Auto-Grader with Groq API (Multilingual: English + Kiswahili)
+# 🎓 AI Auto-Grader with Language-Aware Rationale
+# Supports English & Kiswahili, dynamic Groq model selection
 
 import gradio as gr
 import PyPDF2
@@ -10,27 +11,33 @@ import time
 import os
 from sentence_transformers import SentenceTransformer
 import faiss
+from langdetect import detect  # to detect language
 
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 # Groq API Configuration
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
-GROQ_MODEL = "openai/gpt-oss-120b"
+DEFAULT_MODEL = "llama-3.3-70b-versatile"
+KISWAHILI_MODEL = "qwen/qwen3-32b"
+
 GROQ_API_KEY = os.getenv("GROQ_API_KEY", "").strip()
+if not GROQ_API_KEY:
+    print("⚠️ GROQ_API_KEY not set. Add it in Space Secrets.")
 
-# ─────────────────────────────────────────
-# Embedding Model (MULTILINGUAL)
-# ─────────────────────────────────────────
-embed_model = SentenceTransformer("paraphrase-multilingual-mpnet-base-v2")
+# ─────────────────────────────────────────────────────────────
+# Embedding Model & Global Storage
+# ─────────────────────────────────────────────────────────────
+embed_model = SentenceTransformer("all-mpnet-base-v2")
 
 vector_store = None
 chunks_store = None
+embeddings_store = None
 TOP_K = 3
 MAX_MARKS = 4
 
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 # Text Cleaner
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 def clean_text(text):
     if not text:
         return ""
@@ -38,170 +45,189 @@ def clean_text(text):
     text = re.sub(r'\s+', ' ', text)
     return text.strip()
 
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 # PDF Loader
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 def load_pdf(file_path):
-    reader = PyPDF2.PdfReader(file_path)
-    return [clean_text(p.extract_text()) for p in reader.pages]
-
-# ─────────────────────────────────────────
-# REGEX (ENGLISH + KISWAHILI)
-# ─────────────────────────────────────────
-QA_PATTERN = re.compile(
-    r"(?:Question|Swali):\s*(.+?)\s*(?:Answer|Jibu):\s*(.+?)(?=(?:Question|Swali):|$)",
-    re.DOTALL | re.IGNORECASE
-)
-
-# ─────────────────────────────────────────
-# Chunk Text
-# ─────────────────────────────────────────
-def chunk_text(pages):
-    text = " ".join(pages)
-    matches = QA_PATTERN.findall(text)
-    return [f"Question: {q.strip()} Answer: {a.strip()}" for q, a in matches]
-
-# ─────────────────────────────────────────
+    pdf_reader = PyPDF2.PdfReader(file_path)
+    text_pages = [clean_text(page.extract_text()) for page in pdf_reader.pages]
+    return text_pages
+
+# ─────────────────���───────────────────────────────────────────
+# Chunk text by Q&A
+# ─────────────────────────────────────────────────────────────
+def chunk_text(text_pages):
+    chunks = []
+    text = " ".join(text_pages)
+    pattern = re.compile(r"Question:\s*(.+?)\s*Answer:\s*(.+?)(?=Question:|$)", re.DOTALL | re.IGNORECASE)
+    matches = pattern.findall(text)
+    for q, a in matches:
+        chunks.append(f"Question: {q.strip()} Answer: {a.strip()}")
+    return chunks
+
+# ─────────────────────────────────────────────────────────────
 # Vectorize Marking Scheme
-# ─────────────────────────────────────────
-def vectorize_pdf(file):
-    global vector_store, chunks_store
-
-    if file is None:
-        return {"error": "Upload PDF first"}
-
-    pages = load_pdf(file)
-    chunks = chunk_text(pages)
-
-    if not chunks:
-        return {"error": "No Q&A found. Check format."}
-
-    embeddings = embed_model.encode(chunks, convert_to_numpy=True)
-
-    vector_store = faiss.IndexFlatL2(embeddings.shape[1])
-    vector_store.add(embeddings)
-
-    chunks_store = chunks
-
-    return {
-        "status": "✅ Ready",
-        "chunks": len(chunks),
-        "preview": chunks[:3]
-    }
-
-# ─────────────────────────────────────────
-# Parse Student Answers
-# ─────────────────────────────────────────
-def parse_student_pdf_qna(file):
-    pages = load_pdf(file)
-    text = " ".join(pages)
-    matches = QA_PATTERN.findall(text)
-    return [(q.strip(), a.strip()) for q, a in matches]
-
-# ─────────────────────────────────────────
-# Call Groq
-# ─────────────────────────────────────────
-def call_groq(prompt):
-    headers = {
-        "Authorization": f"Bearer {GROQ_API_KEY}",
-        "Content-Type": "application/json"
-    }
-
+# ─────────────────────────────────────────────────────────────
+def vectorize_pdf(marking_scheme_file):
+    global vector_store, chunks_store, embeddings_store
+    if marking_scheme_file is None:
+        return {"error": "Please upload a PDF."}
+    try:
+        pages = load_pdf(marking_scheme_file)
+        chunks = chunk_text(pages)
+        if not chunks:
+            return {"error": "No Q&A found in PDF."}
+        embeddings = embed_model.encode(chunks, convert_to_numpy=True)
+        vector_store = faiss.IndexFlatL2(embeddings.shape[1])
+        vector_store.add(embeddings)
+        chunks_store = chunks
+        embeddings_store = embeddings
+        preview = [{"id": i+1, "preview": chunk[:120]+"..." if len(chunk)>120 else chunk} for i, chunk in enumerate(chunks[:5])]
+        return {"status": "✅ Success", "chunks_found": len(chunks), "embedding_dim": embeddings.shape[1], "preview": preview}
+    except Exception as e:
+        return {"error": str(e)}
+
+# ─────────────────────────────────────────────────────────────
+# Parse Student PDF
+# ─────────────────────────────────────────────────────────────
+def parse_student_pdf_qna(student_pdf_file):
+    if student_pdf_file is None:
+        return []
+    try:
+        pages = load_pdf(student_pdf_file)
+        text = " ".join(pages)
+        pattern = re.compile(r"Question:\s*(.+?)\s*Answer:\s*(.+?)(?=Question:|$)", re.DOTALL | re.IGNORECASE)
+        qas = pattern.findall(text)
+        return [(q.strip(), a.strip()) for q, a in qas if q.strip() and a.strip()]
+    except Exception as e:
+        print(f"Error parsing student PDF: {e}")
+        return []
+
+# ─────────────────────────────────────────────────────────────
+# Detect language
+# ─────────────────────────────────────────────────────────────
+def detect_language(text):
+    try:
+        lang = detect(text)
+        if lang.startswith("sw"):
+            return "sw"
+        return "en"
+    except:
+        return "en"
+
+# ────────��────────────────────────────────────────────────────
+# Call Groq API with language-aware prompt
+# ─────────────────────────────────────────────────────────────
+def call_groq(prompt, question_text, max_retries=2):
+    if not GROQ_API_KEY:
+        return {"success": False, "score": 0, "rationale": "❌ GROQ_API_KEY not configured."}
+
+    # Select model based on language
+    lang = detect_language(question_text)
+    model = KISWAHILI_MODEL if lang=="sw" else DEFAULT_MODEL
+
+    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
     payload = {
-        "model": GROQ_MODEL,
+        "model": model,
         "messages": [{"role": "user", "content": prompt}],
         "temperature": 0.1,
-        "response_format": {"type": "json_object"}
+        "response_format": {"type": "json_object"},
+        "max_tokens": 500
     }
 
-    res = requests.post(GROQ_API_URL, headers=headers, json=payload)
-    content = res.json()["choices"][0]["message"]["content"]
-
-    if "```" in content:
-        content = content.split("```")[1]
-
-    return json.loads(content)
-
-# ─────────────────────────────────────────
-# MAIN GRADING FUNCTION
-# ─────────────────────────────────────────
-def grade(student_pdf):
+    for attempt in range(max_retries+1):
+        try:
+            response = requests.post(GROQ_API_URL, headers=headers, json=payload, timeout=45)
+            response.raise_for_status()
+            content = response.json()['choices'][0]['message']['content'].strip()
+            if "```json" in content:
+                content = content.split("```json")[1].split("```")[0].strip()
+            elif "```" in content:
+                content = content.split("```")[1].split("```")[0].strip()
+            grading = json.loads(content)
+            return {"success": True, "score": grading["score"], "rationale": grading["rationale"]}
+        except Exception as e:
+            if attempt < max_retries:
+                time.sleep(1.5)
+            else:
+                return {"success": False, "score": 0, "rationale": f"❌ {str(e)}"}
+
+# ─────────────────────────────────────────────────────────────
+# Grade student answers
+# ─────────────────────────────────────────────────────────────
+def grade_student_answers(student_pdf_file):
+    global vector_store, chunks_store
+    if vector_store is None or chunks_store is None:
+        return "❌ Upload & vectorize marking scheme first."
+    if student_pdf_file is None:
+        return "❌ Upload student PDF."
 
-    if vector_store is None:
-        return "❌ Upload marking scheme first"
+    qas = parse_student_pdf_qna(student_pdf_file)
+    if not qas:
+        return "❌ No Q&A found in student PDF."
 
-    qas = parse_student_pdf_qna(student_pdf)
     results = []
-    total = 0
-
-    for i, (q, a) in enumerate(qas, 1):
-
-        query = f"Question: {q} Answer: {a}"
-        vec = embed_model.encode([query], convert_to_numpy=True)
-
-        _, idx = vector_store.search(vec, TOP_K)
-        context = "\n".join([chunks_store[j] for j in idx[0]])
+    total_score = 0
 
-        # 🔥 BILINGUAL PROMPT
+    for idx, (q, a) in enumerate(qas, 1):
+        query_vec = embed_model.encode([f"Question: {q} Answer: {a}"], convert_to_numpy=True)
+        distances, indices = vector_store.search(query_vec, min(TOP_K, len(chunks_store)))
+        context = "\n".join([chunks_store[i] for i in indices[0] if i<len(chunks_store)])
         prompt = f"""
-Maelekezo / Instruction:
-Wewe ni mtahini wa kitaifa. Linganisha jibu la mwanafunzi na mwongozo wa alama.
-Toa alama kwa usahihi. Ruhusu alama za sehemu.
-
-You are a national exam marker. Compare answer with marking scheme and grade fairly.
-
-Swali / Question:
-{q}
-
-Jibu la mwanafunzi / Student Answer:
-{a}
-
-Mwongozo / Marking Scheme:
-{context}
-
-Alama za juu / Maximum Marks: {MAX_MARKS}
-
-Toa JSON:
-{{
- "score": number,
- "rationale": "maelezo"
-}}
-"""
-
-        result = call_groq(prompt)
-
-        score = float(result.get("score", 0))
-        total += score
-
-        results.append(f"""
-Q{i}: {q}
+Instruction: You are a national exam marker.
+Use the same language as the question to write the rationale.
+Compare the student's answer with the marking scheme context and award marks. Output in JSON.
+Question: {q}
 Answer: {a}
-Score: {score}/{MAX_MARKS}
-Reason: {result.get("rationale")}
-""")
-
-    return f"""
-TOTAL: {total}/{len(qas)*MAX_MARKS}
-
-""" + "\n".join(results)
-
-# ─────────────────────────────────────────
+Marking Scheme Context: {context}
+Maximum Marks: {MAX_MARKS}
+Output Format:
+{{"score": <numeric>, "rationale": "<explanation>"}}
+"""
+        grading = call_groq(prompt, q)
+        score = grading.get("score", 0)
+        rationale = grading.get("rationale", "")
+        results.append({"q_num": idx, "question": q, "answer": a, "score": score, "max": MAX_MARKS, "rationale": rationale, "ok": grading.get("success", False)})
+        try: total_score += float(score)
+        except: pass
+        time.sleep(0.3)
+
+    n = len(results)
+    summary = {"total": n, "score": round(total_score,2), "max": n*MAX_MARKS, "pct": round((total_score/(n*MAX_MARKS))*100,1) if n>0 else 0}
+    return {"summary": summary, "results": results}
+
+# ─────────────────────────────────────────────────────────────
+# Format output HTML
+# ─────────────────────────────────────────────────────────────
+def format_output(data):
+    if isinstance(data,str):
+        return f"<div style='color:red'>{data}</div>"
+    s = data["summary"]
+    r = data["results"]
+    html = f"<h3>Summary</h3>Total Questions: {s['total']} | Score: {s['score']}/{s['max']} | Percentage: {s['pct']}%<hr>"
+    for item in r:
+        icon = "✅" if item["ok"] else "❌"
+        html += f"<p>{icon} Q{item['q_num']}: {item['question']}<br>Answer: {item['answer']}<br>Score: {item['score']}/{item['max']}<br>Rationale: {item['rationale']}</p><hr>"
+    return html
+
+# ─────────────────────────────────────────────────────────────
 # Gradio UI
-# ─────────────────────────────────────────
+# ─────────────────────────────────────────────────────────────
 with gr.Blocks() as demo:
-    gr.Markdown("## 🎓 Multilingual AI Auto-Grader (English + Kiswahili)")
-
-    ms_file = gr.File(label="Marking Scheme PDF")
-    st_file = gr.File(label="Student Answers PDF")
-
-    btn1 = gr.Button("Build Index")
-    btn2 = gr.Button("Grade")
-
-    out1 = gr.JSON()
-    out2 = gr.Textbox(lines=20)
-
-    btn1.click(vectorize_pdf, ms_file, out1)
-    btn2.click(grade, st_file, out2)
-
-if __name__ == "__main__":
-    demo.launch()
+    gr.Markdown("## 🎓 AI Auto-Grader (English + Kiswahili)")
+    marking_file = gr.File(label="📄 Marking Scheme PDF", file_types=[".pdf"])
+    vector_status = gr.JSON(label="Vectorization Status")
+    vector_btn = gr.Button("Build Index")
+    
+    student_file = gr.File(label="📝 Student Answers PDF", file_types=[".pdf"])
+    grade_btn = gr.Button("Grade Answers", interactive=False)
+    output = gr.HTML(label="📋 Results")
+
+    vector_btn.click(vectorize_pdf, inputs=[marking_file], outputs=[vector_status]).then(
+        lambda s: gr.update(interactive=True) if s.get("status")=="✅ Success" else gr.update(interactive=False),
+        inputs=[vector_status], outputs=[grade_btn]
+    )
+    grade_btn.click(lambda f: format_output(grade_student_answers(f)), inputs=[student_file], outputs=[output])
+
+if __name__=="__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)