Add interactive VIVA training mode with AI-powered question generation and evaluation

app.py

@@ -158,6 +158,134 @@ Keep it concise and educational."""
         return f"Error generating information: {str(e)}"
 
 
+def generate_viva_questions(topic: str) -> list:
+    """
+    Generate 5 viva questions for the anatomy topic.
+    Returns list of question dictionaries with question, hint, and expected answer.
+    """
+    try:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
+        }
+        
+        prompt = f"""You are an anatomy professor conducting a VIVA exam on: {topic}
+
+Generate exactly 5 viva questions that would be asked during an MBBS anatomy practical exam. For each question, provide:
+1. The question
+2. A helpful hint (not the answer, but guides student thinking)
+3. The expected key points in the answer
+
+Format your response EXACTLY as follows:
+Q1: [question]
+HINT: [hint]
+ANSWER: [expected answer key points]
+
+Q2: [question]
+HINT: [hint]
+ANSWER: [expected answer key points]
+
+... and so on for all 5 questions.
+
+Make questions progressively harder. Start with identification, then structure, then clinical relevance."""
+
+        payload = {
+            "model": HYPERBOLIC_MODEL,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 800,
+            "temperature": 0.7
+        }
+        
+        response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=25)
+        response.raise_for_status()
+        
+        result = response.json()
+        content = result["choices"][0]["message"]["content"]
+        
+        # Parse the questions
+        questions = []
+        lines = content.split('\n')
+        current_q = {}
+        
+        for line in lines:
+            line = line.strip()
+            if line.startswith('Q') and ':' in line:
+                if current_q:
+                    questions.append(current_q)
+                current_q = {'question': line.split(':', 1)[1].strip()}
+            elif line.startswith('HINT:'):
+                current_q['hint'] = line.split(':', 1)[1].strip()
+            elif line.startswith('ANSWER:'):
+                current_q['answer'] = line.split(':', 1)[1].strip()
+        
+        if current_q:
+            questions.append(current_q)
+        
+        return questions[:5]  # Ensure exactly 5 questions
+    
+    except Exception as e:
+        print(f"Error generating viva questions: {e}")
+        return []
+
+
+def evaluate_viva_answer(question: str, student_answer: str, expected_answer: str) -> tuple[str, str]:
+    """
+    Evaluate student's answer and provide feedback.
+    Returns (feedback, score_emoji)
+    """
+    if not student_answer.strip():
+        return "Please provide an answer to continue.", "⏸️"
+    
+    try:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
+        }
+        
+        prompt = f"""You are an anatomy professor evaluating a student's VIVA answer.
+
+Question: {question}
+Expected key points: {expected_answer}
+Student's answer: {student_answer}
+
+Evaluate the answer and provide:
+1. Brief feedback (2-3 sentences)
+2. What was correct
+3. What was missing (if anything)
+4. Score as: EXCELLENT, GOOD, FAIR, or NEEDS_IMPROVEMENT
+
+Be encouraging but honest. Format your response as friendly feedback."""
+
+        payload = {
+            "model": HYPERBOLIC_MODEL,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": 300,
+            "temperature": 0.6
+        }
+        
+        response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=15)
+        response.raise_for_status()
+        
+        result = response.json()
+        feedback = result["choices"][0]["message"]["content"]
+        
+        # Determine emoji based on feedback content
+        feedback_upper = feedback.upper()
+        if "EXCELLENT" in feedback_upper:
+            emoji = "🌟"
+        elif "GOOD" in feedback_upper:
+            emoji = "✅"
+        elif "FAIR" in feedback_upper:
+            emoji = "👍"
+        else:
+            emoji = "📚"
+        
+        return feedback, emoji
+    
+    except Exception as e:
+        return f"Could not evaluate answer: {str(e)}", "⚠️"
+
+
 def process_anatomy_query(query: str) -> tuple:
     """
     Main function to process anatomy queries.
@@ -202,66 +330,206 @@ def process_anatomy_query(query: str) -> tuple:
     return image, info, error_message
 
 
+# VIVA Mode Handler Functions
+def start_viva_mode(topic, image):
+    """Initialize VIVA mode with questions."""
+    if not topic or not image:
+        return (
+            gr.update(visible=False),  # viva_container
+            "Please learn about a topic first before starting VIVA mode!",  # viva_status
+            None, None, None, None, None, None, []  # other outputs
+        )
+    
+    questions = generate_viva_questions(topic)
+    
+    if not questions or len(questions) == 0:
+        return (
+            gr.update(visible=False),
+            "Error generating VIVA questions. Please try again.",
+            None, None, None, None, None, None, []
+        )
+   
+    # Start with question 1
+    q1 = questions[0]
+    return (
+        gr.update(visible=True),  # Show VIVA container
+        f"**VIVA MODE ACTIVE** 📝\nTopic: {topic}",  # viva_status
+        image,  # viva_image
+        f"### Question 1 of 5\n\n**{q1['question']}**",  # current_question
+        f"💡 **Hint:** {q1.get('hint', 'Think about the key anatomical features.')}",  # hint_display
+        "",  # Clear answer input
+        "",  # Clear feedback
+        gr.update(interactive=True, value="Submit Answer"),  # Enable submit button
+        questions  # Store questions in state
+    )
+
+
+def submit_viva_answer(answer, questions, current_q_idx):
+    """Process student's answer and move to next question."""
+    if not questions or current_q_idx >= len(questions):
+        return ("VIVA Complete!", "", "", gr.update(interactive=False), current_q_idx)
+    
+    q = questions[current_q_idx]
+    feedback, emoji = evaluate_viva_answer(q['question'], answer, q.get('answer', ''))
+    
+    feedback_text = f"{emoji} **Feedback:**\n\n{feedback}\n\n**Expected key points:** {q.get('answer', 'N/A')}"
+    
+    # Move to next question
+    next_idx = current_q_idx + 1
+    
+    if next_idx < len(questions):
+        next_q = questions[next_idx]
+        next_question = f"### Question {next_idx + 1} of 5\n\n**{next_q['question']}**"
+        next_hint = f"💡 **Hint:** {next_q.get('hint', 'Think carefully about the anatomical relationships.')}"
+        return (
+            next_question,  # Show next question
+            next_hint,  # Show next hint
+            "",  # Clear answer box
+            feedback_text,  # Show feedback for current answer
+            gr.update(interactive=True, value="Submit Answer"),  # Keep button enabled
+            next_idx  # Update question index
+        )
+    else:
+        # VIVA complete
+        completion_msg = f"### 🎉 VIVA Complete!\n\nYou've answered all 5 questions. Great job on completing your anatomy VIVA training!"
+        return (
+            completion_msg,
+            "",  # Clear hint
+            "",  # Clear answer
+            feedback_text,  # Final feedback
+            gr.update(interactive=False, value="VIVA Complete"),
+            next_idx
+        )
+
+
 # Create Gradio interface
 with gr.Blocks(title="AnatomyBot - MBBS Anatomy Tutor") as demo:
     gr.Markdown(
         """
         # 🩺 AnatomyBot - Your MBBS Anatomy Tutor
         
-        Ask questions about human anatomy and receive visual diagrams with key learning points!
+        Master anatomy through AI-powered learning and interactive VIVA practice!
         """
     )
     
-    with gr.Row():
-        with gr.Column():
-            query_input = gr.Textbox(
-                label="Ask an Anatomy Question",
-                placeholder="e.g., Show me the Circle of Willis",
-                lines=2
-            )
-            
-            # Examples moved here - right below the text box
-            gr.Examples(
-                examples=[
-                    ["Show me the Circle of Willis"],
-                    ["Brachial plexus anatomy"],
-                    ["Carpal bones arrangement"],
-                    ["Layers of the scalp"],
-                    ["Anatomy of the heart chambers"],
-                    ["Cranial nerves and their functions"],
-                    ["Structure of the kidney nephron"],
-                    ["Branches of the abdominal aorta"],
-                    ["Rotator cuff muscles"],
-                    ["Spinal cord cross section"],
-                    ["Femoral triangle anatomy"],
-                    ["Larynx cartilages and membranes"],
-                    ["Portal venous system"],
-                    ["Anatomy of the eyeball"],
-                    ["Bronchopulmonary segments"]
-                ],
-                inputs=query_input
-            )
+    # State variables for VIVA mode
+    viva_questions_state = gr.State([])
+    current_question_idx = gr.State(0)
+    current_topic = gr.State("")
+    current_image_state = gr.State(None)
+    
+    with gr.Tabs() as tabs:
+        # LEARNING MODE TAB
+        with gr.Tab("📚 Learning Mode"):
+            with gr.Row():
+                with gr.Column():
+                    query_input = gr.Textbox(
+                        label="Ask an Anatomy Question",
+                        placeholder="e.g., Show me the Circle of Willis",
+                        lines=2
+                    )
+                    
+                    # Examples moved here - right below the text box
+                    gr.Examples(
+                        examples=[
+                            ["Show me the Circle of Willis"],
+                            ["Brachial plexus anatomy"],
+                            ["Carpal bones arrangement"],
+                            ["Layers of the scalp"],
+                            ["Anatomy of the heart chambers"],
+                            ["Cranial nerves and their functions"],
+                            ["Structure of the kidney nephron"],
+                            ["Branches of the abdominal aorta"],
+                            ["Rotator cuff muscles"],
+                            ["Spinal cord cross section"],
+                            ["Femoral triangle anatomy"],
+                            ["Larynx cartilages and membranes"],
+                            ["Portal venous system"],
+                            ["Anatomy of the eyeball"],
+                            ["Bronchopulmonary segments"]
+                        ],
+                        inputs=query_input
+                    )
+                    
+                    submit_btn = gr.Button("🔍 Search & Learn", variant="primary", size="lg")
+                    error_output = gr.Markdown(label="Status")
+                    
+                    # VIVA Mode Button
+                    start_viva_btn = gr.Button("🎯 Start VIVA Training", variant="secondary", size="lg")
+                
+                with gr.Column():
+                    image_output = gr.Image(label="Anatomy Diagram", type="pil")
             
-            submit_btn = gr.Button("🔍 Search & Learn", variant="primary", size="lg")
-            error_output = gr.Markdown(label="Status")
+            with gr.Row():
+                info_output = gr.Markdown(label="Key Points to Know")
         
-        with gr.Column():
-            image_output = gr.Image(label="Anatomy Diagram", type="pil")
+        # VIVA MODE TAB
+        with gr.Tab("🎯 VIVA Training Mode") as viva_tab:
+            viva_status = gr.Markdown("Click 'Start VIVA Training' from Learning Mode after studying a topic!")
+            
+            with gr.Column(visible=False) as viva_container:
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        viva_image = gr.Image(label="Reference Image", type="pil", interactive=False)
+                    
+                    with gr.Column(scale=2):
+                        current_question_display = gr.Markdown("### Question will appear here")
+                        hint_display = gr.Markdown("💡 Hint will appear here")
+                        
+                        student_answer = gr.Textbox(
+                            label="Your Answer",
+                            placeholder="Type your answer here...",
+                            lines=4
+                        )
+                        
+                        submit_answer_btn = gr.Button("Submit Answer", variant="primary")
+                        
+                        feedback_display = gr.Markdown("Feedback will appear here after you submit your answer")
     
-    with gr.Row():
-        info_output = gr.Markdown(label="Key Points to Know")
+    # Event handlers for Learning Mode
+    def handle_query(query):
+        """Handle learning mode query and store topic/image."""
+        img, info, error = process_anatomy_query(query)
+        return img, info, error, query, img  # Return topic and image for VIVA mode
     
-    # Event handler
     submit_btn.click(
-        fn=process_anatomy_query,
+        fn=handle_query,
         inputs=[query_input],
-        outputs=[image_output, info_output, error_output]
+        outputs=[image_output, info_output, error_output, current_topic, current_image_state]
     )
     
     query_input.submit(
-        fn=process_anatomy_query,
+        fn=handle_query,
         inputs=[query_input],
-        outputs=[image_output, info_output, error_output]
+        outputs=[image_output, info_output, error_output, current_topic, current_image_state]
+    )
+    
+    # Start VIVA Mode
+    start_viva_btn.click(
+        fn=start_viva_mode,
+        inputs=[current_topic, current_image_state],
+        outputs=[
+            viva_container, viva_status, viva_image,
+            current_question_display, hint_display,
+            student_answer, feedback_display, submit_answer_btn,
+            viva_questions_state
+        ]
+    ).then(
+        fn=lambda: gr.update(selected=1),  # Switch to VIVA tab
+        outputs=[tabs]
+    ).then(
+        fn=lambda: 0,  # Reset question index
+        outputs=[current_question_idx]
+    )
+    
+    # Submit VIVA Answer
+    submit_answer_btn.click(
+        fn=submit_viva_answer,
+        inputs=[student_answer, viva_questions_state, current_question_idx],
+        outputs=[
+            current_question_display, hint_display, student_answer,
+            feedback_display, submit_answer_btn, current_question_idx
+        ]
     )
 
 if __name__ == "__main__":