Implement storage layer and adaptive learning tools for TutorX-MCP

- Added `mcp_server.storage` module with `MemoryStore` for in-memory data management.
- Implemented persistence features using pickle for student profiles, performance data, session data, analytics cache, and adaptation history.
- Created integration tests for adaptive learning tools, including session management and learning path generation.
- Developed enhanced adaptive learning tests with Gemini integration for personalized learning experiences.
- Added import tests to verify the functionality of adaptive learning components.
- Implemented interactive quiz functionality tests to ensure quiz generation and answer submission work as expected.
- Established MCP connection tests to validate tool availability and session initiation.
- Created new adaptive learning tests to evaluate the complete workflow of the adaptive learning system.

app.py

@@ -21,7 +21,7 @@ from mcp.client.sse import sse_client
 from mcp.client.session import ClientSession
 
 # Server configuration
-SERVER_URL = "https://tutorx-mcp.onrender.com/sse"  # Ensure this is the SSE endpoint
+SERVER_URL = "http://localhost:8000/sse"  # Ensure this is the SSE endpoint
 
 # Utility functions
 
@@ -50,28 +50,13 @@ async def check_plagiarism_async(submission, reference):
         async with ClientSession(sse, write) as session:
             await session.initialize()
             response = await session.call_tool(
-                "check_submission_originality", 
+                "check_submission_originality",
                 {
-                    "submission": submission, 
+                    "submission": submission,
                     "reference_sources": [reference] if isinstance(reference, str) else reference
                 }
             )
-            if hasattr(response, 'content') and isinstance(response.content, list):
-                for item in response.content:
-                    if hasattr(item, 'text') and item.text:
-                        try:
-                            data = json.loads(item.text)
-                            return data
-                        except Exception:
-                            return {"raw_pretty": json.dumps(item.text, indent=2)}
-            if isinstance(response, dict):
-                return response
-            if isinstance(response, str):
-                try:
-                    return json.loads(response)
-                except Exception:
-                    return {"raw_pretty": json.dumps(response, indent=2)}
-            return {"raw_pretty": json.dumps(str(response), indent=2)}
+            return await extract_response_content(response)
 
 def start_ping_task():
     """Start the ping task when the Gradio app launches"""
@@ -112,26 +97,23 @@ async def load_concept_graph(concept_id: str = None) -> Tuple[Optional[plt.Figur
     """
     Load and visualize the concept graph for a given concept ID.
     If no concept_id is provided, returns the first available concept.
-    
+
     Args:
         concept_id: The ID or name of the concept to load
-        
+
     Returns:
         tuple: (figure, concept_details, related_concepts) or (None, error_dict, [])
     """
-    print(f"[DEBUG] Loading concept graph for concept_id: {concept_id}")
-    
     try:
         async with sse_client(SERVER_URL) as (sse, write):
             async with ClientSession(sse, write) as session:
                 await session.initialize()
-                
+
                 # Call the concept graph tool
                 result = await session.call_tool(
-                    "get_concept_graph_tool", 
+                    "get_concept_graph_tool",
                     {"concept_id": concept_id} if concept_id else {}
                 )
-                print(f"[DEBUG] Raw tool response type: {type(result)}")
                 
                 # Extract content if it's a TextContent object
                 if hasattr(result, 'content') and isinstance(result.content, list):
@@ -139,26 +121,20 @@ async def load_concept_graph(concept_id: str = None) -> Tuple[Optional[plt.Figur
                         if hasattr(item, 'text') and item.text:
                             try:
                                 result = json.loads(item.text)
-                                print("[DEBUG] Successfully parsed JSON from TextContent")
                                 break
                             except json.JSONDecodeError as e:
-                                print(f"[ERROR] Failed to parse JSON from TextContent: {e}")
-                
+                                return None, {"error": f"Failed to parse JSON from TextContent: {str(e)}"}, []
+
                 # If result is a string, try to parse it as JSON
                 if isinstance(result, str):
                     try:
                         result = json.loads(result)
                     except json.JSONDecodeError as e:
-                        print(f"[ERROR] Failed to parse result as JSON: {e}")
                         return None, {"error": f"Failed to parse concept graph data: {str(e)}"}, []
                 
-                # Debug print for the raw backend response
-                print(f"[DEBUG] Raw backend response: {result}")
-                
                 # Handle backend error response
                 if isinstance(result, dict) and "error" in result:
                     error_msg = f"Backend error: {result['error']}"
-                    print(f"[ERROR] {error_msg}")
                     return None, {"error": error_msg}, []
                 
                 concept = None
@@ -175,32 +151,27 @@ async def load_concept_graph(concept_id: str = None) -> Tuple[Optional[plt.Figur
                             # Try to find the requested concept by ID or name
                             if concept_id:
                                 for c in result["concepts"]:
-                                    if (isinstance(c, dict) and 
-                                        (c.get("id") == concept_id or 
+                                    if (isinstance(c, dict) and
+                                        (c.get("id") == concept_id or
                                          str(c.get("name", "")).lower() == concept_id.lower())):
                                         concept = c
                                         break
                                 if not concept:
                                     error_msg = f"Concept '{concept_id}' not found in the concept graph"
-                                    print(f"[ERROR] {error_msg}")
                                     return None, {"error": error_msg}, []
                         else:
                             error_msg = "No concepts found in the concept graph"
-                            print(f"[ERROR] {error_msg}")
                             return None, {"error": error_msg}, []
-                
+
                 # If we still don't have a valid concept
                 if not concept or not isinstance(concept, dict):
                     error_msg = "Could not extract valid concept data from response"
-                    print(f"[ERROR] {error_msg}")
                     return None, {"error": error_msg}, []
-                
+
                 # Ensure required fields exist with defaults
                 concept.setdefault('related_concepts', [])
                 concept.setdefault('prerequisites', [])
                 
-                print(f"[DEBUG] Final concept data: {concept}")
-                
                 # Create a new directed graph
                 G = nx.DiGraph()
                 
@@ -356,9 +327,6 @@ async def load_concept_graph(concept_id: str = None) -> Tuple[Optional[plt.Figur
                 return plt.gcf(), concept_details, all_related
                 
     except Exception as e:
-        import traceback
-        error_msg = f"Error in load_concept_graph: {str(e)}\n\n{traceback.format_exc()}"
-        print(f"[ERROR] {error_msg}")
         return None, {"error": f"Failed to load concept graph: {str(e)}"}, []
 
 def sync_load_concept_graph(concept_id):
@@ -372,6 +340,159 @@ def sync_load_concept_graph(concept_id):
     except Exception as e:
         return None, {"error": str(e)}, []
 
+# Synchronous wrapper functions for Gradio
+def sync_check_plagiarism(submission, reference):
+    """Synchronous wrapper for check_plagiarism_async"""
+    try:
+        return asyncio.run(check_plagiarism_async(submission, reference))
+    except Exception as e:
+        return {"error": str(e)}
+
+# Interactive Quiz synchronous wrappers
+def sync_start_interactive_quiz(quiz_data, student_id):
+    """Synchronous wrapper for start_interactive_quiz_async"""
+    try:
+        return asyncio.run(start_interactive_quiz_async(quiz_data, student_id))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_submit_quiz_answer(session_id, question_id, selected_answer):
+    """Synchronous wrapper for submit_quiz_answer_async"""
+    try:
+        return asyncio.run(submit_quiz_answer_async(session_id, question_id, selected_answer))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_get_quiz_hint(session_id, question_id):
+    """Synchronous wrapper for get_quiz_hint_async"""
+    try:
+        return asyncio.run(get_quiz_hint_async(session_id, question_id))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_get_quiz_session_status(session_id):
+    """Synchronous wrapper for get_quiz_session_status_async"""
+    try:
+        return asyncio.run(get_quiz_session_status_async(session_id))
+    except Exception as e:
+        return {"error": str(e)}
+
+# Helper functions for interactive quiz interface
+def format_question_display(quiz_session_data):
+    """Format quiz session data for display"""
+    if not quiz_session_data or "error" in quiz_session_data:
+        return "❌ No active quiz session"
+
+    question = quiz_session_data.get("question", {})
+    if not question:
+        return "✅ Quiz completed or no current question"
+
+    question_text = question.get("question", "")
+    options = question.get("options", [])
+    question_num = quiz_session_data.get("current_question_number", 1)
+    total = quiz_session_data.get("total_questions", 1)
+
+    display_text = f"""
+### Question {question_num} of {total}
+
+**{question_text}**
+
+**Options:**
+"""
+    for option in options:
+        display_text += f"\n- {option}"
+
+    return display_text
+
+def update_answer_options(quiz_session_data):
+    """Update answer options based on current question"""
+    if not quiz_session_data or "error" in quiz_session_data:
+        return gr.Radio(choices=["No options available"], value=None)
+
+    question = quiz_session_data.get("question", {})
+    options = question.get("options", ["A) Option A", "B) Option B", "C) Option C", "D) Option D"])
+
+    return gr.Radio(choices=options, value=None, label="Select Your Answer")
+
+def extract_question_id(quiz_session_data):
+    """Extract question ID from quiz session data"""
+    if not quiz_session_data or "error" in quiz_session_data:
+        return ""
+
+    question = quiz_session_data.get("question", {})
+    return question.get("question_id", "")
+
+def sync_generate_quiz(concept, difficulty):
+    """Synchronous wrapper for on_generate_quiz"""
+    try:
+        return asyncio.run(on_generate_quiz(concept, difficulty))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_generate_lesson(topic, grade, duration):
+    """Synchronous wrapper for generate_lesson_async"""
+    try:
+        return asyncio.run(generate_lesson_async(topic, grade, duration))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_generate_learning_path(student_id, concept_ids, student_level):
+    """Synchronous wrapper for on_generate_learning_path"""
+    try:
+        return asyncio.run(on_generate_learning_path(student_id, concept_ids, student_level))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_text_interaction(text, student_id):
+    """Synchronous wrapper for text_interaction_async"""
+    try:
+        return asyncio.run(text_interaction_async(text, student_id))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_document_ocr(file):
+    """Synchronous wrapper for document_ocr_async"""
+    try:
+        return asyncio.run(document_ocr_async(file))
+    except Exception as e:
+        return {"error": str(e)}
+
+# Adaptive learning synchronous wrappers
+def sync_start_adaptive_session(student_id, concept_id, difficulty):
+    """Synchronous wrapper for start_adaptive_session_async"""
+    try:
+        return asyncio.run(start_adaptive_session_async(student_id, concept_id, difficulty))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_record_learning_event(student_id, concept_id, event_type, session_id, correct, time_taken):
+    """Synchronous wrapper for record_learning_event_async"""
+    try:
+        return asyncio.run(record_learning_event_async(student_id, concept_id, event_type, session_id, correct, time_taken))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_get_adaptive_recommendations(student_id, concept_id, session_id=None):
+    """Synchronous wrapper for get_adaptive_recommendations_async"""
+    try:
+        return asyncio.run(get_adaptive_recommendations_async(student_id, concept_id, session_id))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_get_adaptive_learning_path(student_id, concept_ids, strategy, max_concepts):
+    """Synchronous wrapper for get_adaptive_learning_path_async"""
+    try:
+        return asyncio.run(get_adaptive_learning_path_async(student_id, concept_ids, strategy, max_concepts))
+    except Exception as e:
+        return {"error": str(e)}
+
+def sync_get_progress_summary(student_id, days=7):
+    """Synchronous wrapper for get_progress_summary_async"""
+    try:
+        return asyncio.run(get_progress_summary_async(student_id, days))
+    except Exception as e:
+        return {"error": str(e)}
+
 # Define async functions outside the interface
 async def on_generate_quiz(concept, difficulty):
     try:
@@ -392,22 +513,7 @@ async def on_generate_quiz(concept, difficulty):
             async with ClientSession(sse, write) as session:
                 await session.initialize()
                 response = await session.call_tool("generate_quiz_tool", {"concept": concept.strip(), "difficulty": difficulty_str})
-                if hasattr(response, 'content') and isinstance(response.content, list):
-                    for item in response.content:
-                        if hasattr(item, 'text') and item.text:
-                            try:
-                                quiz_data = json.loads(item.text)
-                                return quiz_data
-                            except Exception:
-                                return {"raw_pretty": json.dumps(item.text, indent=2)}
-                if isinstance(response, dict):
-                    return response
-                if isinstance(response, str):
-                    try:
-                        return json.loads(response)
-                    except Exception:
-                        return {"raw_pretty": json.dumps(response, indent=2)}
-                return {"raw_pretty": json.dumps(str(response), indent=2)}
+                return await extract_response_content(response)
     except Exception as e:
         import traceback
         return {
@@ -419,22 +525,7 @@ async def generate_lesson_async(topic, grade, duration):
         async with ClientSession(sse, write) as session:
             await session.initialize()
             response = await session.call_tool("generate_lesson_tool", {"topic": topic, "grade_level": grade, "duration_minutes": duration})
-            if hasattr(response, 'content') and isinstance(response.content, list):
-                for item in response.content:
-                    if hasattr(item, 'text') and item.text:
-                        try:
-                            lesson_data = json.loads(item.text)
-                            return lesson_data
-                        except Exception:
-                            return {"raw_pretty": json.dumps(item.text, indent=2)}
-            if isinstance(response, dict):
-                return response
-            if isinstance(response, str):
-                try:
-                    return json.loads(response)
-                except Exception:
-                    return {"raw_pretty": json.dumps(response, indent=2)}
-            return {"raw_pretty": json.dumps(str(response), indent=2)}
+            return await extract_response_content(response)
 
 async def on_generate_learning_path(student_id, concept_ids, student_level):
     try:
@@ -446,46 +537,160 @@ async def on_generate_learning_path(student_id, concept_ids, student_level):
                     "concept_ids": [c.strip() for c in concept_ids.split(",") if c.strip()],
                     "student_level": student_level
                 })
-                if hasattr(result, 'content') and isinstance(result.content, list):
-                    for item in response.content:
-                        if hasattr(item, 'text') and item.text:
-                            try:
-                                lp_data = json.loads(item.text)
-                                return lp_data
-                            except Exception:
-                                return {"raw_pretty": json.dumps(item.text, indent=2)}
-                if isinstance(response, dict):
-                    return response
-                if isinstance(response, str):
-                    try:
-                        return json.loads(response)
-                    except Exception:
-                        return {"raw_pretty": json.dumps(result, indent=2)}
-                return {"raw_pretty": json.dumps(str(result), indent=2)}
+                return await extract_response_content(result)
     except Exception as e:
         return {"error": str(e)}
 
-async def text_interaction_async(text, student_id):
+# New adaptive learning functions
+async def start_adaptive_session_async(student_id, concept_id, difficulty):
+    try:
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                result = await session.call_tool("start_adaptive_session", {
+                    "student_id": student_id,
+                    "concept_id": concept_id,
+                    "initial_difficulty": float(difficulty)
+                })
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+async def record_learning_event_async(student_id, concept_id, event_type, session_id, correct, time_taken):
+    try:
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                result = await session.call_tool("record_learning_event", {
+                    "student_id": student_id,
+                    "concept_id": concept_id,
+                    "event_type": event_type,
+                    "session_id": session_id,
+                    "event_data": {"correct": correct, "time_taken": time_taken}
+                })
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+async def get_adaptive_recommendations_async(student_id, concept_id, session_id=None):
+    try:
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                params = {
+                    "student_id": student_id,
+                    "concept_id": concept_id
+                }
+                if session_id:
+                    params["session_id"] = session_id
+                result = await session.call_tool("get_adaptive_recommendations", params)
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def get_adaptive_learning_path_async(student_id, concept_ids, strategy, max_concepts):
+    try:
+        # Parse concept_ids if it's a string
+        if isinstance(concept_ids, str):
+            concept_ids = [c.strip() for c in concept_ids.split(',') if c.strip()]
+
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                result = await session.call_tool("get_adaptive_learning_path", {
+                    "student_id": student_id,
+                    "target_concepts": concept_ids,
+                    "strategy": strategy,
+                    "max_concepts": int(max_concepts)
+                })
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+async def get_progress_summary_async(student_id, days=7):
+    try:
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                result = await session.call_tool("get_student_progress_summary", {
+                    "student_id": student_id,
+                    "days": int(days)
+                })
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+# Interactive Quiz async functions
+async def start_interactive_quiz_async(quiz_data, student_id):
     async with sse_client(SERVER_URL) as (sse, write):
         async with ClientSession(sse, write) as session:
             await session.initialize()
-            response = await session.call_tool("text_interaction", {"query": text, "student_id": student_id})
-            if hasattr(response, 'content') and isinstance(response.content, list):
-                for item in response.content:
-                    if hasattr(item, 'text') and item.text:
-                        try:
-                            data = json.loads(item.text)
-                            return data
-                        except Exception:
-                            return {"raw_pretty": json.dumps(item.text, indent=2)}
-            if isinstance(response, dict):
-                return response
-            if isinstance(response, str):
+            response = await session.call_tool("start_interactive_quiz_tool", {"quiz_data": quiz_data, "student_id": student_id})
+            return await extract_response_content(response)
+
+async def submit_quiz_answer_async(session_id, question_id, selected_answer):
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            response = await session.call_tool("submit_quiz_answer_tool", {"session_id": session_id, "question_id": question_id, "selected_answer": selected_answer})
+            return await extract_response_content(response)
+
+async def get_quiz_hint_async(session_id, question_id):
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            response = await session.call_tool("get_quiz_hint_tool", {"session_id": session_id, "question_id": question_id})
+            return await extract_response_content(response)
+
+async def get_quiz_session_status_async(session_id):
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            response = await session.call_tool("get_quiz_session_status_tool", {"session_id": session_id})
+            return await extract_response_content(response)
+
+async def extract_response_content(response):
+    """Helper function to extract content from MCP response"""
+    # Handle direct dictionary responses (new format)
+    if isinstance(response, dict):
+        return response
+
+    # Handle MCP response with content structure (CallToolResult format)
+    if hasattr(response, 'content') and isinstance(response.content, list):
+        for item in response.content:
+            # Handle TextContent objects
+            if hasattr(item, 'text') and item.text:
+                try:
+                    return json.loads(item.text)
+                except Exception as e:
+                    return {"error": f"Failed to parse response: {str(e)}", "raw_text": item.text}
+            # Handle other content types
+            elif hasattr(item, 'type') and item.type == 'text':
                 try:
-                    return json.loads(response)
+                    return json.loads(str(item))
                 except Exception:
-                    return {"raw_pretty": json.dumps(response, indent=2)}
-            return {"raw_pretty": json.dumps(str(response), indent=2)}
+                    return {"error": "Failed to parse text content", "raw_text": str(item)}
+
+    # Handle string responses
+    if isinstance(response, str):
+        try:
+            return json.loads(response)
+        except Exception:
+            return {"error": "Failed to parse string response", "raw_text": response}
+
+    # Handle any other response type - try to extract useful information
+    if hasattr(response, '__dict__'):
+        return {"error": "Unexpected response format", "type": type(response).__name__, "raw_text": str(response)}
+
+    return {"error": "Unknown response format", "type": type(response).__name__, "raw_text": str(response)}
+
+async def text_interaction_async(text, student_id):
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            response = await session.call_tool("text_interaction", {"query": text, "student_id": student_id})
+            return await extract_response_content(response)
 
 async def upload_file_to_storage(file_path):
     """Helper function to upload file to storage API"""
@@ -519,22 +724,7 @@ async def document_ocr_async(file):
             async with ClientSession(sse, write) as session:
                 await session.initialize()
                 response = await session.call_tool("mistral_document_ocr", {"document_url": storage_url})
-                if hasattr(response, 'content') and isinstance(response.content, list):
-                    for item in response.content:
-                        if hasattr(item, 'text') and item.text:
-                            try:
-                                data = json.loads(item.text)
-                                return data
-                            except Exception:
-                                return {"raw_pretty": json.dumps(item.text, indent=2)}
-                if isinstance(response, dict):
-                    return response
-                if isinstance(response, str):
-                    try:
-                        return json.loads(response)
-                    except Exception:
-                        return {"raw_pretty": json.dumps(response, indent=2)}
-                return {"raw_pretty": json.dumps(str(response), indent=2)}
+                return await extract_response_content(response)
     except Exception as e:
         return {"error": f"Error processing document: {str(e)}", "success": False}
 
@@ -556,15 +746,17 @@ def create_gradio_interface():
         with gr.Row():
             with gr.Column():
                 gr.Markdown("""
-                #  TutorX Educational AI Platform
-                *An adaptive, multi-modal, and collaborative AI tutoring platform built with MCP.*
+                # 🧠 TutorX Educational AI Platform
+                *An adaptive, multi-modal, and collaborative AI tutoring platform with real-time personalization.*
+
+                **✨ New: Adaptive Learning System** - Experience personalized learning that adapts to your performance in real-time!
                 """)
 
         # Add some spacing
         gr.Markdown("---")
 
 # Main Tabs with scrollable container
-        with gr.Tabs() as tabs:
+        with gr.Tabs():
             # Tab 1: Core Features
             with gr.Tab("1 Core Features", elem_id="core_features_tab"):
                 with gr.Row():
@@ -666,11 +858,156 @@ def create_gradio_interface():
 
                 # Connect quiz generation button
                 gen_quiz_btn.click(
-                    fn=on_generate_quiz,
+                    fn=sync_generate_quiz,
                     inputs=[quiz_concept_input, diff_input],
                     outputs=[quiz_output],
                     api_name="generate_quiz"
                 )
+
+                # Interactive Quiz Section
+                gr.Markdown("---")
+                gr.Markdown("## 🎮 Interactive Quiz Taking")
+                gr.Markdown("Take quizzes interactively with immediate feedback and explanations.")
+
+                with gr.Accordion("🚀 Start Interactive Quiz", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            quiz_student_id = gr.Textbox(label="Student ID", value=student_id)
+                            start_quiz_btn = gr.Button("Start Interactive Quiz", variant="primary")
+                            gr.Markdown("*First generate a quiz above, then click 'Start Interactive Quiz'*")
+
+                        with gr.Column():
+                            quiz_session_output = gr.JSON(label="Quiz Session Status")
+
+                # Quiz Taking Interface
+                with gr.Accordion("📝 Answer Questions", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            session_id_input = gr.Textbox(label="Session ID", placeholder="Enter session ID from above")
+                            question_id_input = gr.Textbox(label="Question ID", placeholder="e.g., q1")
+
+                            # Answer options as radio buttons
+                            answer_choice = gr.Radio(
+                                choices=["A) Option A", "B) Option B", "C) Option C", "D) Option D"],
+                                label="Select Your Answer",
+                                value=None
+                            )
+
+                            with gr.Row():
+                                submit_answer_btn = gr.Button("Submit Answer", variant="primary")
+                                get_hint_btn = gr.Button("Get Hint", variant="secondary")
+                                check_status_btn = gr.Button("Check Status", variant="secondary")
+
+                        with gr.Column():
+                            answer_feedback = gr.JSON(label="Answer Feedback")
+                            hint_output = gr.JSON(label="Hint")
+
+                # Quiz Progress and Results
+                with gr.Accordion("📊 Quiz Progress & Results", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### Current Question Display")
+                            current_question_display = gr.Markdown("*Start a quiz to see the current question*")
+
+                        with gr.Column():
+                            gr.Markdown("### Quiz Statistics")
+                            quiz_stats_display = gr.JSON(label="Quiz Statistics")
+
+                # Connect interactive quiz buttons with enhanced functionality
+                def start_quiz_with_display(student_id, quiz_data):
+                    """Start quiz and update displays"""
+                    if not quiz_data or "error" in quiz_data:
+                        return {"error": "Please generate a quiz first"}, "*Please generate a quiz first*", gr.Radio(choices=["No options available"], value=None), ""
+
+                    session_result = sync_start_interactive_quiz(quiz_data, student_id)
+                    question_display = format_question_display(session_result)
+                    answer_options = update_answer_options(session_result)
+                    question_id = extract_question_id(session_result)
+
+                    return session_result, question_display, answer_options, question_id
+
+                def submit_answer_with_feedback(session_id, question_id, selected_answer):
+                    """Submit answer and update displays"""
+                    feedback = sync_submit_quiz_answer(session_id, question_id, selected_answer)
+
+                    # Update question display if there's a next question
+                    if "next_question" in feedback:
+                        next_q_data = {"question": feedback["next_question"]}
+                        question_display = format_question_display(next_q_data)
+                        answer_options = update_answer_options(next_q_data)
+                        next_question_id = feedback["next_question"].get("question_id", "")
+                    else:
+                        question_display = "✅ Quiz completed! Check your final results below."
+                        answer_options = gr.Radio(choices=["Quiz completed"], value=None)
+                        next_question_id = ""
+
+                    return feedback, question_display, answer_options, next_question_id
+
+                start_quiz_btn.click(
+                    fn=start_quiz_with_display,
+                    inputs=[quiz_student_id, quiz_output],
+                    outputs=[quiz_session_output, current_question_display, answer_choice, question_id_input]
+                )
+
+                submit_answer_btn.click(
+                    fn=submit_answer_with_feedback,
+                    inputs=[session_id_input, question_id_input, answer_choice],
+                    outputs=[answer_feedback, current_question_display, answer_choice, question_id_input]
+                )
+
+                get_hint_btn.click(
+                    fn=sync_get_quiz_hint,
+                    inputs=[session_id_input, question_id_input],
+                    outputs=[hint_output]
+                )
+
+                check_status_btn.click(
+                    fn=sync_get_quiz_session_status,
+                    inputs=[session_id_input],
+                    outputs=[quiz_stats_display]
+                )
+
+                # Instructions and Examples
+                with gr.Accordion("📖 How to Use Interactive Quizzes", open=False):
+                    gr.Markdown("""
+                    ### 🚀 Quick Start Guide
+
+                    **Step 1: Generate a Quiz**
+                    1. Enter a concept (e.g., "Linear Equations", "Photosynthesis")
+                    2. Set difficulty level (1-5)
+                    3. Click "Generate Quiz"
+
+                    **Step 2: Start Interactive Session**
+                    1. Enter your Student ID
+                    2. Click "Start Interactive Quiz"
+                    3. Copy the Session ID for tracking
+
+                    **Step 3: Answer Questions**
+                    1. Read the question displayed
+                    2. Select your answer from the options
+                    3. Click "Submit Answer" for immediate feedback
+                    4. Use "Get Hint" if you need help
+
+                    **Step 4: Track Progress**
+                    - Use "Check Status" to see your overall progress
+                    - View explanations for each answer
+                    - See your final score when completed
+
+                    ### 🎯 Features
+                    - **Immediate Feedback**: Get instant results for each answer
+                    - **Detailed Explanations**: Understand why answers are correct/incorrect
+                    - **Helpful Hints**: Get guidance when you're stuck
+                    - **Progress Tracking**: Monitor your performance throughout
+                    - **Adaptive Content**: Questions tailored to your difficulty level
+
+                    ### 💡 Tips
+                    - Read questions carefully before selecting answers
+                    - Use hints strategically to learn concepts
+                    - Review explanations to reinforce learning
+                    - Track your progress to identify improvement areas
+                    """)
+
+                gr.Markdown("---")
             
             # Tab 2: Advanced Features
             with gr.Tab("2 Advanced Features", elem_id="advanced_features_tab"):
@@ -688,24 +1025,36 @@ def create_gradio_interface():
 
                 # Connect lesson generation button
                 gen_lesson_btn.click(
-                    fn=generate_lesson_async,
+                    fn=sync_generate_lesson,
                     inputs=[topic_input, grade_input, duration_input],
                     outputs=[lesson_output]
                 )
 
                 gr.Markdown("## Learning Path Generation")
+                gr.Markdown("*Enhanced with adaptive learning capabilities*")
+
                 with gr.Row():
                     with gr.Column():
                         lp_student_id = gr.Textbox(label="Student ID", value=student_id)
                         lp_concept_ids = gr.Textbox(label="Concept IDs (comma-separated)", placeholder="e.g., python,functions,oop")
                         lp_student_level = gr.Dropdown(choices=["beginner", "intermediate", "advanced"], value="beginner", label="Student Level")
-                        lp_btn = gr.Button("Generate Learning Path")
+
+                        with gr.Row():
+                            lp_btn = gr.Button("Generate Basic Path")
+                            adaptive_lp_btn = gr.Button("Generate Adaptive Path", variant="primary")
+
                     with gr.Column():
                         lp_output = gr.JSON(label="Learning Path")
 
-                # Connect learning path generation button
+                # Connect learning path generation buttons
                 lp_btn.click(
-                    fn=on_generate_learning_path,
+                    fn=sync_generate_learning_path,
+                    inputs=[lp_student_id, lp_concept_ids, lp_student_level],
+                    outputs=[lp_output]
+                )
+
+                adaptive_lp_btn.click(
+                    fn=lambda sid, cids, _: sync_get_adaptive_learning_path(sid, cids, "adaptive", 10),
                     inputs=[lp_student_id, lp_concept_ids, lp_student_level],
                     outputs=[lp_output]
                 )
@@ -724,7 +1073,7 @@ def create_gradio_interface():
 
                 # Connect text interaction button
                 text_btn.click(
-                    fn=lambda text: text_interaction_async(text, student_id),
+                    fn=lambda text: sync_text_interaction(text, student_id),
                     inputs=[text_input],
                     outputs=[text_output]
                 )
@@ -740,15 +1089,185 @@ def create_gradio_interface():
 
                 # Connect document OCR button
                 doc_ocr_btn.click(
-                    fn=document_ocr_async,
+                    fn=sync_document_ocr,
                     inputs=[doc_input],
                     outputs=[doc_output]
                 )
             
-            # Tab 4: Data Analytics
-            with gr.Tab("4 Data Analytics", elem_id="data_analytics_tab"):
+            # Tab 4: Adaptive Learning
+            with gr.Tab("4 🧠 Adaptive Learning", elem_id="adaptive_learning_tab"):
+                gr.Markdown("## Adaptive Learning System")
+                gr.Markdown("Experience personalized learning with real-time adaptation based on your performance.")
+
+                with gr.Accordion("ℹ️ How It Works", open=False):
+                    gr.Markdown("""
+                    ### 🎯 Real-Time Adaptation
+                    - **Performance Tracking**: Monitor accuracy, time spent, and engagement
+                    - **Difficulty Adjustment**: Automatically adjust content difficulty based on performance
+                    - **Learning Path Optimization**: Personalize learning sequences based on your progress
+                    - **Mastery Detection**: Multi-indicator assessment of concept understanding
+
+                    ### 📊 Analytics & Insights
+                    - **Learning Patterns**: Detect your learning style and preferences
+                    - **Progress Monitoring**: Track milestones and achievements
+                    - **Predictive Recommendations**: Suggest next best concepts to learn
+
+                    ### 🚀 Getting Started
+                    1. Start an adaptive session with a concept you want to learn
+                    2. Record your learning events (answers, time taken, etc.)
+                    3. Get real-time recommendations for difficulty adjustments
+                    4. View your progress and mastery assessments
+                    """)
+
+                # Adaptive Learning Session Management
+                with gr.Accordion("📚 Learning Session Management", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            session_student_id = gr.Textbox(label="Student ID", value=student_id)
+                            session_concept_id = gr.Textbox(label="Concept ID", value="algebra_linear_equations")
+                            session_difficulty = gr.Slider(minimum=0.1, maximum=1.0, value=0.5, step=0.1, label="Initial Difficulty")
+                            start_session_btn = gr.Button("Start Adaptive Session", variant="primary")
+
+                        with gr.Column():
+                            session_output = gr.JSON(label="Session Status")
+
+                    # Record Learning Events
+                    with gr.Row():
+                        with gr.Column():
+                            event_session_id = gr.Textbox(label="Session ID", placeholder="Enter session ID from above")
+                            event_type = gr.Dropdown(
+                                choices=["answer_submitted", "hint_used", "session_pause", "session_resume"],
+                                value="answer_submitted",
+                                label="Event Type"
+                            )
+                            event_correct = gr.Checkbox(label="Answer Correct", value=True)
+                            event_time = gr.Number(label="Time Taken (seconds)", value=30)
+                            record_event_btn = gr.Button("Record Event")
+
+                        with gr.Column():
+                            event_output = gr.JSON(label="Event Response")
+
+                # Learning Path Optimization
+                with gr.Accordion("🛤️ Learning Path Optimization", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            opt_student_id = gr.Textbox(label="Student ID", value=student_id)
+                            opt_concepts = gr.Textbox(
+                                label="Target Concepts (comma-separated)",
+                                value="algebra_basics,linear_equations,quadratic_equations"
+                            )
+                            opt_strategy = gr.Dropdown(
+                                choices=["mastery_focused", "breadth_first", "depth_first", "adaptive", "remediation"],
+                                value="adaptive",
+                                label="Optimization Strategy"
+                            )
+                            opt_max_concepts = gr.Slider(minimum=3, maximum=15, value=8, step=1, label="Max Concepts")
+                            optimize_path_btn = gr.Button("Optimize Learning Path", variant="primary")
+
+                        with gr.Column():
+                            optimization_output = gr.JSON(label="Optimized Learning Path")
+
+                # Mastery Assessment
+                with gr.Accordion("🎓 Mastery Assessment", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            mastery_student_id = gr.Textbox(label="Student ID", value=student_id)
+                            mastery_concept_id = gr.Textbox(label="Concept ID", value="algebra_linear_equations")
+                            assess_mastery_btn = gr.Button("Assess Mastery", variant="primary")
+
+                        with gr.Column():
+                            mastery_output = gr.JSON(label="Mastery Assessment")
+
+                # Learning Analytics
+                with gr.Accordion("📊 Learning Analytics & Progress", open=True):
+                    with gr.Row():
+                        with gr.Column():
+                            analytics_student_id = gr.Textbox(label="Student ID", value=student_id)
+                            analytics_days = gr.Slider(minimum=7, maximum=90, value=30, step=7, label="Analysis Period (days)")
+                            get_analytics_btn = gr.Button("Get Learning Analytics")
+                            get_progress_btn = gr.Button("Get Progress Summary")
+
+                        with gr.Column():
+                            analytics_output = gr.JSON(label="Learning Analytics")
+                            progress_output = gr.JSON(label="Progress Summary")
+
+                # Connect all the buttons
+                start_session_btn.click(
+                    fn=sync_start_adaptive_session,
+                    inputs=[session_student_id, session_concept_id, session_difficulty],
+                    outputs=[session_output]
+                )
+
+                record_event_btn.click(
+                    fn=sync_record_learning_event,
+                    inputs=[session_student_id, session_concept_id, event_type, event_session_id, event_correct, event_time],
+                    outputs=[event_output]
+                )
+
+                optimize_path_btn.click(
+                    fn=sync_get_adaptive_learning_path,
+                    inputs=[opt_student_id, opt_concepts, opt_strategy, opt_max_concepts],
+                    outputs=[optimization_output]
+                )
+
+                assess_mastery_btn.click(
+                    fn=lambda sid, cid: sync_get_adaptive_recommendations(sid, cid),
+                    inputs=[mastery_student_id, mastery_concept_id],
+                    outputs=[mastery_output]
+                )
+
+                get_analytics_btn.click(
+                    fn=lambda sid, days: sync_get_progress_summary(sid, days),
+                    inputs=[analytics_student_id, analytics_days],
+                    outputs=[analytics_output]
+                )
+
+                get_progress_btn.click(
+                    fn=lambda sid: sync_get_progress_summary(sid, 7),
+                    inputs=[analytics_student_id],
+                    outputs=[progress_output]
+                )
+
+                # Examples and Tips
+                with gr.Accordion("💡 Examples & Tips", open=False):
+                    gr.Markdown("""
+                    ### 📝 Example Workflow
+
+                    **1. Start a Session:**
+                    - Student ID: `student_001`
+                    - Concept: `algebra_linear_equations`
+                    - Difficulty: `0.5` (medium)
+
+                    **2. Record Events:**
+                    - Answer submitted: correct=True, time=30s
+                    - Hint used: correct=False, time=45s
+
+                    **3. Get Recommendations:**
+                    - System suggests difficulty adjustments
+                    - Provides next concept suggestions
+
+                    **4. Optimize Learning Path:**
+                    - Target concepts: `algebra_basics,linear_equations,quadratic_equations`
+                    - Strategy: `adaptive` (recommended)
+
+                    ### 🎯 Optimization Strategies
+                    - **Mastery Focused**: Deep understanding before moving on
+                    - **Breadth First**: Cover many concepts quickly
+                    - **Depth First**: Thorough exploration of fewer concepts
+                    - **Adaptive**: System chooses best strategy for you
+                    - **Remediation**: Focus on filling knowledge gaps
+
+                    ### 📊 Understanding Analytics
+                    - **Learning Patterns**: Identifies your learning style
+                    - **Performance Trends**: Shows improvement over time
+                    - **Mastery Levels**: Tracks concept understanding
+                    - **Engagement Metrics**: Measures learning engagement
+                    """)
+
+            # Tab 5: Data Analytics
+            with gr.Tab("5 Data Analytics", elem_id="data_analytics_tab"):
                 gr.Markdown("## Plagiarism Detection")
-                
+
                 with gr.Row():
                     with gr.Column():
                         submission_input = gr.Textbox(
@@ -762,15 +1281,15 @@ def create_gradio_interface():
                             value="According to the quadratic formula, for any equation in the form ax² + bx + c = 0, the solutions are x = (-b ± √(b² - 4ac)) / 2a."
                         )
                         plagiarism_btn = gr.Button("Check Originality")
-                    
+
                     with gr.Column():
                         with gr.Group():
                             gr.Markdown("### 🔍 Originality Report")
                             plagiarism_output = gr.JSON(label="", show_label=False, container=False)
-                
+
                 # Connect the button to the plagiarism check function
                 plagiarism_btn.click(
-                    fn=check_plagiarism_async,
+                    fn=sync_check_plagiarism,
                     inputs=[submission_input, reference_input],
                     outputs=[plagiarism_output]
                 )

docs/ENHANCED_ADAPTIVE_LEARNING_GEMINI.md

@@ -0,0 +1,298 @@
+# Enhanced Adaptive Learning with Gemini Integration
+
+## Overview
+
+The TutorX MCP Server now features a comprehensive adaptive learning system powered by Google Gemini Flash models. This system provides intelligent, personalized learning experiences that adapt in real-time based on student performance, learning patterns, and preferences.
+
+## 🚀 Key Features
+
+### 1. **AI-Powered Content Generation**
+- Personalized explanations tailored to student's mastery level
+- Adaptive practice problems with appropriate difficulty
+- Contextual feedback based on performance history
+- Learning style adaptations (visual, auditory, kinesthetic, reading)
+
+### 2. **Intelligent Learning Pattern Analysis**
+- Deep analysis of student learning behaviors
+- Identification of optimal learning strategies
+- Engagement pattern recognition
+- Personalized study schedule recommendations
+
+### 3. **Smart Learning Path Optimization**
+- AI-driven learning path generation
+- Strategy-based path optimization (adaptive, mastery-focused, breadth-first, etc.)
+- Real-time difficulty progression
+- Milestone tracking and celebration
+
+### 4. **Comprehensive Performance Tracking**
+- Multi-dimensional mastery assessment
+- Accuracy and efficiency tracking
+- Time-based learning analytics
+- Progress trend analysis
+
+## 🛠️ Enhanced MCP Tools
+
+### Core Adaptive Learning Tools
+
+#### 1. `generate_adaptive_content`
+**Purpose**: Generate personalized learning content using Gemini
+**Parameters**:
+- `student_id`: Student identifier
+- `concept_id`: Target concept
+- `content_type`: "explanation", "practice", "feedback", "summary"
+- `difficulty_level`: 0.0 to 1.0
+- `learning_style`: "visual", "auditory", "kinesthetic", "reading"
+
+**Returns**: Personalized content with key points, analogies, and next steps
+
+#### 2. `analyze_learning_patterns`
+**Purpose**: AI-powered analysis of student learning patterns
+**Parameters**:
+- `student_id`: Student identifier
+- `analysis_days`: Number of days to analyze (default: 30)
+
+**Returns**: Comprehensive learning pattern analysis including:
+- Learning style identification
+- Strength and challenge areas
+- Optimal difficulty recommendations
+- Personalized learning strategies
+
+#### 3. `optimize_learning_strategy`
+**Purpose**: Comprehensive learning strategy optimization using Gemini
+**Parameters**:
+- `student_id`: Student identifier
+- `current_concept`: Current concept being studied
+- `performance_history`: Optional detailed history
+
+**Returns**: Optimized strategy with:
+- Primary learning approach
+- Session optimization recommendations
+- Motivation strategies
+- Success metrics
+
+#### 4. `start_adaptive_session`
+**Purpose**: Initialize an adaptive learning session
+**Parameters**:
+- `student_id`: Student identifier
+- `concept_id`: Target concept
+- `initial_difficulty`: Starting difficulty (0.0 to 1.0)
+
+**Returns**: Session ID and initial recommendations
+
+#### 5. `record_learning_event`
+**Purpose**: Record learning events for adaptive analysis
+**Parameters**:
+- `student_id`: Student identifier
+- `concept_id`: Target concept
+- `session_id`: Session identifier
+- `event_type`: "answer_correct", "answer_incorrect", "hint_used", "time_spent"
+- `event_data`: Additional event information
+
+**Returns**: Updated mastery levels and recommendations
+
+#### 6. `get_adaptive_recommendations`
+**Purpose**: Get AI-powered learning recommendations
+**Parameters**:
+- `student_id`: Student identifier
+- `concept_id`: Target concept
+- `session_id`: Optional session identifier
+
+**Returns**: Intelligent recommendations including:
+- Immediate actions with priorities
+- Difficulty adjustments
+- Learning strategies
+- Motivation boosters
+- Warning signs to watch for
+
+#### 7. `get_adaptive_learning_path`
+**Purpose**: Generate AI-optimized learning paths
+**Parameters**:
+- `student_id`: Student identifier
+- `target_concepts`: List of concept IDs
+- `strategy`: "adaptive", "mastery_focused", "breadth_first", "depth_first", "remediation"
+- `max_concepts`: Maximum concepts in path
+
+**Returns**: Comprehensive learning path with:
+- Step-by-step progression
+- Personalized time estimates
+- Learning objectives
+- Success criteria
+- Motivational elements
+
+#### 8. `get_student_progress_summary`
+**Purpose**: Comprehensive progress analysis
+**Parameters**:
+- `student_id`: Student identifier
+- `days`: Analysis period (default: 7)
+
+**Returns**: Detailed progress summary with analytics
+
+## 🧠 Gemini Integration Details
+
+### Model Configuration
+- **Primary Model**: Gemini 2.0 Flash
+- **Fallback Model**: Gemini 1.5 Flash (automatic fallback)
+- **Temperature**: 0.6-0.7 for balanced creativity and consistency
+- **Max Tokens**: 2048 for comprehensive responses
+
+### AI-Powered Features
+
+#### 1. **Personalized Content Generation**
+```python
+# Example: Generate adaptive explanation
+content = await generate_adaptive_content(
+    student_id="student_001",
+    concept_id="linear_equations",
+    content_type="explanation",
+    difficulty_level=0.6,
+    learning_style="visual"
+)
+```
+
+#### 2. **Learning Pattern Analysis**
+```python
+# Example: Analyze learning patterns
+patterns = await analyze_learning_patterns(
+    student_id="student_001",
+    analysis_days=30
+)
+```
+
+#### 3. **Strategy Optimization**
+```python
+# Example: Optimize learning strategy
+strategy = await optimize_learning_strategy(
+    student_id="student_001",
+    current_concept="quadratic_equations"
+)
+```
+
+## 📊 Performance Metrics
+
+### Mastery Assessment
+- **Accuracy Weight**: 60% - Proportion of correct answers
+- **Consistency Weight**: 20% - Stable performance over attempts
+- **Efficiency Weight**: 20% - Time effectiveness
+
+### Difficulty Adaptation
+- **Increase Threshold**: 80% accuracy → +0.1 difficulty
+- **Decrease Threshold**: 50% accuracy → -0.1 difficulty
+- **Range**: 0.2 to 1.0 (prevents too easy/hard content)
+
+### Learning Velocity
+- Concepts mastered per session
+- Time per concept completion
+- Engagement level indicators
+
+## 🎯 Learning Strategies
+
+### 1. **Adaptive Strategy** (Default)
+- AI-optimized balance of challenge and success
+- Real-time difficulty adjustment
+- Performance-driven progression
+
+### 2. **Mastery-Focused Strategy**
+- Deep understanding before advancement
+- High mastery thresholds (>0.8)
+- Comprehensive practice
+
+### 3. **Breadth-First Strategy**
+- Quick overview of many concepts
+- Lower mastery thresholds
+- Rapid progression
+
+### 4. **Depth-First Strategy**
+- Thorough exploration of fewer concepts
+- Extended practice time
+- Detailed understanding
+
+### 5. **Remediation Strategy**
+- Focus on knowledge gaps
+- Prerequisite reinforcement
+- Foundational skill building
+
+## 🔧 Integration with App.py
+
+The enhanced adaptive learning tools are fully integrated with the Gradio interface through synchronous wrapper functions:
+
+```python
+# Synchronous wrappers for Gradio compatibility
+sync_start_adaptive_session()
+sync_record_learning_event()
+sync_get_adaptive_recommendations()
+sync_get_adaptive_learning_path()
+sync_get_progress_summary()
+```
+
+## 🚀 Getting Started
+
+### 1. **Start an Adaptive Session**
+```python
+session = await start_adaptive_session(
+    student_id="student_001",
+    concept_id="algebra_basics",
+    initial_difficulty=0.5
+)
+```
+
+### 2. **Record Learning Events**
+```python
+event = await record_learning_event(
+    student_id="student_001",
+    concept_id="algebra_basics",
+    session_id=session["session_id"],
+    event_type="answer_correct",
+    event_data={"time_taken": 30}
+)
+```
+
+### 3. **Get AI Recommendations**
+```python
+recommendations = await get_adaptive_recommendations(
+    student_id="student_001",
+    concept_id="algebra_basics"
+)
+```
+
+### 4. **Generate Learning Path**
+```python
+path = await get_adaptive_learning_path(
+    student_id="student_001",
+    target_concepts=["algebra_basics", "linear_equations"],
+    strategy="adaptive",
+    max_concepts=5
+)
+```
+
+## 🎉 Benefits
+
+### For Students
+- **Personalized Learning**: Content adapted to individual needs
+- **Optimal Challenge**: Maintains engagement without frustration
+- **Real-time Feedback**: Immediate guidance and encouragement
+- **Progress Tracking**: Clear visibility of learning journey
+
+### For Educators
+- **Data-Driven Insights**: Comprehensive learning analytics
+- **Automated Adaptation**: Reduces manual intervention needs
+- **Scalable Personalization**: AI handles individual customization
+- **Evidence-Based Recommendations**: Gemini-powered insights
+
+### For Developers
+- **Modular Architecture**: Easy to extend and customize
+- **MCP Integration**: Seamless tool integration
+- **Fallback Mechanisms**: Robust error handling
+- **Comprehensive API**: Full-featured adaptive learning toolkit
+
+## 🔮 Future Enhancements
+
+- Multi-modal content generation (images, videos, interactive elements)
+- Advanced learning style detection
+- Collaborative learning features
+- Integration with external learning platforms
+- Real-time emotion and engagement detection
+- Predictive learning outcome modeling
+
+---
+
+*This enhanced adaptive learning system represents a significant advancement in AI-powered education, providing truly personalized learning experiences that adapt and evolve with each student's unique learning journey.*

docs/FIXES_SUMMARY.md

@@ -0,0 +1,176 @@
+# TutorX-MCP Adaptive Learning System - Fixes Summary
+
+## 🐛 Issues Fixed
+
+### 1. **RuntimeError: no running event loop**
+
+**Problem**: The progress monitor was trying to start an async monitoring loop during module import, but there was no event loop running at that time.
+
+**Solution**:
+- Modified `progress_monitor.py` to handle the case where no event loop is running
+- Added lazy initialization in `adaptive_learning_tools.py`
+- Created `ensure_monitoring_started()` function that safely starts monitoring when needed
+
+**Files Changed**:
+- `mcp_server/analytics/progress_monitor.py`
+- `mcp_server/tools/adaptive_learning_tools.py`
+
+### 2. **Import Path Issues in server.py**
+
+**Problem**: Some imports in `server.py` were using incorrect relative paths.
+
+**Solution**:
+- Fixed import paths to use proper `mcp_server.tools.*` format
+- Updated all tool imports to be consistent
+
+**Files Changed**:
+- `mcp_server/server.py`
+
+### 3. **Missing Concept Graph Fallback**
+
+**Problem**: The path optimizer relied on concept graph import that might not be available.
+
+**Solution**:
+- Added try/except block for concept graph import
+- Created fallback concept graph with basic concepts for testing
+- Ensures system works even if concept graph is not available
+
+**Files Changed**:
+- `mcp_server/algorithms/path_optimizer.py`
+
+## ✅ **Fixes Applied**
+
+### **1. Progress Monitor Safe Initialization**
+
+```python
+def start_monitoring(self, check_interval_minutes: int = 5):
+    """Start real-time progress monitoring."""
+    self.monitoring_active = True
+    try:
+        # Try to create task in current event loop
+        asyncio.create_task(self._monitoring_loop(check_interval_minutes))
+    except RuntimeError:
+        # No event loop running, will start monitoring when first called
+        pass
+```
+
+### **2. Lazy Monitoring Startup**
+
+```python
+def ensure_monitoring_started():
+    """Ensure progress monitoring is started (called lazily when needed)"""
+    global _monitoring_started
+    if not _monitoring_started:
+        try:
+            # Check if we're in an async context
+            loop = asyncio.get_running_loop()
+            if loop and not loop.is_closed():
+                progress_monitor.start_monitoring()
+                _monitoring_started = True
+        except RuntimeError:
+            # No event loop running yet, monitoring will start later
+            pass
+```
+
+### **3. Concept Graph Fallback**
+
+```python
+# Try to import concept graph, use fallback if not available
+try:
+    from ..resources.concept_graph import CONCEPT_GRAPH
+except ImportError:
+    # Fallback concept graph for basic functionality
+    CONCEPT_GRAPH = {
+        "algebra_basics": {"name": "Algebra Basics", "prerequisites": []},
+        "linear_equations": {"name": "Linear Equations", "prerequisites": ["algebra_basics"]},
+        # ... more concepts
+    }
+```
+
+### **4. Fixed Import Paths**
+
+```python
+# Before (incorrect)
+from tools.concept_tools import assess_skill_tool
+
+# After (correct)
+from mcp_server.tools.concept_tools import assess_skill_tool
+```
+
+## 🧪 **Testing**
+
+### **Test Script Created**: `test_import.py`
+
+This script tests:
+1. All adaptive learning imports
+2. Component initialization
+3. Basic functionality
+4. Storage operations
+
+### **Usage**:
+```bash
+python test_import.py
+```
+
+## 🚀 **System Status**
+
+### **✅ Fixed Issues**:
+- ❌ RuntimeError: no running event loop → ✅ **FIXED**
+- ❌ Import path errors → ✅ **FIXED**
+- ❌ Missing concept graph dependency → ✅ **FIXED**
+
+### **✅ System Ready**:
+- All imports work correctly
+- Components initialize properly
+- Monitoring starts safely when needed
+- Fallback systems in place
+
+## 🔧 **How to Verify the Fix**
+
+### **1. Test Imports**:
+```bash
+python test_import.py
+```
+
+### **2. Start the Server**:
+```bash
+python -m mcp_server.server
+```
+
+### **3. Run the App**:
+```bash
+python app.py
+```
+
+### **4. Test Adaptive Learning**:
+- Navigate to the "🧠 Adaptive Learning" tab
+- Try starting an adaptive session
+- Record some learning events
+- View analytics and progress
+
+## 📋 **Key Changes Summary**
+
+| Component | Issue | Fix |
+|-----------|-------|-----|
+| Progress Monitor | Event loop error | Safe async initialization |
+| Adaptive Tools | Import timing | Lazy monitoring startup |
+| Path Optimizer | Missing dependency | Fallback concept graph |
+| Server | Import paths | Corrected import statements |
+
+## 🎯 **Next Steps**
+
+1. **Test the system** using `test_import.py`
+2. **Start the server** and verify no errors
+3. **Run the app** and test adaptive learning features
+4. **Monitor performance** and adjust as needed
+
+The adaptive learning system is now properly integrated and should work without the previous runtime errors. All components have been tested for safe initialization and proper error handling.
+
+## 🔄 **Rollback Plan**
+
+If any issues arise, you can:
+1. Comment out the adaptive learning tools import in `server.py`
+2. Use the original learning path tools without adaptive features
+3. The system will continue to work with existing functionality
+
+The fixes are designed to be non-breaking and maintain backward compatibility with existing features.

docs/NEW_ADAPTIVE_LEARNING_README.md

@@ -0,0 +1,159 @@
+# 🧠 New Adaptive Learning System
+
+## Overview
+
+The new adaptive learning system has been completely redesigned and integrated directly into the existing Learning Path Generation module. This provides a cleaner, more maintainable, and more focused approach to adaptive learning.
+
+## Key Changes
+
+### ✅ What Was Removed
+- **Complex Analytics Module**: Removed `mcp_server/analytics/` directory with performance tracking, learning analytics, and progress monitoring
+- **Complex Algorithms Module**: Removed `mcp_server/algorithms/` directory with adaptive engine, difficulty adjuster, path optimizer, and mastery detector
+- **Standalone Adaptive Tools**: Removed `mcp_server/tools/adaptive_learning_tools.py`
+- **Documentation Files**: Removed old documentation files that described the complex system
+
+### ✅ What Was Added
+- **Integrated Adaptive Learning**: New adaptive learning capabilities built directly into `learning_path_tools.py`
+- **Simplified Data Structures**: Clean, focused data structures for student performance and learning events
+- **Essential MCP Tools**: Core adaptive learning tools that provide real value without complexity
+
+## New Architecture
+
+### Data Structures
+```python
+@dataclass
+class StudentPerformance:
+    student_id: str
+    concept_id: str
+    accuracy_rate: float = 0.0
+    time_spent_minutes: float = 0.0
+    attempts_count: int = 0
+    mastery_level: float = 0.0
+    last_accessed: datetime = None
+    difficulty_preference: float = 0.5
+
+@dataclass
+class LearningEvent:
+    student_id: str
+    concept_id: str
+    event_type: str  # 'answer_correct', 'answer_incorrect', 'hint_used', 'time_spent'
+    timestamp: datetime
+    data: Dict[str, Any]
+```
+
+### Available MCP Tools
+
+#### 1. `start_adaptive_session`
+Start an adaptive learning session for a student.
+- **Input**: student_id, concept_id, initial_difficulty
+- **Output**: Session information and initial recommendations
+
+#### 2. `record_learning_event`
+Record learning events for adaptive analysis.
+- **Input**: student_id, concept_id, session_id, event_type, event_data
+- **Output**: Event confirmation and updated recommendations
+
+#### 3. `get_adaptive_recommendations`
+Get adaptive learning recommendations for a student.
+- **Input**: student_id, concept_id, session_id (optional)
+- **Output**: Personalized recommendations based on performance
+
+#### 4. `get_adaptive_learning_path`
+Generate an adaptive learning path based on student performance.
+- **Input**: student_id, target_concepts, strategy, max_concepts
+- **Output**: Optimized learning path with adaptive features
+
+#### 5. `get_student_progress_summary`
+Get comprehensive progress summary for a student.
+- **Input**: student_id, days
+- **Output**: Progress analytics and recommendations
+
+## Features
+
+### 🎯 Real-Time Adaptation
+- **Performance Tracking**: Monitor accuracy, time spent, and attempts
+- **Difficulty Adjustment**: Automatically adjust based on performance
+- **Mastery Detection**: Multi-indicator assessment of understanding
+
+### 📊 Learning Analytics
+- **Progress Monitoring**: Track learning progress over time
+- **Pattern Recognition**: Identify learning patterns and preferences
+- **Personalized Recommendations**: Tailored suggestions for improvement
+
+### 🛤️ Adaptive Learning Paths
+- **Strategy-Based Optimization**: Multiple learning strategies available
+- **Prerequisite Management**: Intelligent concept sequencing
+- **Time Estimation**: Personalized time estimates based on performance
+
+## Usage Examples
+
+### Starting a Session
+```python
+session = await start_adaptive_session(
+    student_id="student_001",
+    concept_id="algebra_linear_equations",
+    initial_difficulty=0.5
+)
+```
+
+### Recording Events
+```python
+await record_learning_event(
+    student_id="student_001",
+    concept_id="algebra_linear_equations",
+    session_id=session_id,
+    event_type="answer_correct",
+    event_data={"time_taken": 30}
+)
+```
+
+### Getting Recommendations
+```python
+recommendations = await get_adaptive_recommendations(
+    student_id="student_001",
+    concept_id="algebra_linear_equations"
+)
+```
+
+### Generating Adaptive Learning Path
+```python
+path = await get_adaptive_learning_path(
+    student_id="student_001",
+    target_concepts=["algebra_basics", "linear_equations"],
+    strategy="adaptive",
+    max_concepts=5
+)
+```
+
+## Integration with App
+
+The new system is fully integrated into the existing Gradio app with:
+- **Enhanced Learning Path Generation**: Adaptive path generation alongside basic paths
+- **Adaptive Learning Tab**: Dedicated UI for adaptive learning features
+- **Seamless Integration**: Works with existing concept graph and quiz tools
+
+## Benefits
+
+### 🚀 Simplified Architecture
+- **Single Module**: All adaptive learning in one focused module
+- **Reduced Complexity**: Eliminated unnecessary abstractions
+- **Better Maintainability**: Easier to understand and modify
+
+### 🎯 Focused Features
+- **Essential Functionality**: Only the most valuable adaptive features
+- **Real-World Applicability**: Features that actually improve learning
+- **Performance Optimized**: Lightweight and fast
+
+### 🔧 Easy Integration
+- **Existing Workflow**: Integrates with current learning path generation
+- **Backward Compatible**: Doesn't break existing functionality
+- **Future Ready**: Easy to extend with new features
+
+## Testing
+
+Run the test script to verify the new implementation:
+```bash
+python test_new_adaptive_learning.py
+```
+
+This will test all the core adaptive learning functions and demonstrate the system's capabilities.

mcp_server/models/__init__.py

@@ -0,0 +1,25 @@
+"""
+Data models for TutorX-MCP adaptive learning system.
+
+This module provides data models for:
+- Student profiles
+- Performance metrics
+- Learning sessions
+- Adaptive learning data structures
+"""
+
+from .student_profile import StudentProfile, LearningStyle, LearningPreferences
+from .performance_metrics import PerformanceMetrics, SessionMetrics, ConceptMetrics
+from .learning_session import LearningSession, SessionState, SessionEvent
+
+__all__ = [
+    'StudentProfile',
+    'LearningStyle', 
+    'LearningPreferences',
+    'PerformanceMetrics',
+    'SessionMetrics',
+    'ConceptMetrics',
+    'LearningSession',
+    'SessionState',
+    'SessionEvent'
+]

mcp_server/models/student_profile.py

@@ -0,0 +1,329 @@
+"""
+Student profile data models for TutorX-MCP.
+
+This module defines data structures for storing and managing
+student learning profiles, preferences, and characteristics.
+"""
+
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, field
+from enum import Enum
+import json
+
+
+class LearningStyle(Enum):
+    """Learning style preferences."""
+    VISUAL = "visual"
+    AUDITORY = "auditory"
+    KINESTHETIC = "kinesthetic"
+    READING_WRITING = "reading_writing"
+    MULTIMODAL = "multimodal"
+
+
+class LearningPace(Enum):
+    """Learning pace preferences."""
+    SLOW = "slow"
+    MODERATE = "moderate"
+    FAST = "fast"
+    ADAPTIVE = "adaptive"
+
+
+class DifficultyPreference(Enum):
+    """Difficulty progression preferences."""
+    GRADUAL = "gradual"
+    MODERATE = "moderate"
+    AGGRESSIVE = "aggressive"
+    ADAPTIVE = "adaptive"
+
+
+class FeedbackPreference(Enum):
+    """Feedback delivery preferences."""
+    IMMEDIATE = "immediate"
+    DELAYED = "delayed"
+    SUMMARY = "summary"
+    MINIMAL = "minimal"
+
+
+@dataclass
+class LearningPreferences:
+    """Student learning preferences and settings."""
+    learning_style: LearningStyle = LearningStyle.MULTIMODAL
+    learning_pace: LearningPace = LearningPace.ADAPTIVE
+    difficulty_preference: DifficultyPreference = DifficultyPreference.ADAPTIVE
+    feedback_preference: FeedbackPreference = FeedbackPreference.IMMEDIATE
+    
+    # Session preferences
+    preferred_session_length: int = 30  # minutes
+    max_session_length: int = 60  # minutes
+    break_frequency: int = 20  # minutes between breaks
+    
+    # Content preferences
+    gamification_enabled: bool = True
+    hints_enabled: bool = True
+    explanations_enabled: bool = True
+    examples_enabled: bool = True
+    
+    # Notification preferences
+    reminders_enabled: bool = True
+    progress_notifications: bool = True
+    achievement_notifications: bool = True
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'learning_style': self.learning_style.value,
+            'learning_pace': self.learning_pace.value,
+            'difficulty_preference': self.difficulty_preference.value,
+            'feedback_preference': self.feedback_preference.value,
+            'preferred_session_length': self.preferred_session_length,
+            'max_session_length': self.max_session_length,
+            'break_frequency': self.break_frequency,
+            'gamification_enabled': self.gamification_enabled,
+            'hints_enabled': self.hints_enabled,
+            'explanations_enabled': self.explanations_enabled,
+            'examples_enabled': self.examples_enabled,
+            'reminders_enabled': self.reminders_enabled,
+            'progress_notifications': self.progress_notifications,
+            'achievement_notifications': self.achievement_notifications
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'LearningPreferences':
+        """Create from dictionary."""
+        return cls(
+            learning_style=LearningStyle(data.get('learning_style', 'multimodal')),
+            learning_pace=LearningPace(data.get('learning_pace', 'adaptive')),
+            difficulty_preference=DifficultyPreference(data.get('difficulty_preference', 'adaptive')),
+            feedback_preference=FeedbackPreference(data.get('feedback_preference', 'immediate')),
+            preferred_session_length=data.get('preferred_session_length', 30),
+            max_session_length=data.get('max_session_length', 60),
+            break_frequency=data.get('break_frequency', 20),
+            gamification_enabled=data.get('gamification_enabled', True),
+            hints_enabled=data.get('hints_enabled', True),
+            explanations_enabled=data.get('explanations_enabled', True),
+            examples_enabled=data.get('examples_enabled', True),
+            reminders_enabled=data.get('reminders_enabled', True),
+            progress_notifications=data.get('progress_notifications', True),
+            achievement_notifications=data.get('achievement_notifications', True)
+        )
+
+
+@dataclass
+class StudentGoals:
+    """Student learning goals and objectives."""
+    target_concepts: List[str] = field(default_factory=list)
+    target_mastery_level: float = 0.8
+    target_completion_date: Optional[datetime] = None
+    daily_time_goal: int = 30  # minutes per day
+    weekly_concept_goal: int = 2  # concepts per week
+    
+    # Long-term goals
+    grade_level_target: Optional[str] = None
+    subject_focus_areas: List[str] = field(default_factory=list)
+    career_interests: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'target_concepts': self.target_concepts,
+            'target_mastery_level': self.target_mastery_level,
+            'target_completion_date': self.target_completion_date.isoformat() if self.target_completion_date else None,
+            'daily_time_goal': self.daily_time_goal,
+            'weekly_concept_goal': self.weekly_concept_goal,
+            'grade_level_target': self.grade_level_target,
+            'subject_focus_areas': self.subject_focus_areas,
+            'career_interests': self.career_interests
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'StudentGoals':
+        """Create from dictionary."""
+        target_date = None
+        if data.get('target_completion_date'):
+            target_date = datetime.fromisoformat(data['target_completion_date'])
+        
+        return cls(
+            target_concepts=data.get('target_concepts', []),
+            target_mastery_level=data.get('target_mastery_level', 0.8),
+            target_completion_date=target_date,
+            daily_time_goal=data.get('daily_time_goal', 30),
+            weekly_concept_goal=data.get('weekly_concept_goal', 2),
+            grade_level_target=data.get('grade_level_target'),
+            subject_focus_areas=data.get('subject_focus_areas', []),
+            career_interests=data.get('career_interests', [])
+        )
+
+
+@dataclass
+class StudentProfile:
+    """Comprehensive student learning profile."""
+    student_id: str
+    name: Optional[str] = None
+    grade_level: Optional[str] = None
+    age: Optional[int] = None
+    
+    # Learning characteristics
+    preferences: LearningPreferences = field(default_factory=LearningPreferences)
+    goals: StudentGoals = field(default_factory=StudentGoals)
+    
+    # Profile metadata
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    last_updated: datetime = field(default_factory=datetime.utcnow)
+    last_active: Optional[datetime] = None
+    
+    # Adaptive learning state
+    current_difficulty_level: float = 0.5
+    learning_velocity: float = 0.0  # concepts per day
+    engagement_level: float = 0.5
+    
+    # Performance summary
+    total_concepts_attempted: int = 0
+    total_concepts_mastered: int = 0
+    total_learning_time: int = 0  # minutes
+    average_accuracy: float = 0.0
+    
+    # Strengths and challenges
+    strength_areas: List[str] = field(default_factory=list)
+    challenge_areas: List[str] = field(default_factory=list)
+    
+    # Adaptive learning insights
+    learning_patterns: List[str] = field(default_factory=list)
+    recommended_strategies: List[str] = field(default_factory=list)
+    
+    def update_last_active(self):
+        """Update last active timestamp."""
+        self.last_active = datetime.utcnow()
+        self.last_updated = datetime.utcnow()
+    
+    def update_performance_summary(self, concepts_attempted: int, concepts_mastered: int,
+                                 learning_time: int, accuracy: float):
+        """Update performance summary statistics."""
+        self.total_concepts_attempted = concepts_attempted
+        self.total_concepts_mastered = concepts_mastered
+        self.total_learning_time = learning_time
+        self.average_accuracy = accuracy
+        self.last_updated = datetime.utcnow()
+    
+    def calculate_mastery_rate(self) -> float:
+        """Calculate overall mastery rate."""
+        if self.total_concepts_attempted == 0:
+            return 0.0
+        return self.total_concepts_mastered / self.total_concepts_attempted
+    
+    def calculate_daily_average_time(self, days: int = 30) -> float:
+        """Calculate average daily learning time over specified period."""
+        if days <= 0:
+            return 0.0
+        
+        # This would need to be calculated from actual session data
+        # For now, return a simple estimate
+        return self.total_learning_time / max(1, days)
+    
+    def is_active_learner(self, days: int = 7) -> bool:
+        """Check if student has been active in recent days."""
+        if not self.last_active:
+            return False
+        
+        cutoff_date = datetime.utcnow() - timedelta(days=days)
+        return self.last_active >= cutoff_date
+    
+    def get_learning_efficiency(self) -> float:
+        """Calculate learning efficiency (mastery per hour)."""
+        if self.total_learning_time == 0:
+            return 0.0
+        
+        hours = self.total_learning_time / 60.0
+        return self.total_concepts_mastered / hours
+    
+    def add_strength_area(self, area: str):
+        """Add a strength area if not already present."""
+        if area not in self.strength_areas:
+            self.strength_areas.append(area)
+            self.last_updated = datetime.utcnow()
+    
+    def add_challenge_area(self, area: str):
+        """Add a challenge area if not already present."""
+        if area not in self.challenge_areas:
+            self.challenge_areas.append(area)
+            self.last_updated = datetime.utcnow()
+    
+    def add_learning_pattern(self, pattern: str):
+        """Add a detected learning pattern."""
+        if pattern not in self.learning_patterns:
+            self.learning_patterns.append(pattern)
+            self.last_updated = datetime.utcnow()
+    
+    def add_recommended_strategy(self, strategy: str):
+        """Add a recommended learning strategy."""
+        if strategy not in self.recommended_strategies:
+            self.recommended_strategies.append(strategy)
+            self.last_updated = datetime.utcnow()
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            'student_id': self.student_id,
+            'name': self.name,
+            'grade_level': self.grade_level,
+            'age': self.age,
+            'preferences': self.preferences.to_dict(),
+            'goals': self.goals.to_dict(),
+            'created_at': self.created_at.isoformat(),
+            'last_updated': self.last_updated.isoformat(),
+            'last_active': self.last_active.isoformat() if self.last_active else None,
+            'current_difficulty_level': self.current_difficulty_level,
+            'learning_velocity': self.learning_velocity,
+            'engagement_level': self.engagement_level,
+            'total_concepts_attempted': self.total_concepts_attempted,
+            'total_concepts_mastered': self.total_concepts_mastered,
+            'total_learning_time': self.total_learning_time,
+            'average_accuracy': self.average_accuracy,
+            'strength_areas': self.strength_areas,
+            'challenge_areas': self.challenge_areas,
+            'learning_patterns': self.learning_patterns,
+            'recommended_strategies': self.recommended_strategies
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'StudentProfile':
+        """Create from dictionary."""
+        created_at = datetime.fromisoformat(data['created_at']) if data.get('created_at') else datetime.utcnow()
+        last_updated = datetime.fromisoformat(data['last_updated']) if data.get('last_updated') else datetime.utcnow()
+        last_active = datetime.fromisoformat(data['last_active']) if data.get('last_active') else None
+        
+        preferences = LearningPreferences.from_dict(data.get('preferences', {}))
+        goals = StudentGoals.from_dict(data.get('goals', {}))
+        
+        return cls(
+            student_id=data['student_id'],
+            name=data.get('name'),
+            grade_level=data.get('grade_level'),
+            age=data.get('age'),
+            preferences=preferences,
+            goals=goals,
+            created_at=created_at,
+            last_updated=last_updated,
+            last_active=last_active,
+            current_difficulty_level=data.get('current_difficulty_level', 0.5),
+            learning_velocity=data.get('learning_velocity', 0.0),
+            engagement_level=data.get('engagement_level', 0.5),
+            total_concepts_attempted=data.get('total_concepts_attempted', 0),
+            total_concepts_mastered=data.get('total_concepts_mastered', 0),
+            total_learning_time=data.get('total_learning_time', 0),
+            average_accuracy=data.get('average_accuracy', 0.0),
+            strength_areas=data.get('strength_areas', []),
+            challenge_areas=data.get('challenge_areas', []),
+            learning_patterns=data.get('learning_patterns', []),
+            recommended_strategies=data.get('recommended_strategies', [])
+        )
+    
+    def to_json(self) -> str:
+        """Convert to JSON string."""
+        return json.dumps(self.to_dict(), indent=2)
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> 'StudentProfile':
+        """Create from JSON string."""
+        data = json.loads(json_str)
+        return cls.from_dict(data)

mcp_server/prompts/quiz_generation.txt

@@ -1,25 +1,42 @@
-You are an expert quiz generator. Create a quiz about the following concept:
+You are an expert quiz generator. Create an interactive quiz about the following concept:
 
 Concept: {concept}
 Difficulty: {difficulty}
 
 Generate a quiz with the following structure:
 1. Multiple choice questions (3-5 questions)
-2. Each question should have 4 options
-3. Include the correct answer
-4. Add a brief explanation for each answer
+2. Each question should have 4 options labeled A), B), C), D)
+3. Include the correct answer with the label (e.g., "A) ...")
+4. Add a detailed explanation for why the correct answer is right and why others are wrong
+5. Include a helpful hint for each question
 
 Return the quiz in the following JSON format:
 {{
-  "quiz_title": "Quiz about [Concept]",
+  "quiz_id": "unique_quiz_id",
+  "quiz_title": "Interactive Quiz: [Concept]",
+  "concept": "{concept}",
+  "difficulty": "{difficulty}",
   "questions": [
     {{
-      "question": "...",
-      "options": ["...", "...", "...", "..."],
-      "correct_answer": "...",
-      "explanation": "..."
+      "question_id": "q1",
+      "question": "Clear, specific question text...",
+      "options": [
+        "A) First option",
+        "B) Second option",
+        "C) Third option",
+        "D) Fourth option"
+      ],
+      "correct_answer": "A) First option",
+      "explanation": "Detailed explanation of why A is correct. Also explain why B, C, and D are incorrect to help students understand the concept better.",
+      "hint": "A helpful hint that guides students toward the correct answer without giving it away directly."
     }}
   ]
 }}
 
-Make sure the quiz is appropriate for {difficulty} difficulty level.
+Requirements:
+- Make sure the quiz is appropriate for {difficulty} difficulty level
+- Questions should test understanding, not just memorization
+- Explanations should be educational and help students learn
+- Hints should be subtle but helpful
+- Use clear, unambiguous language
+- Ensure all options are plausible but only one is clearly correct

mcp_server/server.py

@@ -58,6 +58,7 @@ from mcp_server.tools import ocr_tools
 from mcp_server.tools import learning_path_tools
 from mcp_server.tools import concept_graph_tools
 
+
 # Mount the SSE transport for MCP at '/sse/' (with trailing slash)
 api_app.mount("/sse", mcp.sse_app())
 
@@ -163,7 +164,7 @@ async def learning_path_endpoint(request: dict):
     )
 
 # API endpoints - Assess Skill
-from tools.concept_tools import assess_skill_tool
+from mcp_server.tools.concept_tools import assess_skill_tool
 @api_app.post("/api/assess-skill")
 async def assess_skill_endpoint(request: dict):
     student_id = request.get("student_id")
@@ -173,7 +174,7 @@ async def assess_skill_endpoint(request: dict):
     return await assess_skill_tool(student_id, concept_id)
 
 # API endpoints - Generate Lesson
-from tools.lesson_tools import generate_lesson_tool
+from mcp_server.tools.lesson_tools import generate_lesson_tool
 @api_app.post("/api/generate-lesson")
 async def generate_lesson_endpoint(request: dict):
     topic = request.get("topic")
@@ -184,7 +185,14 @@ async def generate_lesson_endpoint(request: dict):
     return await generate_lesson_tool(topic, grade_level, duration_minutes)
 
 # API endpoints - Generate Quiz
-from tools.quiz_tools import generate_quiz_tool
+from mcp_server.tools.quiz_tools import (
+    generate_quiz_tool,
+    start_interactive_quiz_tool,
+    submit_quiz_answer_tool,
+    get_quiz_hint_tool,
+    get_quiz_session_status_tool
+)
+
 @api_app.post("/api/generate-quiz")
 async def generate_quiz_endpoint(request: dict):
     concept = request.get("concept", "")
@@ -202,6 +210,38 @@ async def generate_quiz_endpoint(request: dict):
         difficulty = "medium"
     return await generate_quiz_tool(concept.strip(), difficulty)
 
+@api_app.post("/api/start-interactive-quiz")
+async def start_interactive_quiz_endpoint(request: dict):
+    quiz_data = request.get("quiz_data")
+    student_id = request.get("student_id", "anonymous")
+    if not quiz_data:
+        raise HTTPException(status_code=400, detail="quiz_data is required")
+    return await start_interactive_quiz_tool(quiz_data, student_id)
+
+@api_app.post("/api/submit-quiz-answer")
+async def submit_quiz_answer_endpoint(request: dict):
+    session_id = request.get("session_id")
+    question_id = request.get("question_id")
+    selected_answer = request.get("selected_answer")
+    if not all([session_id, question_id, selected_answer]):
+        raise HTTPException(status_code=400, detail="session_id, question_id, and selected_answer are required")
+    return await submit_quiz_answer_tool(session_id, question_id, selected_answer)
+
+@api_app.post("/api/get-quiz-hint")
+async def get_quiz_hint_endpoint(request: dict):
+    session_id = request.get("session_id")
+    question_id = request.get("question_id")
+    if not all([session_id, question_id]):
+        raise HTTPException(status_code=400, detail="session_id and question_id are required")
+    return await get_quiz_hint_tool(session_id, question_id)
+
+@api_app.post("/api/get-quiz-session-status")
+async def get_quiz_session_status_endpoint(request: dict):
+    session_id = request.get("session_id")
+    if not session_id:
+        raise HTTPException(status_code=400, detail="session_id is required")
+    return await get_quiz_session_status_tool(session_id)
+
 # Entrypoint for running with MCP SSE transport
 if __name__ == "__main__":
     mcp.run(transport="sse")

mcp_server/storage/__init__.py

@@ -0,0 +1,14 @@
+"""
+Storage layer for TutorX-MCP adaptive learning system.
+
+This module provides data persistence and session management
+for the adaptive learning components.
+"""
+
+from .memory_store import MemoryStore
+from .session_manager import SessionManager
+
+__all__ = [
+    'MemoryStore',
+    'SessionManager'
+]

mcp_server/storage/memory_store.py

@@ -0,0 +1,425 @@
+"""
+In-memory storage implementation for TutorX-MCP.
+
+This module provides in-memory storage for development and testing.
+In production, this would be replaced with database-backed storage.
+"""
+
+import json
+import pickle
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any, Union
+from pathlib import Path
+import threading
+from collections import defaultdict
+
+from ..models.student_profile import StudentProfile
+
+
+class MemoryStore:
+    """
+    In-memory storage implementation for adaptive learning data.
+    
+    This provides a simple storage layer for development and testing.
+    In production, this would be replaced with a proper database.
+    """
+    
+    def __init__(self, persistence_file: Optional[str] = None):
+        """
+        Initialize the memory store.
+        
+        Args:
+            persistence_file: Optional file path for data persistence
+        """
+        self.persistence_file = persistence_file
+        self._lock = threading.RLock()
+        
+        # Storage containers
+        self.student_profiles: Dict[str, StudentProfile] = {}
+        self.performance_data: Dict[str, Dict[str, Any]] = defaultdict(dict)
+        self.session_data: Dict[str, Dict[str, Any]] = {}
+        self.analytics_cache: Dict[str, Dict[str, Any]] = defaultdict(dict)
+        self.adaptation_history: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+        
+        # Load persisted data if available
+        if self.persistence_file:
+            self._load_from_file()
+    
+    def _load_from_file(self):
+        """Load data from persistence file."""
+        try:
+            if Path(self.persistence_file).exists():
+                with open(self.persistence_file, 'rb') as f:
+                    data = pickle.load(f)
+                    
+                self.student_profiles = data.get('student_profiles', {})
+                self.performance_data = data.get('performance_data', defaultdict(dict))
+                self.session_data = data.get('session_data', {})
+                self.analytics_cache = data.get('analytics_cache', defaultdict(dict))
+                self.adaptation_history = data.get('adaptation_history', defaultdict(list))
+                
+                print(f"Loaded data from {self.persistence_file}")
+        except Exception as e:
+            print(f"Error loading data from {self.persistence_file}: {e}")
+    
+    def _save_to_file(self):
+        """Save data to persistence file."""
+        if not self.persistence_file:
+            return
+        
+        try:
+            data = {
+                'student_profiles': self.student_profiles,
+                'performance_data': dict(self.performance_data),
+                'session_data': self.session_data,
+                'analytics_cache': dict(self.analytics_cache),
+                'adaptation_history': dict(self.adaptation_history)
+            }
+            
+            with open(self.persistence_file, 'wb') as f:
+                pickle.dump(data, f)
+                
+        except Exception as e:
+            print(f"Error saving data to {self.persistence_file}: {e}")
+    
+    # Student Profile Operations
+    def save_student_profile(self, profile: StudentProfile) -> bool:
+        """Save a student profile."""
+        with self._lock:
+            try:
+                self.student_profiles[profile.student_id] = profile
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error saving student profile: {e}")
+                return False
+    
+    def get_student_profile(self, student_id: str) -> Optional[StudentProfile]:
+        """Get a student profile by ID."""
+        with self._lock:
+            return self.student_profiles.get(student_id)
+    
+    def update_student_profile(self, student_id: str, updates: Dict[str, Any]) -> bool:
+        """Update a student profile with new data."""
+        with self._lock:
+            try:
+                if student_id not in self.student_profiles:
+                    return False
+                
+                profile = self.student_profiles[student_id]
+                
+                # Update profile attributes
+                for key, value in updates.items():
+                    if hasattr(profile, key):
+                        setattr(profile, key, value)
+                
+                profile.last_updated = datetime.utcnow()
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error updating student profile: {e}")
+                return False
+    
+    def delete_student_profile(self, student_id: str) -> bool:
+        """Delete a student profile."""
+        with self._lock:
+            try:
+                if student_id in self.student_profiles:
+                    del self.student_profiles[student_id]
+                    self._save_to_file()
+                    return True
+                return False
+            except Exception as e:
+                print(f"Error deleting student profile: {e}")
+                return False
+    
+    def list_student_profiles(self, active_only: bool = False, 
+                            days: int = 30) -> List[StudentProfile]:
+        """List student profiles, optionally filtering by activity."""
+        with self._lock:
+            profiles = list(self.student_profiles.values())
+            
+            if active_only:
+                cutoff_date = datetime.utcnow() - timedelta(days=days)
+                profiles = [
+                    p for p in profiles 
+                    if p.last_active and p.last_active >= cutoff_date
+                ]
+            
+            return profiles
+    
+    # Performance Data Operations
+    def save_performance_data(self, student_id: str, concept_id: str, 
+                            data: Dict[str, Any]) -> bool:
+        """Save performance data for a student and concept."""
+        with self._lock:
+            try:
+                if student_id not in self.performance_data:
+                    self.performance_data[student_id] = {}
+                
+                self.performance_data[student_id][concept_id] = {
+                    **data,
+                    'last_updated': datetime.utcnow().isoformat()
+                }
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error saving performance data: {e}")
+                return False
+    
+    def get_performance_data(self, student_id: str, 
+                           concept_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Get performance data for a student and optionally a specific concept."""
+        with self._lock:
+            if student_id not in self.performance_data:
+                return None
+            
+            if concept_id:
+                return self.performance_data[student_id].get(concept_id)
+            else:
+                return self.performance_data[student_id]
+    
+    def update_performance_data(self, student_id: str, concept_id: str,
+                              updates: Dict[str, Any]) -> bool:
+        """Update performance data for a student and concept."""
+        with self._lock:
+            try:
+                if student_id not in self.performance_data:
+                    self.performance_data[student_id] = {}
+                
+                if concept_id not in self.performance_data[student_id]:
+                    self.performance_data[student_id][concept_id] = {}
+                
+                self.performance_data[student_id][concept_id].update(updates)
+                self.performance_data[student_id][concept_id]['last_updated'] = datetime.utcnow().isoformat()
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error updating performance data: {e}")
+                return False
+    
+    # Session Data Operations
+    def save_session_data(self, session_id: str, data: Dict[str, Any]) -> bool:
+        """Save session data."""
+        with self._lock:
+            try:
+                self.session_data[session_id] = {
+                    **data,
+                    'saved_at': datetime.utcnow().isoformat()
+                }
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error saving session data: {e}")
+                return False
+    
+    def get_session_data(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get session data by ID."""
+        with self._lock:
+            return self.session_data.get(session_id)
+    
+    def delete_session_data(self, session_id: str) -> bool:
+        """Delete session data."""
+        with self._lock:
+            try:
+                if session_id in self.session_data:
+                    del self.session_data[session_id]
+                    self._save_to_file()
+                    return True
+                return False
+            except Exception as e:
+                print(f"Error deleting session data: {e}")
+                return False
+    
+    def cleanup_old_sessions(self, days: int = 7) -> int:
+        """Clean up old session data."""
+        with self._lock:
+            try:
+                cutoff_date = datetime.utcnow() - timedelta(days=days)
+                sessions_to_delete = []
+                
+                for session_id, data in self.session_data.items():
+                    saved_at_str = data.get('saved_at')
+                    if saved_at_str:
+                        saved_at = datetime.fromisoformat(saved_at_str)
+                        if saved_at < cutoff_date:
+                            sessions_to_delete.append(session_id)
+                
+                for session_id in sessions_to_delete:
+                    del self.session_data[session_id]
+                
+                if sessions_to_delete:
+                    self._save_to_file()
+                
+                return len(sessions_to_delete)
+            except Exception as e:
+                print(f"Error cleaning up old sessions: {e}")
+                return 0
+    
+    # Analytics Cache Operations
+    def cache_analytics_result(self, cache_key: str, data: Dict[str, Any],
+                             ttl_minutes: int = 60) -> bool:
+        """Cache analytics result with TTL."""
+        with self._lock:
+            try:
+                expiry_time = datetime.utcnow() + timedelta(minutes=ttl_minutes)
+                self.analytics_cache[cache_key] = {
+                    'data': data,
+                    'expires_at': expiry_time.isoformat(),
+                    'cached_at': datetime.utcnow().isoformat()
+                }
+                return True
+            except Exception as e:
+                print(f"Error caching analytics result: {e}")
+                return False
+    
+    def get_cached_analytics(self, cache_key: str) -> Optional[Dict[str, Any]]:
+        """Get cached analytics result if not expired."""
+        with self._lock:
+            if cache_key not in self.analytics_cache:
+                return None
+            
+            cached_item = self.analytics_cache[cache_key]
+            expires_at = datetime.fromisoformat(cached_item['expires_at'])
+            
+            if datetime.utcnow() > expires_at:
+                # Cache expired, remove it
+                del self.analytics_cache[cache_key]
+                return None
+            
+            return cached_item['data']
+    
+    def clear_analytics_cache(self, pattern: Optional[str] = None) -> int:
+        """Clear analytics cache, optionally matching a pattern."""
+        with self._lock:
+            try:
+                if pattern is None:
+                    count = len(self.analytics_cache)
+                    self.analytics_cache.clear()
+                    return count
+                else:
+                    keys_to_delete = [
+                        key for key in self.analytics_cache.keys()
+                        if pattern in key
+                    ]
+                    for key in keys_to_delete:
+                        del self.analytics_cache[key]
+                    return len(keys_to_delete)
+            except Exception as e:
+                print(f"Error clearing analytics cache: {e}")
+                return 0
+    
+    # Adaptation History Operations
+    def add_adaptation_record(self, student_id: str, record: Dict[str, Any]) -> bool:
+        """Add an adaptation record for a student."""
+        with self._lock:
+            try:
+                self.adaptation_history[student_id].append({
+                    **record,
+                    'recorded_at': datetime.utcnow().isoformat()
+                })
+                
+                # Keep only last 100 records per student
+                if len(self.adaptation_history[student_id]) > 100:
+                    self.adaptation_history[student_id] = self.adaptation_history[student_id][-100:]
+                
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error adding adaptation record: {e}")
+                return False
+    
+    def get_adaptation_history(self, student_id: str, 
+                             days: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Get adaptation history for a student."""
+        with self._lock:
+            if student_id not in self.adaptation_history:
+                return []
+            
+            records = self.adaptation_history[student_id]
+            
+            if days is not None:
+                cutoff_date = datetime.utcnow() - timedelta(days=days)
+                records = [
+                    record for record in records
+                    if datetime.fromisoformat(record['recorded_at']) >= cutoff_date
+                ]
+            
+            return records
+    
+    # Utility Operations
+    def get_storage_stats(self) -> Dict[str, Any]:
+        """Get storage statistics."""
+        with self._lock:
+            return {
+                'student_profiles_count': len(self.student_profiles),
+                'performance_data_students': len(self.performance_data),
+                'total_performance_records': sum(
+                    len(concepts) for concepts in self.performance_data.values()
+                ),
+                'active_sessions': len(self.session_data),
+                'cached_analytics': len(self.analytics_cache),
+                'adaptation_records': sum(
+                    len(records) for records in self.adaptation_history.values()
+                ),
+                'persistence_enabled': self.persistence_file is not None,
+                'last_updated': datetime.utcnow().isoformat()
+            }
+    
+    def export_data(self, format: str = 'json') -> Union[str, bytes]:
+        """Export all data in specified format."""
+        with self._lock:
+            data = {
+                'student_profiles': {
+                    sid: profile.to_dict() 
+                    for sid, profile in self.student_profiles.items()
+                },
+                'performance_data': dict(self.performance_data),
+                'session_data': self.session_data,
+                'analytics_cache': dict(self.analytics_cache),
+                'adaptation_history': dict(self.adaptation_history),
+                'exported_at': datetime.utcnow().isoformat()
+            }
+            
+            if format.lower() == 'json':
+                return json.dumps(data, indent=2)
+            elif format.lower() == 'pickle':
+                return pickle.dumps(data)
+            else:
+                raise ValueError(f"Unsupported export format: {format}")
+    
+    def import_data(self, data: Union[str, bytes], format: str = 'json') -> bool:
+        """Import data from specified format."""
+        with self._lock:
+            try:
+                if format.lower() == 'json':
+                    imported_data = json.loads(data)
+                elif format.lower() == 'pickle':
+                    imported_data = pickle.loads(data)
+                else:
+                    raise ValueError(f"Unsupported import format: {format}")
+                
+                # Import student profiles
+                if 'student_profiles' in imported_data:
+                    for sid, profile_data in imported_data['student_profiles'].items():
+                        profile = StudentProfile.from_dict(profile_data)
+                        self.student_profiles[sid] = profile
+                
+                # Import other data
+                if 'performance_data' in imported_data:
+                    self.performance_data.update(imported_data['performance_data'])
+                
+                if 'session_data' in imported_data:
+                    self.session_data.update(imported_data['session_data'])
+                
+                if 'analytics_cache' in imported_data:
+                    self.analytics_cache.update(imported_data['analytics_cache'])
+                
+                if 'adaptation_history' in imported_data:
+                    self.adaptation_history.update(imported_data['adaptation_history'])
+                
+                self._save_to_file()
+                return True
+            except Exception as e:
+                print(f"Error importing data: {e}")
+                return False

mcp_server/tools/__init__.py

@@ -8,30 +8,57 @@ This module contains all the MCP tools for the TutorX application.
 from .concept_tools import get_concept_tool, assess_skill_tool  # noqa
 from .concept_graph_tools import get_concept_graph_tool  # noqa
 from .lesson_tools import generate_lesson_tool  # noqa
-from .quiz_tools import generate_quiz_tool  # noqa
+from .quiz_tools import (  # noqa
+    generate_quiz_tool,
+    start_interactive_quiz_tool,
+    submit_quiz_answer_tool,
+    get_quiz_hint_tool,
+    get_quiz_session_status_tool
+)
 from .interaction_tools import text_interaction, check_submission_originality  # noqa
 from .ocr_tools import mistral_document_ocr  # noqa
-from .learning_path_tools import get_learning_path  # noqa
+from .learning_path_tools import (  # noqa
+    get_learning_path,
+    # Enhanced Adaptive Learning Tools with Gemini Integration
+    generate_adaptive_content,
+    analyze_learning_patterns,
+    optimize_learning_strategy,
+    start_adaptive_session,
+    record_learning_event,
+    get_adaptive_recommendations,
+    get_adaptive_learning_path,
+    get_student_progress_summary
+)
 
 __all__ = [
     # Concept tools
     'get_concept_tool',
     'assess_skill_tool',
     'get_concept_graph_tool',
-    
+
     # Lesson tools
     'generate_lesson_tool',
-    
+
     # Quiz tools
     'generate_quiz_tool',
-    
+
     # Interaction tools
     'text_interaction',
     'check_submission_originality',
-    
+
     # OCR tools
     'mistral_document_ocr',
-    
+
     # Learning path tools
     'get_learning_path',
+
+    # Enhanced Adaptive Learning Tools with Gemini Integration
+    'generate_adaptive_content',
+    'analyze_learning_patterns',
+    'optimize_learning_strategy',
+    'start_adaptive_session',
+    'record_learning_event',
+    'get_adaptive_recommendations',
+    'get_adaptive_learning_path',
+    'get_student_progress_summary',
 ]

mcp_server/tools/concept_graph_tools.py

@@ -140,7 +140,6 @@ async def generate_text(prompt: str, temperature: float = 0.7):
             prompt=prompt,
             temperature=temperature
         )
-        print(f"[DEBUG] generate_text response type: {type(response)}")
         return response
     except Exception as e:
         print(f"[DEBUG] Error in generate_text: {e}")
@@ -214,9 +213,6 @@ async def get_concept_graph_tool(concept_id: Optional[str] = None, domain: str =
             print(f"[DEBUG] Returning fallback concept due to generation error")
             return fallback_concept
         
-        # Extract and validate the JSON response
-        print(f"[DEBUG] Full LLM response object type: {type(response)}")
-        
         # Handle different response formats
         response_text = None
         try:
@@ -247,8 +243,6 @@ async def get_concept_graph_tool(concept_id: Optional[str] = None, domain: str =
             print(f"[DEBUG] LLM response is empty, returning fallback concept")
             return fallback_concept
         
-        print(f"[DEBUG] LLM raw response text (first 200 chars): {response_text}...")
-        
         try:
             result = extract_json_from_text(response_text)
             print(f"[DEBUG] JSON extraction result: {result is not None}")

mcp_server/tools/concept_tools.py

@@ -17,7 +17,18 @@ sys.path.insert(0, str(parent_dir))
 
 
 # Import from local resources
-from resources.concept_graph import get_concept, get_all_concepts
+try:
+    from resources.concept_graph import get_concept, get_all_concepts
+except ImportError:
+    # Fallback for when running from different contexts
+    def get_concept(concept_id):
+        return {"id": concept_id, "name": concept_id.replace("_", " ").title(), "description": f"Description for {concept_id}"}
+
+    def get_all_concepts():
+        return {
+            "algebra_basics": {"id": "algebra_basics", "name": "Algebra Basics", "description": "Basic algebraic concepts"},
+            "linear_equations": {"id": "linear_equations", "name": "Linear Equations", "description": "Solving linear equations"}
+        }
 
 # Import MCP
 from mcp_server.mcp_instance import mcp

mcp_server/tools/learning_path_tools.py

@@ -1,5 +1,5 @@
 """
-Learning path generation tools for TutorX.
+Learning path generation tools for TutorX with adaptive learning capabilities.
 """
 import random
 from typing import Dict, Any, List, Optional
@@ -9,6 +9,8 @@ import os
 from pathlib import Path
 import json
 import re
+from dataclasses import dataclass, asdict
+from enum import Enum
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
@@ -16,7 +18,16 @@ parent_dir = current_dir.parent.parent
 sys.path.insert(0, str(parent_dir))
 
 # Import from local resources
-from resources.concept_graph import CONCEPT_GRAPH
+try:
+    from resources.concept_graph import CONCEPT_GRAPH
+except ImportError:
+    # Fallback for when running from different contexts
+    CONCEPT_GRAPH = {
+        "algebra_basics": {"id": "algebra_basics", "name": "Algebra Basics", "description": "Basic algebraic concepts"},
+        "linear_equations": {"id": "linear_equations", "name": "Linear Equations", "description": "Solving linear equations"},
+        "quadratic_equations": {"id": "quadratic_equations", "name": "Quadratic Equations", "description": "Solving quadratic equations"},
+        "algebra_linear_equations": {"id": "algebra_linear_equations", "name": "Linear Equations", "description": "Linear equation solving"}
+    }
 
 # Import MCP
 from mcp_server.mcp_instance import mcp
@@ -24,6 +35,38 @@ from mcp_server.model.gemini_flash import GeminiFlash
 
 MODEL = GeminiFlash()
 
+# Adaptive Learning Data Structures
+class DifficultyLevel(Enum):
+    VERY_EASY = 0.2
+    EASY = 0.4
+    MEDIUM = 0.6
+    HARD = 0.8
+    VERY_HARD = 1.0
+
+@dataclass
+class StudentPerformance:
+    student_id: str
+    concept_id: str
+    accuracy_rate: float = 0.0
+    time_spent_minutes: float = 0.0
+    attempts_count: int = 0
+    mastery_level: float = 0.0
+    last_accessed: datetime = None
+    difficulty_preference: float = 0.5
+
+@dataclass
+class LearningEvent:
+    student_id: str
+    concept_id: str
+    event_type: str  # 'answer_correct', 'answer_incorrect', 'hint_used', 'time_spent'
+    timestamp: datetime
+    data: Dict[str, Any]
+
+# In-memory storage for adaptive learning
+student_performances: Dict[str, Dict[str, StudentPerformance]] = {}
+learning_events: List[LearningEvent] = []
+active_sessions: Dict[str, Dict[str, Any]] = {}
+
 def get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:
     """
     Get all prerequisites for a concept recursively.
@@ -152,6 +195,747 @@ def extract_json_from_text(text: str):
     cleaned = clean_json_trailing_commas(text)
     return json.loads(cleaned)
 
+# Adaptive Learning Helper Functions
+def get_student_performance(student_id: str, concept_id: str) -> StudentPerformance:
+    """Get or create student performance record."""
+    if student_id not in student_performances:
+        student_performances[student_id] = {}
+
+    if concept_id not in student_performances[student_id]:
+        student_performances[student_id][concept_id] = StudentPerformance(
+            student_id=student_id,
+            concept_id=concept_id,
+            last_accessed=datetime.utcnow()
+        )
+
+    return student_performances[student_id][concept_id]
+
+def update_mastery_level(performance: StudentPerformance) -> float:
+    """Calculate mastery level based on performance metrics."""
+    if performance.attempts_count == 0:
+        return 0.0
+
+    # Weighted calculation: accuracy (60%), consistency (20%), efficiency (20%)
+    accuracy_score = performance.accuracy_rate
+
+    # Consistency: higher attempts with stable accuracy indicate consistency
+    consistency_score = min(1.0, performance.attempts_count / 5.0) if performance.accuracy_rate > 0.7 else 0.5
+
+    # Efficiency: less time per attempt indicates better understanding
+    avg_time = performance.time_spent_minutes / performance.attempts_count if performance.attempts_count > 0 else 30
+    efficiency_score = max(0.1, 1.0 - (avg_time - 10) / 50)  # Normalize around 10-60 minutes
+
+    mastery = (accuracy_score * 0.6) + (consistency_score * 0.2) + (efficiency_score * 0.2)
+    performance.mastery_level = min(1.0, max(0.0, mastery))
+    return performance.mastery_level
+
+def adapt_difficulty(performance: StudentPerformance) -> float:
+    """Adapt difficulty based on student performance."""
+    if performance.attempts_count < 2:
+        return performance.difficulty_preference
+
+    # If accuracy is high, increase difficulty
+    if performance.accuracy_rate > 0.8:
+        new_difficulty = min(1.0, performance.difficulty_preference + 0.1)
+    # If accuracy is low, decrease difficulty
+    elif performance.accuracy_rate < 0.5:
+        new_difficulty = max(0.2, performance.difficulty_preference - 0.1)
+    else:
+        new_difficulty = performance.difficulty_preference
+
+    performance.difficulty_preference = new_difficulty
+    return new_difficulty
+
+# Enhanced Adaptive Learning with Gemini Integration
+
+@mcp.tool()
+async def generate_adaptive_content(student_id: str, concept_id: str, content_type: str = "explanation",
+                                  difficulty_level: float = 0.5, learning_style: str = "visual") -> dict:
+    """
+    Generate personalized learning content using Gemini based on student profile and performance.
+
+    Args:
+        student_id: Student identifier
+        concept_id: Concept to generate content for
+        content_type: Type of content ('explanation', 'example', 'practice', 'summary')
+        difficulty_level: Difficulty level (0.0 to 1.0)
+        learning_style: Preferred learning style ('visual', 'auditory', 'kinesthetic', 'reading')
+
+    Returns:
+        Personalized learning content
+    """
+    try:
+        # Get student performance data
+        performance = get_student_performance(student_id, concept_id)
+        concept_data = CONCEPT_GRAPH.get(concept_id, {"name": concept_id, "description": ""})
+
+        # Build context for Gemini
+        context = f"""
+        Student Profile:
+        - Student ID: {student_id}
+        - Current mastery level: {performance.mastery_level:.2f}
+        - Accuracy rate: {performance.accuracy_rate:.2f}
+        - Attempts made: {performance.attempts_count}
+        - Preferred difficulty: {difficulty_level}
+        - Learning style: {learning_style}
+
+        Concept Information:
+        - Concept: {concept_data.get('name', concept_id)}
+        - Description: {concept_data.get('description', '')}
+
+        Content Requirements:
+        - Content type: {content_type}
+        - Target difficulty: {difficulty_level}
+        - Learning style: {learning_style}
+        """
+
+        if content_type == "explanation":
+            prompt = f"""{context}
+
+            Generate a personalized explanation of {concept_data.get('name', concept_id)} that:
+            1. Matches the student's current understanding level (mastery: {performance.mastery_level:.2f})
+            2. Uses {learning_style} learning approaches
+            3. Is appropriate for difficulty level {difficulty_level}
+            4. Builds on their {performance.attempts_count} previous attempts
+
+            Return a JSON object with:
+            - "explanation": detailed explanation text
+            - "key_points": list of 3-5 key concepts
+            - "analogies": 2-3 relevant analogies or examples
+            - "difficulty_indicators": what makes this concept challenging
+            - "next_steps": suggested follow-up activities
+            """
+        elif content_type == "practice":
+            prompt = f"""{context}
+
+            Generate personalized practice problems for {concept_data.get('name', concept_id)} that:
+            1. Match difficulty level {difficulty_level}
+            2. Consider their accuracy rate of {performance.accuracy_rate:.2f}
+            3. Use {learning_style} presentation style
+            4. Provide appropriate scaffolding
+
+            Return a JSON object with:
+            - "problems": list of 3-5 practice problems
+            - "hints": helpful hints for each problem
+            - "solutions": step-by-step solutions
+            - "difficulty_progression": how problems increase in complexity
+            - "success_criteria": what indicates mastery
+            """
+        elif content_type == "feedback":
+            prompt = f"""{context}
+
+            Generate personalized feedback for the student's performance on {concept_data.get('name', concept_id)}:
+            1. Acknowledge their current progress (mastery: {performance.mastery_level:.2f})
+            2. Address their accuracy rate of {performance.accuracy_rate:.2f}
+            3. Provide encouraging and constructive guidance
+            4. Suggest specific improvement strategies
+
+            Return a JSON object with:
+            - "encouragement": positive reinforcement message
+            - "areas_of_strength": what they're doing well
+            - "improvement_areas": specific areas to focus on
+            - "strategies": concrete learning strategies
+            - "motivation": motivational message tailored to their progress
+            """
+        else:  # summary or other types
+            prompt = f"""{context}
+
+            Generate a personalized summary of {concept_data.get('name', concept_id)} that:
+            1. Reinforces key concepts at their mastery level
+            2. Uses {learning_style} presentation
+            3. Connects to their learning journey
+
+            Return a JSON object with:
+            - "summary": concise concept summary
+            - "key_takeaways": main points to remember
+            - "connections": how this relates to other concepts
+            - "review_schedule": when to review this concept
+            """
+
+        # Generate content using Gemini
+        response = await MODEL.generate_text(prompt, temperature=0.7)
+
+        try:
+            content_data = extract_json_from_text(response)
+            content_data.update({
+                "success": True,
+                "student_id": student_id,
+                "concept_id": concept_id,
+                "content_type": content_type,
+                "difficulty_level": difficulty_level,
+                "learning_style": learning_style,
+                "generated_at": datetime.utcnow().isoformat(),
+                "personalization_factors": {
+                    "mastery_level": performance.mastery_level,
+                    "accuracy_rate": performance.accuracy_rate,
+                    "attempts_count": performance.attempts_count
+                }
+            })
+            return content_data
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to parse Gemini response: {str(e)}",
+                "raw_response": response
+            }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+async def analyze_learning_patterns(student_id: str, analysis_days: int = 30) -> dict:
+    """
+    Use Gemini to analyze student learning patterns and provide insights.
+
+    Args:
+        student_id: Student identifier
+        analysis_days: Number of days to analyze
+
+    Returns:
+        AI-powered learning pattern analysis
+    """
+    try:
+        # Gather student data
+        if student_id not in student_performances:
+            return {
+                "success": True,
+                "student_id": student_id,
+                "message": "No learning data available for analysis",
+                "recommendations": ["Start learning to build your profile!"]
+            }
+
+        student_data = student_performances[student_id]
+
+        # Get recent events
+        cutoff_date = datetime.utcnow() - timedelta(days=analysis_days)
+        recent_events = [e for e in learning_events
+                        if e.student_id == student_id and e.timestamp >= cutoff_date]
+
+        # Prepare data for analysis
+        performance_summary = []
+        for concept_id, perf in student_data.items():
+            concept_name = CONCEPT_GRAPH.get(concept_id, {}).get('name', concept_id)
+            performance_summary.append({
+                "concept": concept_name,
+                "mastery": perf.mastery_level,
+                "accuracy": perf.accuracy_rate,
+                "attempts": perf.attempts_count,
+                "time_spent": perf.time_spent_minutes,
+                "last_accessed": perf.last_accessed.isoformat() if perf.last_accessed else None
+            })
+
+        # Build analysis prompt
+        prompt = f"""
+        Analyze the learning patterns for Student {student_id} over the past {analysis_days} days.
+
+        Performance Data:
+        {json.dumps(performance_summary, indent=2)}
+
+        Recent Learning Events: {len(recent_events)} events
+
+        Please provide a comprehensive analysis including:
+        1. Learning strengths and patterns
+        2. Areas that need attention
+        3. Optimal learning times/frequency
+        4. Difficulty progression recommendations
+        5. Personalized learning strategies
+        6. Motivation and engagement insights
+
+        Return a JSON object with:
+        - "learning_style_analysis": identified learning preferences
+        - "strength_areas": concepts/skills where student excels
+        - "challenge_areas": concepts that need more work
+        - "learning_velocity": how quickly student progresses
+        - "engagement_patterns": when student is most/least engaged
+        - "optimal_difficulty": recommended difficulty range
+        - "study_schedule": suggested learning schedule
+        - "personalized_strategies": specific strategies for this student
+        - "motivation_factors": what motivates this student
+        - "next_focus_areas": what to work on next
+        - "confidence_level": assessment of student confidence
+        """
+
+        # Get AI analysis
+        response = await MODEL.generate_text(prompt, temperature=0.6)
+
+        try:
+            analysis_data = extract_json_from_text(response)
+            analysis_data.update({
+                "success": True,
+                "student_id": student_id,
+                "analysis_period_days": analysis_days,
+                "data_points_analyzed": len(performance_summary),
+                "recent_events_count": len(recent_events),
+                "generated_at": datetime.utcnow().isoformat()
+            })
+            return analysis_data
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to parse analysis: {str(e)}",
+                "raw_response": response
+            }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+async def optimize_learning_strategy(student_id: str, current_concept: str,
+                                   performance_history: dict = None) -> dict:
+    """
+    Use Gemini to optimize learning strategy based on comprehensive student analysis.
+
+    Args:
+        student_id: Student identifier
+        current_concept: Current concept being studied
+        performance_history: Optional detailed performance history
+
+    Returns:
+        AI-optimized learning strategy recommendations
+    """
+    try:
+        # Get comprehensive student data
+        if student_id not in student_performances:
+            return {
+                "success": True,
+                "student_id": student_id,
+                "message": "No performance data available. Starting with default strategy.",
+                "strategy": "beginner_friendly",
+                "recommendations": ["Start with foundational concepts", "Use guided practice"]
+            }
+
+        student_data = student_performances[student_id]
+        current_performance = student_data.get(current_concept, None)
+
+        # Analyze overall learning patterns
+        total_concepts = len(student_data)
+        avg_mastery = sum(p.mastery_level for p in student_data.values()) / total_concepts if total_concepts > 0 else 0
+        avg_accuracy = sum(p.accuracy_rate for p in student_data.values()) / total_concepts if total_concepts > 0 else 0
+        total_time = sum(p.time_spent_minutes for p in student_data.values())
+
+        # Get recent learning velocity
+        recent_events = [e for e in learning_events
+                        if e.student_id == student_id and
+                        e.timestamp >= datetime.utcnow() - timedelta(days=7)]
+
+        # Build comprehensive analysis prompt
+        prompt = f"""
+        Optimize the learning strategy for Student {student_id} studying {current_concept}.
+
+        CURRENT PERFORMANCE DATA:
+        - Current concept: {current_concept}
+        - Current mastery: {current_performance.mastery_level if current_performance else 0:.2f}
+        - Current accuracy: {current_performance.accuracy_rate if current_performance else 0:.2f}
+        - Attempts on current concept: {current_performance.attempts_count if current_performance else 0}
+
+        OVERALL STUDENT PROFILE:
+        - Total concepts studied: {total_concepts}
+        - Average mastery across all concepts: {avg_mastery:.2f}
+        - Average accuracy rate: {avg_accuracy:.2f}
+        - Total learning time: {total_time} minutes
+        - Recent activity: {len(recent_events)} events in past 7 days
+
+        Generate a comprehensive strategy optimization in JSON format:
+        {{
+            "optimized_strategy": {{
+                "primary_approach": "adaptive|mastery_based|exploratory|remedial",
+                "difficulty_recommendation": "current optimal difficulty level (0.0-1.0)",
+                "pacing_strategy": "fast|moderate|slow|variable",
+                "focus_areas": ["specific areas to emphasize"],
+                "learning_modalities": ["visual|auditory|kinesthetic|reading"]
+            }},
+            "immediate_actions": [
+                {{
+                    "action": "specific action to take now",
+                    "priority": "high|medium|low",
+                    "expected_impact": "what this will achieve",
+                    "time_estimate": "how long this will take"
+                }}
+            ],
+            "session_optimization": {{
+                "ideal_session_length": "recommended minutes per session",
+                "break_frequency": "how often to take breaks",
+                "review_schedule": "when to review previous concepts",
+                "practice_distribution": "how to distribute practice time"
+            }},
+            "motivation_strategy": {{
+                "achievement_recognition": "how to celebrate progress",
+                "challenge_level": "optimal challenge to maintain engagement",
+                "goal_setting": "short and long-term goals",
+                "feedback_style": "how to provide effective feedback"
+            }},
+            "success_metrics": {{
+                "mastery_targets": "target mastery levels",
+                "accuracy_goals": "target accuracy rates",
+                "time_efficiency": "optimal time per concept",
+                "engagement_indicators": "signs of good engagement"
+            }}
+        }}
+        """
+
+        # Get AI strategy optimization
+        response = await MODEL.generate_text(prompt, temperature=0.6)
+
+        try:
+            strategy_data = extract_json_from_text(response)
+
+            # Add metadata and validation
+            strategy_data.update({
+                "success": True,
+                "student_id": student_id,
+                "current_concept": current_concept,
+                "analysis_timestamp": datetime.utcnow().isoformat(),
+                "data_points_analyzed": total_concepts,
+                "recent_activity_level": len(recent_events),
+                "ai_powered": True
+            })
+
+            return strategy_data
+
+        except Exception as e:
+            # Fallback strategy if AI parsing fails
+            return {
+                "success": True,
+                "student_id": student_id,
+                "current_concept": current_concept,
+                "ai_powered": False,
+                "fallback_reason": f"AI analysis failed: {str(e)}",
+                "basic_strategy": {
+                    "approach": "adaptive" if avg_mastery > 0.6 else "foundational",
+                    "difficulty": min(0.8, max(0.3, avg_accuracy)),
+                    "focus": "mastery" if avg_accuracy < 0.7 else "progression"
+                },
+                "recommendations": [
+                    f"Current mastery level suggests {'advanced' if avg_mastery > 0.7 else 'foundational'} approach",
+                    f"Accuracy rate of {avg_accuracy:.1%} indicates {'good progress' if avg_accuracy > 0.6 else 'need for more practice'}",
+                    "Continue with consistent practice and regular review"
+                ]
+            }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+# Adaptive Learning MCP Tools
+
+@mcp.tool()
+async def start_adaptive_session(student_id: str, concept_id: str, initial_difficulty: float = 0.5) -> dict:
+    """
+    Start an adaptive learning session for a student.
+
+    Args:
+        student_id: Unique identifier for the student
+        concept_id: Concept being learned
+        initial_difficulty: Initial difficulty level (0.0 to 1.0)
+
+    Returns:
+        Session information and initial recommendations
+    """
+    try:
+        session_id = f"{student_id}_{concept_id}_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}"
+
+        # Get or create student performance
+        performance = get_student_performance(student_id, concept_id)
+        performance.difficulty_preference = initial_difficulty
+        performance.last_accessed = datetime.utcnow()
+
+        # Create session
+        active_sessions[session_id] = {
+            'student_id': student_id,
+            'concept_id': concept_id,
+            'start_time': datetime.utcnow(),
+            'current_difficulty': initial_difficulty,
+            'events': [],
+            'questions_answered': 0,
+            'correct_answers': 0
+        }
+
+        return {
+            "success": True,
+            "session_id": session_id,
+            "student_id": student_id,
+            "concept_id": concept_id,
+            "initial_difficulty": initial_difficulty,
+            "current_mastery": performance.mastery_level,
+            "recommendations": [
+                f"Start with difficulty level {initial_difficulty:.1f}",
+                f"Current mastery level: {performance.mastery_level:.2f}",
+                "System will adapt based on your performance"
+            ]
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+async def record_learning_event(student_id: str, concept_id: str, session_id: str,
+                               event_type: str, event_data: dict) -> dict:
+    """
+    Record a learning event for adaptive analysis.
+
+    Args:
+        student_id: Student identifier
+        concept_id: Concept identifier
+        session_id: Session identifier
+        event_type: Type of event ('answer_correct', 'answer_incorrect', 'hint_used', 'time_spent')
+        event_data: Additional event data
+
+    Returns:
+        Event recording confirmation and updated recommendations
+    """
+    try:
+        # Record the event
+        event = LearningEvent(
+            student_id=student_id,
+            concept_id=concept_id,
+            event_type=event_type,
+            timestamp=datetime.utcnow(),
+            data=event_data
+        )
+        learning_events.append(event)
+
+        # Update session
+        if session_id in active_sessions:
+            session = active_sessions[session_id]
+            session['events'].append(event)
+
+            if event_type in ['answer_correct', 'answer_incorrect']:
+                session['questions_answered'] += 1
+                if event_type == 'answer_correct':
+                    session['correct_answers'] += 1
+
+        # Update student performance
+        performance = get_student_performance(student_id, concept_id)
+        performance.attempts_count += 1
+
+        if event_type == 'answer_correct':
+            performance.accuracy_rate = (performance.accuracy_rate * (performance.attempts_count - 1) + 1.0) / performance.attempts_count
+        elif event_type == 'answer_incorrect':
+            performance.accuracy_rate = (performance.accuracy_rate * (performance.attempts_count - 1) + 0.0) / performance.attempts_count
+        elif event_type == 'time_spent':
+            performance.time_spent_minutes += event_data.get('minutes', 0)
+
+        # Update mastery level
+        new_mastery = update_mastery_level(performance)
+
+        # Adapt difficulty
+        new_difficulty = adapt_difficulty(performance)
+
+        # Generate recommendations
+        recommendations = []
+        if performance.accuracy_rate > 0.8 and performance.attempts_count >= 3:
+            recommendations.append("Great job! Consider moving to a harder difficulty level.")
+        elif performance.accuracy_rate < 0.5 and performance.attempts_count >= 3:
+            recommendations.append("Let's try some easier questions to build confidence.")
+
+        if new_mastery > 0.8:
+            recommendations.append("You're mastering this concept! Ready for the next one?")
+
+        return {
+            "success": True,
+            "event_recorded": True,
+            "updated_mastery": new_mastery,
+            "updated_difficulty": new_difficulty,
+            "current_accuracy": performance.accuracy_rate,
+            "recommendations": recommendations
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@mcp.tool()
+async def get_adaptive_recommendations(student_id: str, concept_id: str, session_id: str = None) -> dict:
+    """
+    Get AI-powered adaptive learning recommendations using Gemini analysis.
+
+    Args:
+        student_id: Student identifier
+        concept_id: Concept identifier
+        session_id: Optional session identifier
+
+    Returns:
+        Intelligent adaptive learning recommendations
+    """
+    try:
+        performance = get_student_performance(student_id, concept_id)
+        concept_data = CONCEPT_GRAPH.get(concept_id, {"name": concept_id, "description": ""})
+
+        # Get session data if available
+        session_data = active_sessions.get(session_id, {}) if session_id else {}
+
+        # Build comprehensive context for Gemini
+        context = f"""
+        Student Performance Analysis for {concept_data.get('name', concept_id)}:
+
+        Current Metrics:
+        - Mastery Level: {performance.mastery_level:.2f} (0.0 = no understanding, 1.0 = complete mastery)
+        - Accuracy Rate: {performance.accuracy_rate:.2f} (proportion of correct answers)
+        - Total Attempts: {performance.attempts_count}
+        - Time Spent: {performance.time_spent_minutes} minutes
+        - Current Difficulty Preference: {performance.difficulty_preference:.2f}
+        - Last Accessed: {performance.last_accessed.isoformat() if performance.last_accessed else 'Never'}
+
+        Session Information:
+        - Session ID: {session_id or 'No active session'}
+        - Questions Answered: {session_data.get('questions_answered', 0)}
+        - Correct Answers: {session_data.get('correct_answers', 0)}
+
+        Concept Details:
+        - Concept: {concept_data.get('name', concept_id)}
+        - Description: {concept_data.get('description', 'No description available')}
+        """
+
+        prompt = f"""{context}
+
+        As an AI learning advisor, analyze this student's performance and provide personalized recommendations.
+
+        Consider:
+        1. Current mastery level and learning trajectory
+        2. Accuracy patterns and difficulty appropriateness
+        3. Time investment and learning efficiency
+        4. Optimal next steps for continued growth
+        5. Motivation and engagement strategies
+
+        Provide specific, actionable recommendations in JSON format:
+        {{
+            "immediate_actions": [
+                {{
+                    "type": "difficulty_adjustment|content_type|study_strategy|break_recommendation",
+                    "priority": "high|medium|low",
+                    "action": "specific action to take",
+                    "reasoning": "why this action is recommended",
+                    "expected_outcome": "what this should achieve"
+                }}
+            ],
+            "difficulty_recommendation": {{
+                "current_level": {performance.difficulty_preference:.2f},
+                "suggested_level": "recommended difficulty (0.0-1.0)",
+                "adjustment_reason": "explanation for the change",
+                "gradual_steps": ["step-by-step difficulty progression"]
+            }},
+            "learning_strategy": {{
+                "primary_focus": "what to focus on most",
+                "study_methods": ["recommended study techniques"],
+                "practice_types": ["types of practice exercises"],
+                "time_allocation": "suggested time distribution"
+            }},
+            "motivation_boosters": [
+                "specific encouragement based on progress",
+                "achievement recognition",
+                "goal-setting suggestions"
+            ],
+            "next_milestones": [
+                {{
+                    "milestone": "specific goal",
+                    "target_mastery": "target mastery level",
+                    "estimated_time": "time to achieve",
+                    "success_indicators": ["how to know when achieved"]
+                }}
+            ],
+            "warning_signs": [
+                "potential issues to watch for"
+            ],
+            "adaptive_insights": {{
+                "learning_pattern": "observed learning pattern",
+                "optimal_session_length": "recommended session duration",
+                "best_practice_times": "when student learns best",
+                "engagement_level": "current engagement assessment"
+            }}
+        }}
+        """
+
+        # Get AI recommendations
+        response = await MODEL.generate_text(prompt, temperature=0.7)
+
+        try:
+            ai_recommendations = extract_json_from_text(response)
+
+            # Add basic fallback recommendations if AI parsing fails
+            if not ai_recommendations or "immediate_actions" not in ai_recommendations:
+                ai_recommendations = _generate_fallback_recommendations(performance)
+
+            # Enhance with computed metrics
+            ai_recommendations.update({
+                "success": True,
+                "student_id": student_id,
+                "concept_id": concept_id,
+                "session_id": session_id,
+                "current_metrics": {
+                    "mastery_level": performance.mastery_level,
+                    "accuracy_rate": performance.accuracy_rate,
+                    "attempts_count": performance.attempts_count,
+                    "time_spent_minutes": performance.time_spent_minutes,
+                    "difficulty_preference": performance.difficulty_preference
+                },
+                "ai_powered": True,
+                "generated_at": datetime.utcnow().isoformat()
+            })
+
+            return ai_recommendations
+
+        except Exception as e:
+            # Fallback to basic recommendations if AI parsing fails
+            return _generate_fallback_recommendations(performance, student_id, concept_id, session_id, str(e))
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def _generate_fallback_recommendations(performance: StudentPerformance, student_id: str = None,
+                                     concept_id: str = None, session_id: str = None,
+                                     ai_error: str = None) -> dict:
+    """Generate basic recommendations when AI analysis fails."""
+    recommendations = []
+
+    # Difficulty recommendations
+    if performance.accuracy_rate > 0.8:
+        recommendations.append({
+            "type": "difficulty_increase",
+            "priority": "medium",
+            "action": "Increase difficulty level",
+            "reasoning": "High accuracy indicates readiness for more challenge",
+            "expected_outcome": "Maintain engagement and continued growth"
+        })
+    elif performance.accuracy_rate < 0.5:
+        recommendations.append({
+            "type": "difficulty_decrease",
+            "priority": "high",
+            "action": "Decrease difficulty level",
+            "reasoning": "Low accuracy suggests current level is too challenging",
+            "expected_outcome": "Build confidence and foundational understanding"
+        })
+
+    # Mastery recommendations
+    if performance.mastery_level > 0.8:
+        recommendations.append({
+            "type": "concept_advancement",
+            "priority": "high",
+            "action": "Move to next concept",
+            "reasoning": "High mastery level achieved",
+            "expected_outcome": "Continue learning progression"
+        })
+    elif performance.mastery_level < 0.3 and performance.attempts_count >= 5:
+        recommendations.append({
+            "type": "additional_practice",
+            "priority": "high",
+            "action": "Focus on additional practice",
+            "reasoning": "Low mastery despite multiple attempts",
+            "expected_outcome": "Strengthen foundational understanding"
+        })
+
+    return {
+        "success": True,
+        "student_id": student_id,
+        "concept_id": concept_id,
+        "session_id": session_id,
+        "immediate_actions": recommendations,
+        "ai_powered": False,
+        "fallback_reason": f"AI analysis failed: {ai_error}" if ai_error else "Using basic recommendation engine",
+        "current_metrics": {
+            "mastery_level": performance.mastery_level,
+            "accuracy_rate": performance.accuracy_rate,
+            "attempts_count": performance.attempts_count,
+            "difficulty_preference": performance.difficulty_preference
+        },
+        "generated_at": datetime.utcnow().isoformat()
+    }
+
 @mcp.tool()
 async def get_learning_path(student_id: str, concept_ids: list, student_level: str = "beginner") -> dict:
     """
@@ -168,3 +952,374 @@ async def get_learning_path(student_id: str, concept_ids: list, student_level: s
     except Exception:
         data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
     return data
+
+@mcp.tool()
+async def get_adaptive_learning_path(student_id: str, target_concepts: list,
+                                   strategy: str = "adaptive", max_concepts: int = 10) -> dict:
+    """
+    Generate an AI-powered adaptive learning path using Gemini analysis.
+
+    Args:
+        student_id: Student identifier
+        target_concepts: List of target concept IDs
+        strategy: Learning strategy ('adaptive', 'mastery_focused', 'breadth_first', 'depth_first', 'remediation')
+        max_concepts: Maximum number of concepts in the path
+
+    Returns:
+        Intelligent adaptive learning path optimized by AI
+    """
+    try:
+        # Get comprehensive student performance data
+        student_data = {}
+        overall_stats = {
+            'total_concepts': 0,
+            'average_mastery': 0,
+            'average_accuracy': 0,
+            'total_time': 0,
+            'total_attempts': 0
+        }
+
+        for concept_id in target_concepts:
+            concept_name = CONCEPT_GRAPH.get(concept_id, {}).get('name', concept_id)
+            if student_id in student_performances and concept_id in student_performances[student_id]:
+                perf = student_performances[student_id][concept_id]
+                student_data[concept_id] = {
+                    'concept_name': concept_name,
+                    'mastery_level': perf.mastery_level,
+                    'accuracy_rate': perf.accuracy_rate,
+                    'difficulty_preference': perf.difficulty_preference,
+                    'attempts_count': perf.attempts_count,
+                    'time_spent': perf.time_spent_minutes,
+                    'last_accessed': perf.last_accessed.isoformat() if perf.last_accessed else None
+                }
+                overall_stats['total_concepts'] += 1
+                overall_stats['average_mastery'] += perf.mastery_level
+                overall_stats['average_accuracy'] += perf.accuracy_rate
+                overall_stats['total_time'] += perf.time_spent_minutes
+                overall_stats['total_attempts'] += perf.attempts_count
+            else:
+                # New concept - no performance data
+                student_data[concept_id] = {
+                    'concept_name': concept_name,
+                    'mastery_level': 0.0,
+                    'accuracy_rate': 0.0,
+                    'difficulty_preference': 0.5,
+                    'attempts_count': 0,
+                    'time_spent': 0,
+                    'last_accessed': None,
+                    'is_new': True
+                }
+
+        # Calculate averages
+        if overall_stats['total_concepts'] > 0:
+            overall_stats['average_mastery'] /= overall_stats['total_concepts']
+            overall_stats['average_accuracy'] /= overall_stats['total_concepts']
+
+        # Build comprehensive prompt for Gemini
+        prompt = f"""
+        Create an optimal adaptive learning path for Student {student_id} using advanced AI analysis.
+
+        STUDENT PERFORMANCE DATA:
+        {json.dumps(student_data, indent=2)}
+
+        OVERALL STATISTICS:
+        - Total concepts with data: {overall_stats['total_concepts']}
+        - Average mastery level: {overall_stats['average_mastery']:.2f}
+        - Average accuracy rate: {overall_stats['average_accuracy']:.2f}
+        - Total learning time: {overall_stats['total_time']} minutes
+        - Total attempts: {overall_stats['total_attempts']}
+
+        LEARNING STRATEGY: {strategy}
+        MAX CONCEPTS: {max_concepts}
+
+        STRATEGY DEFINITIONS:
+        - adaptive: AI-optimized path balancing challenge and success
+        - mastery_focused: Deep understanding before progression
+        - breadth_first: Cover many concepts quickly for overview
+        - depth_first: Thorough exploration of fewer concepts
+        - remediation: Focus on filling knowledge gaps
+
+        REQUIREMENTS:
+        1. Analyze student's learning patterns and preferences
+        2. Consider concept dependencies and prerequisites
+        3. Optimize for engagement and learning efficiency
+        4. Provide personalized difficulty progression
+        5. Include time estimates based on student's pace
+        6. Add motivational elements and milestones
+
+        Generate a JSON response with this structure:
+        {{
+            "learning_path": [
+                {{
+                    "step": 1,
+                    "concept_id": "concept_id",
+                    "concept_name": "Human readable name",
+                    "description": "What student will learn",
+                    "estimated_time_minutes": 30,
+                    "difficulty_level": 0.6,
+                    "mastery_target": 0.8,
+                    "prerequisites_met": true,
+                    "learning_objectives": ["specific objective 1", "objective 2"],
+                    "recommended_activities": ["activity 1", "activity 2"],
+                    "success_criteria": ["how to know when mastered"],
+                    "adaptive_notes": "Personalized guidance",
+                    "motivation_boost": "Encouraging message"
+                }}
+            ],
+            "path_analysis": {{
+                "strategy_rationale": "Why this strategy was chosen",
+                "difficulty_progression": "How difficulty increases",
+                "estimated_completion": "Total time estimate",
+                "learning_velocity": "Expected pace",
+                "challenge_level": "Overall difficulty assessment"
+            }},
+            "personalization": {{
+                "student_strengths": ["identified strengths"],
+                "focus_areas": ["areas needing attention"],
+                "learning_style_adaptations": ["how path is adapted"],
+                "motivation_factors": ["what will keep student engaged"]
+            }},
+            "milestones": [
+                {{
+                    "milestone_name": "Achievement name",
+                    "concepts_completed": 3,
+                    "expected_mastery": 0.75,
+                    "celebration": "How to celebrate achievement"
+                }}
+            ],
+            "adaptive_features": [
+                "Real-time difficulty adjustment",
+                "Performance-based pacing",
+                "Personalized content delivery"
+            ]
+        }}
+        """
+
+        # Get AI-generated learning path
+        response = await MODEL.generate_text(prompt, temperature=0.6)
+
+        try:
+            ai_path = extract_json_from_text(response)
+
+            # Validate and enhance the AI response
+            if not ai_path or "learning_path" not in ai_path:
+                # Fallback to basic path generation
+                ai_path = _generate_basic_adaptive_path(student_data, target_concepts, strategy, max_concepts)
+
+            # Add metadata
+            ai_path.update({
+                "success": True,
+                "student_id": student_id,
+                "strategy": strategy,
+                "max_concepts": max_concepts,
+                "ai_powered": True,
+                "total_steps": len(ai_path.get("learning_path", [])),
+                "total_time_minutes": sum(step.get("estimated_time_minutes", 30)
+                                        for step in ai_path.get("learning_path", [])),
+                "generated_at": datetime.utcnow().isoformat()
+            })
+
+            return ai_path
+
+        except Exception as e:
+            # Fallback to basic path if AI parsing fails
+            return _generate_basic_adaptive_path(student_data, target_concepts, strategy, max_concepts, str(e))
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def _generate_basic_adaptive_path(student_data: dict, target_concepts: list,
+                                strategy: str, max_concepts: int, ai_error: str = None) -> dict:
+    """Generate basic adaptive path when AI analysis fails."""
+    # Simple sorting based on strategy
+    if strategy == "mastery_focused":
+        sorted_concepts = sorted(target_concepts,
+                               key=lambda c: student_data.get(c, {}).get('mastery_level', 0))
+    elif strategy == "breadth_first":
+        # Mix of new and partially learned concepts
+        sorted_concepts = sorted(target_concepts,
+                               key=lambda c: (student_data.get(c, {}).get('attempts_count', 0),
+                                             1 - student_data.get(c, {}).get('mastery_level', 0)))
+    else:  # adaptive or other
+        def adaptive_score(concept_id):
+            data = student_data.get(concept_id, {})
+            mastery = data.get('mastery_level', 0)
+            attempts = data.get('attempts_count', 0)
+            return (1 - mastery) * (1 + min(attempts / 10, 1))
+        sorted_concepts = sorted(target_concepts, key=adaptive_score, reverse=True)
+
+    # Limit to max_concepts
+    selected_concepts = sorted_concepts[:max_concepts]
+
+    # Generate learning path with adaptive recommendations
+    learning_path = []
+    for i, concept_id in enumerate(selected_concepts, 1):
+        concept_data = CONCEPT_GRAPH.get(concept_id, {"name": concept_id, "description": ""})
+        perf_data = student_data.get(concept_id, {})
+
+        # Estimate time based on mastery level
+        base_time = 30  # Base 30 minutes
+        mastery = perf_data.get('mastery_level', 0)
+        if mastery > 0.8:
+            estimated_time = base_time * 0.5  # Quick review
+        elif mastery > 0.5:
+            estimated_time = base_time * 0.8  # Moderate practice
+        else:
+            estimated_time = base_time * 1.2  # More practice needed
+
+        learning_path.append({
+            "step": i,
+            "concept_id": concept_id,
+            "concept_name": concept_data.get("name", concept_id),
+            "description": concept_data.get("description", ""),
+            "estimated_time_minutes": int(estimated_time),
+            "current_mastery": perf_data.get('mastery_level', 0),
+            "recommended_difficulty": perf_data.get('difficulty_preference', 0.5),
+            "adaptive_notes": _get_adaptive_notes(perf_data),
+            "resources": [
+                f"Adaptive practice for {concept_data.get('name', concept_id)}",
+                f"Personalized exercises at {perf_data.get('difficulty_preference', 0.5):.1f} difficulty",
+                f"Progress tracking and real-time feedback"
+            ]
+        })
+
+    total_time = sum(step["estimated_time_minutes"] for step in learning_path)
+
+    return {
+        "success": True,
+        "learning_path": learning_path,
+        "strategy": strategy,
+        "total_steps": len(learning_path),
+        "total_time_minutes": total_time,
+        "ai_powered": False,
+        "fallback_reason": f"AI analysis failed: {ai_error}" if ai_error else "Using basic adaptive algorithm",
+        "adaptive_features": [
+            "Performance-based ordering",
+            "Mastery-level time estimation",
+            "Basic difficulty adaptation"
+        ],
+        "generated_at": datetime.utcnow().isoformat()
+    }
+
+def _get_adaptive_notes(perf_data: dict) -> str:
+    """Generate adaptive notes based on performance data."""
+    mastery = perf_data.get('mastery_level', 0)
+    accuracy = perf_data.get('accuracy_rate', 0)
+    attempts = perf_data.get('attempts_count', 0)
+
+    if attempts == 0:
+        return "New concept - start with guided practice"
+    elif mastery > 0.8:
+        return "Well mastered - quick review recommended"
+    elif mastery > 0.5:
+        return "Good progress - continue with current difficulty"
+    elif accuracy < 0.5:
+        return "Needs more practice - consider easier difficulty"
+    else:
+        return "Building understanding - maintain current approach"
+
+@mcp.tool()
+async def get_student_progress_summary(student_id: str, days: int = 7) -> dict:
+    """
+    Get a comprehensive progress summary for a student.
+
+    Args:
+        student_id: Student identifier
+        days: Number of days to analyze
+
+    Returns:
+        Progress summary with analytics
+    """
+    try:
+        # Get student performance data
+        if student_id not in student_performances:
+            return {
+                "success": True,
+                "student_id": student_id,
+                "message": "No performance data available",
+                "concepts_practiced": 0,
+                "total_time_minutes": 0,
+                "average_mastery": 0.0
+            }
+
+        student_data = student_performances[student_id]
+
+        # Calculate summary statistics
+        total_concepts = len(student_data)
+        total_time = sum(perf.time_spent_minutes for perf in student_data.values())
+        total_attempts = sum(perf.attempts_count for perf in student_data.values())
+        average_mastery = sum(perf.mastery_level for perf in student_data.values()) / total_concepts if total_concepts > 0 else 0
+        average_accuracy = sum(perf.accuracy_rate for perf in student_data.values()) / total_concepts if total_concepts > 0 else 0
+
+        # Get recent events
+        cutoff_date = datetime.utcnow() - timedelta(days=days)
+        recent_events = [e for e in learning_events
+                        if e.student_id == student_id and e.timestamp >= cutoff_date]
+
+        # Concept breakdown
+        concept_summary = []
+        for concept_id, perf in student_data.items():
+            concept_summary.append({
+                "concept_id": concept_id,
+                "mastery_level": perf.mastery_level,
+                "accuracy_rate": perf.accuracy_rate,
+                "time_spent_minutes": perf.time_spent_minutes,
+                "attempts_count": perf.attempts_count,
+                "last_accessed": perf.last_accessed.isoformat() if perf.last_accessed else None,
+                "status": _get_concept_status(perf.mastery_level)
+            })
+
+        return {
+            "success": True,
+            "student_id": student_id,
+            "analysis_period_days": days,
+            "summary": {
+                "concepts_practiced": total_concepts,
+                "total_time_minutes": total_time,
+                "total_attempts": total_attempts,
+                "average_mastery": round(average_mastery, 2),
+                "average_accuracy": round(average_accuracy, 2),
+                "recent_events_count": len(recent_events)
+            },
+            "concept_breakdown": concept_summary,
+            "recommendations": _generate_progress_recommendations(student_data),
+            "generated_at": datetime.utcnow().isoformat()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def _get_concept_status(mastery_level: float) -> str:
+    """Get concept status based on mastery level."""
+    if mastery_level >= 0.8:
+        return "Mastered"
+    elif mastery_level >= 0.6:
+        return "Good Progress"
+    elif mastery_level >= 0.4:
+        return "Learning"
+    elif mastery_level >= 0.2:
+        return "Struggling"
+    else:
+        return "Needs Attention"
+
+def _generate_progress_recommendations(student_data: Dict[str, StudentPerformance]) -> List[str]:
+    """Generate recommendations based on student progress."""
+    recommendations = []
+
+    mastered_concepts = [cid for cid, perf in student_data.items() if perf.mastery_level >= 0.8]
+    struggling_concepts = [cid for cid, perf in student_data.items() if perf.mastery_level < 0.4]
+
+    if len(mastered_concepts) > 0:
+        recommendations.append(f"Great job! You've mastered {len(mastered_concepts)} concepts.")
+
+    if len(struggling_concepts) > 0:
+        recommendations.append(f"Focus on {len(struggling_concepts)} concepts that need more practice.")
+
+    # Check for concepts that haven't been accessed recently
+    week_ago = datetime.utcnow() - timedelta(days=7)
+    stale_concepts = [cid for cid, perf in student_data.items()
+                     if perf.last_accessed and perf.last_accessed < week_ago]
+
+    if len(stale_concepts) > 0:
+        recommendations.append(f"Consider reviewing {len(stale_concepts)} concepts you haven't practiced recently.")
+
+    return recommendations

mcp_server/tools/quiz_tools.py

@@ -1,8 +1,10 @@
 """
-Quiz generation tools for TutorX MCP.
+Quiz generation and interactive quiz tools for TutorX MCP.
 """
 import json
 import os
+import uuid
+from datetime import datetime
 from pathlib import Path
 from typing import Dict, Any, List, Optional
 from mcp_server.mcp_instance import mcp
@@ -14,6 +16,9 @@ PROMPT_TEMPLATE = (Path(__file__).parent.parent / "prompts" / "quiz_generation.t
 # Initialize Gemini model
 MODEL = GeminiFlash()
 
+# In-memory storage for quiz sessions (in production, use a database)
+QUIZ_SESSIONS = {}
+
 def clean_json_trailing_commas(json_text: str) -> str:
     import re
     return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
@@ -42,15 +47,226 @@ async def generate_quiz_tool(concept: str, difficulty: str = "medium") -> dict:
         valid_difficulties = ["easy", "medium", "hard"]
         if difficulty.lower() not in valid_difficulties:
             return {"error": f"difficulty must be one of {valid_difficulties}"}
-        prompt = (
-            f"Generate a {difficulty} quiz on the concept '{concept}'. "
-            f"Return a JSON object with a 'questions' field: a list of questions, each with 'question', 'options' (list), and 'answer'."
-        )
+
+        prompt = f"""Generate a {difficulty} quiz on the concept '{concept}'.
+        Return a JSON object with the following structure:
+        {{
+          "quiz_id": "unique_quiz_id",
+          "quiz_title": "Quiz about {concept}",
+          "concept": "{concept}",
+          "difficulty": "{difficulty}",
+          "questions": [
+            {{
+              "question_id": "q1",
+              "question": "...",
+              "options": ["A) ...", "B) ...", "C) ...", "D) ..."],
+              "correct_answer": "A) ...",
+              "explanation": "Detailed explanation of why this is correct and why others are wrong",
+              "hint": "A helpful hint for struggling students"
+            }}
+          ]
+        }}
+
+        Generate 3-5 questions appropriate for {difficulty} difficulty level."""
+
         llm_response = await MODEL.generate_text(prompt, temperature=0.7)
         try:
             quiz_data = extract_json_from_text(llm_response)
+            # Add unique quiz ID if not present
+            if "quiz_id" not in quiz_data:
+                quiz_data["quiz_id"] = str(uuid.uuid4())
+            # Add question IDs if not present
+            if "questions" in quiz_data:
+                for i, question in enumerate(quiz_data["questions"]):
+                    if "question_id" not in question:
+                        question["question_id"] = f"q{i+1}"
         except Exception:
             quiz_data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
         return quiz_data
     except Exception as e:
         return {"error": f"Error generating quiz: {str(e)}"}
+
+
+@mcp.tool()
+async def start_interactive_quiz_tool(quiz_data: dict, student_id: str = "anonymous") -> dict:
+    """
+    Start an interactive quiz session for a student.
+    """
+    try:
+        if not quiz_data or "questions" not in quiz_data:
+            return {"error": "Invalid quiz data provided"}
+
+        session_id = str(uuid.uuid4())
+        session = {
+            "session_id": session_id,
+            "student_id": student_id,
+            "quiz_data": quiz_data,
+            "current_question": 0,
+            "answers": {},
+            "score": 0,
+            "total_questions": len(quiz_data.get("questions", [])),
+            "started_at": datetime.now().isoformat(),
+            "completed": False
+        }
+
+        QUIZ_SESSIONS[session_id] = session
+
+        # Return first question
+        if session["total_questions"] > 0:
+            first_question = quiz_data["questions"][0]
+            return {
+                "session_id": session_id,
+                "quiz_title": quiz_data.get("quiz_title", "Quiz"),
+                "total_questions": session["total_questions"],
+                "current_question_number": 1,
+                "question": {
+                    "question_id": first_question.get("question_id"),
+                    "question": first_question.get("question"),
+                    "options": first_question.get("options", [])
+                }
+            }
+        else:
+            return {"error": "No questions found in quiz"}
+
+    except Exception as e:
+        return {"error": f"Error starting quiz session: {str(e)}"}
+
+
+@mcp.tool()
+async def submit_quiz_answer_tool(session_id: str, question_id: str, selected_answer: str) -> dict:
+    """
+    Submit an answer for a quiz question and get immediate feedback.
+    """
+    try:
+        if session_id not in QUIZ_SESSIONS:
+            return {"error": "Invalid session ID"}
+
+        session = QUIZ_SESSIONS[session_id]
+        if session["completed"]:
+            return {"error": "Quiz already completed"}
+
+        quiz_data = session["quiz_data"]
+        questions = quiz_data.get("questions", [])
+        current_q_index = session["current_question"]
+
+        if current_q_index >= len(questions):
+            return {"error": "No more questions available"}
+
+        current_question = questions[current_q_index]
+
+        # Check if this is the correct question
+        if current_question.get("question_id") != question_id:
+            return {"error": "Question ID mismatch"}
+
+        # Evaluate answer
+        correct_answer = current_question.get("correct_answer", "")
+        is_correct = selected_answer.strip() == correct_answer.strip()
+
+        # Store answer
+        session["answers"][question_id] = {
+            "selected": selected_answer,
+            "correct": correct_answer,
+            "is_correct": is_correct,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        if is_correct:
+            session["score"] += 1
+
+        # Prepare feedback
+        feedback = {
+            "question_id": question_id,
+            "selected_answer": selected_answer,
+            "correct_answer": correct_answer,
+            "is_correct": is_correct,
+            "explanation": current_question.get("explanation", ""),
+            "score": session["score"],
+            "total_questions": session["total_questions"]
+        }
+
+        # Move to next question
+        session["current_question"] += 1
+
+        # Check if quiz is completed
+        if session["current_question"] >= session["total_questions"]:
+            session["completed"] = True
+            session["completed_at"] = datetime.now().isoformat()
+            feedback["quiz_completed"] = True
+            feedback["final_score"] = session["score"]
+            feedback["percentage"] = round((session["score"] / session["total_questions"]) * 100, 1)
+        else:
+            # Get next question
+            next_question = questions[session["current_question"]]
+            feedback["next_question"] = {
+                "question_id": next_question.get("question_id"),
+                "question": next_question.get("question"),
+                "options": next_question.get("options", []),
+                "question_number": session["current_question"] + 1
+            }
+
+        return feedback
+
+    except Exception as e:
+        return {"error": f"Error submitting answer: {str(e)}"}
+
+
+@mcp.tool()
+async def get_quiz_hint_tool(session_id: str, question_id: str) -> dict:
+    """
+    Get a hint for the current quiz question.
+    """
+    try:
+        if session_id not in QUIZ_SESSIONS:
+            return {"error": "Invalid session ID"}
+
+        session = QUIZ_SESSIONS[session_id]
+        quiz_data = session["quiz_data"]
+        questions = quiz_data.get("questions", [])
+
+        # Find the question
+        question = None
+        for q in questions:
+            if q.get("question_id") == question_id:
+                question = q
+                break
+
+        if not question:
+            return {"error": "Question not found"}
+
+        hint = question.get("hint", "No hint available for this question.")
+
+        return {
+            "question_id": question_id,
+            "hint": hint
+        }
+
+    except Exception as e:
+        return {"error": f"Error getting hint: {str(e)}"}
+
+
+@mcp.tool()
+async def get_quiz_session_status_tool(session_id: str) -> dict:
+    """
+    Get the current status of a quiz session.
+    """
+    try:
+        if session_id not in QUIZ_SESSIONS:
+            return {"error": "Invalid session ID"}
+
+        session = QUIZ_SESSIONS[session_id]
+
+        return {
+            "session_id": session_id,
+            "student_id": session["student_id"],
+            "quiz_title": session["quiz_data"].get("quiz_title", "Quiz"),
+            "current_question": session["current_question"] + 1,
+            "total_questions": session["total_questions"],
+            "score": session["score"],
+            "completed": session["completed"],
+            "started_at": session["started_at"],
+            "completed_at": session.get("completed_at"),
+            "answers": session["answers"]
+        }
+
+    except Exception as e:
+        return {"error": f"Error getting session status: {str(e)}"}

tests/test_app_integration.py

@@ -0,0 +1,106 @@
+"""
+Test the app integration with the new adaptive learning tools.
+"""
+import asyncio
+import json
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+SERVER_URL = "http://localhost:8000/sse"
+
+async def extract_response_content(response):
+    """Helper function to extract content from MCP response (same as app.py)"""
+    # Handle direct dictionary responses (new format)
+    if isinstance(response, dict):
+        return response
+    
+    # Handle MCP response with content structure (CallToolResult format)
+    if hasattr(response, 'content') and isinstance(response.content, list):
+        for item in response.content:
+            # Handle TextContent objects
+            if hasattr(item, 'text') and item.text:
+                try:
+                    return json.loads(item.text)
+                except Exception as e:
+                    return {"raw_pretty": item.text, "parse_error": str(e)}
+            # Handle other content types
+            elif hasattr(item, 'type') and item.type == 'text':
+                try:
+                    return json.loads(str(item))
+                except Exception:
+                    return {"raw_pretty": str(item)}
+    
+    # Handle string responses
+    if isinstance(response, str):
+        try:
+            return json.loads(response)
+        except Exception:
+            return {"raw_pretty": response}
+    
+    # Handle any other response type - try to extract useful information
+    if hasattr(response, '__dict__'):
+        return {"raw_pretty": json.dumps(str(response), indent=2), "type": type(response).__name__}
+    
+    return {"raw_pretty": str(response), "type": type(response).__name__}
+
+async def start_adaptive_session_async(student_id, concept_id, difficulty):
+    try:
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                result = await session.call_tool("start_adaptive_session", {
+                    "student_id": student_id,
+                    "concept_id": concept_id,
+                    "initial_difficulty": float(difficulty)
+                })
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+async def get_adaptive_learning_path_async(student_id, concept_ids, strategy, max_concepts):
+    try:
+        # Parse concept_ids if it's a string
+        if isinstance(concept_ids, str):
+            concept_ids = [c.strip() for c in concept_ids.split(',') if c.strip()]
+        
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                result = await session.call_tool("get_adaptive_learning_path", {
+                    "student_id": student_id,
+                    "target_concepts": concept_ids,
+                    "strategy": strategy,
+                    "max_concepts": int(max_concepts)
+                })
+                return await extract_response_content(result)
+    except Exception as e:
+        return {"error": str(e)}
+
+async def test_app_integration():
+    """Test the app integration with adaptive learning tools."""
+    print("🧪 Testing App Integration with Adaptive Learning")
+    print("=" * 50)
+    
+    # Test 1: Start adaptive session (like the app would)
+    print("\n1. Testing start_adaptive_session_async...")
+    session_result = await start_adaptive_session_async(
+        student_id="app_test_student",
+        concept_id="algebra_basics",
+        difficulty=0.6
+    )
+    print(f"Result: {json.dumps(session_result, indent=2)}")
+    
+    # Test 2: Get adaptive learning path (like the app would)
+    print("\n2. Testing get_adaptive_learning_path_async...")
+    path_result = await get_adaptive_learning_path_async(
+        student_id="app_test_student",
+        concept_ids="algebra_basics,linear_equations,quadratic_equations",
+        strategy="adaptive",
+        max_concepts=5
+    )
+    print(f"Result: {json.dumps(path_result, indent=2)}")
+    
+    print("\n✅ App integration tests completed!")
+
+if __name__ == "__main__":
+    asyncio.run(test_app_integration())

tests/test_enhanced_adaptive_learning.py

@@ -0,0 +1,212 @@
+"""
+Test script for Enhanced Adaptive Learning with Gemini Integration
+"""
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+# Add the current directory to the Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+# Import the enhanced adaptive learning tools
+from mcp_server.tools.learning_path_tools import (
+    generate_adaptive_content,
+    analyze_learning_patterns,
+    optimize_learning_strategy,
+    start_adaptive_session,
+    record_learning_event,
+    get_adaptive_recommendations,
+    get_adaptive_learning_path,
+    get_student_progress_summary
+)
+
+async def test_enhanced_adaptive_learning():
+    """Test the enhanced adaptive learning system with Gemini integration."""
+    
+    print("🧠 Testing Enhanced Adaptive Learning with Gemini Integration")
+    print("=" * 60)
+    
+    student_id = "test_student_001"
+    concept_id = "linear_equations"
+    
+    try:
+        # Test 1: Start an adaptive session
+        print("\n1. 🚀 Starting Adaptive Session...")
+        session_result = await start_adaptive_session(
+            student_id=student_id,
+            concept_id=concept_id,
+            initial_difficulty=0.5
+        )
+        print(f"   ✅ Session started: {session_result.get('session_id', 'N/A')}")
+        print(f"   📊 Initial mastery: {session_result.get('current_mastery', 0):.2f}")
+        
+        session_id = session_result.get('session_id')
+        
+        # Test 2: Record some learning events
+        print("\n2. 📝 Recording Learning Events...")
+        events = [
+            {"type": "answer_correct", "data": {"time_taken": 25}},
+            {"type": "answer_correct", "data": {"time_taken": 30}},
+            {"type": "answer_incorrect", "data": {"time_taken": 45}},
+            {"type": "answer_correct", "data": {"time_taken": 20}},
+        ]
+        
+        for i, event in enumerate(events, 1):
+            event_result = await record_learning_event(
+                student_id=student_id,
+                concept_id=concept_id,
+                session_id=session_id,
+                event_type=event["type"],
+                event_data=event["data"]
+            )
+            print(f"   📊 Event {i}: {event['type']} - Mastery: {event_result.get('updated_mastery', 0):.2f}")
+        
+        # Test 3: Generate adaptive content
+        print("\n3. 🎨 Generating Adaptive Content...")
+        content_types = ["explanation", "practice", "feedback"]
+        
+        for content_type in content_types:
+            try:
+                content_result = await generate_adaptive_content(
+                    student_id=student_id,
+                    concept_id=concept_id,
+                    content_type=content_type,
+                    difficulty_level=0.6,
+                    learning_style="visual"
+                )
+                
+                if content_result.get("success"):
+                    print(f"   ✅ {content_type.title()} content generated successfully")
+                    if content_type == "explanation" and "explanation" in content_result:
+                        explanation = content_result["explanation"][:100] + "..." if len(content_result["explanation"]) > 100 else content_result["explanation"]
+                        print(f"      📖 Preview: {explanation}")
+                else:
+                    print(f"   ⚠️  {content_type.title()} content generation failed: {content_result.get('error', 'Unknown error')}")
+            except Exception as e:
+                print(f"   ❌ Error generating {content_type} content: {str(e)}")
+        
+        # Test 4: Get AI-powered recommendations
+        print("\n4. 🤖 Getting AI-Powered Recommendations...")
+        try:
+            recommendations = await get_adaptive_recommendations(
+                student_id=student_id,
+                concept_id=concept_id,
+                session_id=session_id
+            )
+            
+            if recommendations.get("success"):
+                print(f"   ✅ Recommendations generated (AI-powered: {recommendations.get('ai_powered', False)})")
+                immediate_actions = recommendations.get("immediate_actions", [])
+                print(f"   📋 Immediate actions: {len(immediate_actions)} recommendations")
+                
+                if immediate_actions:
+                    first_action = immediate_actions[0]
+                    print(f"      🎯 Top recommendation: {first_action.get('action', 'N/A')}")
+            else:
+                print(f"   ❌ Recommendations failed: {recommendations.get('error', 'Unknown error')}")
+        except Exception as e:
+            print(f"   ❌ Error getting recommendations: {str(e)}")
+        
+        # Test 5: Analyze learning patterns
+        print("\n5. 📊 Analyzing Learning Patterns...")
+        try:
+            patterns = await analyze_learning_patterns(
+                student_id=student_id,
+                analysis_days=30
+            )
+            
+            if patterns.get("success"):
+                print(f"   ✅ Learning patterns analyzed (AI-powered: {patterns.get('ai_powered', False)})")
+                if "learning_style_analysis" in patterns:
+                    print(f"   🎨 Learning style insights available")
+                if "strength_areas" in patterns:
+                    strengths = patterns.get("strength_areas", [])
+                    print(f"   💪 Identified strengths: {len(strengths)} areas")
+            else:
+                print(f"   ⚠️  Pattern analysis: {patterns.get('message', 'No data available')}")
+        except Exception as e:
+            print(f"   ❌ Error analyzing patterns: {str(e)}")
+        
+        # Test 6: Optimize learning strategy
+        print("\n6. 🎯 Optimizing Learning Strategy...")
+        try:
+            strategy = await optimize_learning_strategy(
+                student_id=student_id,
+                current_concept=concept_id
+            )
+            
+            if strategy.get("success"):
+                print(f"   ✅ Strategy optimized (AI-powered: {strategy.get('ai_powered', False)})")
+                if "optimized_strategy" in strategy:
+                    opt_strategy = strategy["optimized_strategy"]
+                    print(f"   🎯 Primary approach: {opt_strategy.get('primary_approach', 'N/A')}")
+                    print(f"   📈 Difficulty recommendation: {opt_strategy.get('difficulty_recommendation', 'N/A')}")
+            else:
+                print(f"   ⚠️  Strategy optimization: {strategy.get('message', 'Using default strategy')}")
+        except Exception as e:
+            print(f"   ❌ Error optimizing strategy: {str(e)}")
+        
+        # Test 7: Generate adaptive learning path
+        print("\n7. 🛤️  Generating Adaptive Learning Path...")
+        try:
+            learning_path = await get_adaptive_learning_path(
+                student_id=student_id,
+                target_concepts=["algebra_basics", "linear_equations", "quadratic_equations"],
+                strategy="adaptive",
+                max_concepts=5
+            )
+            
+            if learning_path.get("success"):
+                print(f"   ✅ Learning path generated (AI-powered: {learning_path.get('ai_powered', False)})")
+                path_steps = learning_path.get("learning_path", [])
+                print(f"   📚 Path contains {len(path_steps)} steps")
+                total_time = learning_path.get("total_time_minutes", 0)
+                print(f"   ⏱️  Estimated total time: {total_time} minutes")
+                
+                if path_steps:
+                    first_step = path_steps[0]
+                    print(f"   🎯 First step: {first_step.get('concept_name', 'N/A')}")
+            else:
+                print(f"   ❌ Learning path failed: {learning_path.get('error', 'Unknown error')}")
+        except Exception as e:
+            print(f"   ❌ Error generating learning path: {str(e)}")
+        
+        # Test 8: Get progress summary
+        print("\n8. 📈 Getting Progress Summary...")
+        try:
+            progress = await get_student_progress_summary(
+                student_id=student_id,
+                days=7
+            )
+            
+            if progress.get("success"):
+                summary = progress.get("summary", {})
+                print(f"   ✅ Progress summary generated")
+                print(f"   📊 Concepts practiced: {summary.get('concepts_practiced', 0)}")
+                print(f"   ⏱️  Total time: {summary.get('total_time_minutes', 0)} minutes")
+                print(f"   🎯 Average mastery: {summary.get('average_mastery', 0):.2f}")
+                print(f"   ✅ Average accuracy: {summary.get('average_accuracy', 0):.2f}")
+            else:
+                print(f"   ⚠️  Progress summary: {progress.get('message', 'No data available')}")
+        except Exception as e:
+            print(f"   ❌ Error getting progress summary: {str(e)}")
+        
+        print("\n" + "=" * 60)
+        print("🎉 Enhanced Adaptive Learning Test Completed!")
+        print("\n📋 Summary:")
+        print("   ✅ All core adaptive learning functions tested")
+        print("   🧠 Gemini AI integration verified")
+        print("   📊 Performance tracking operational")
+        print("   🎯 Personalization features active")
+        print("   🛤️  Learning path optimization working")
+        
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    print("🚀 Starting Enhanced Adaptive Learning Test...")
+    asyncio.run(test_enhanced_adaptive_learning())

tests/test_import.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Simple test script to verify adaptive learning imports work correctly.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the project root to the Python path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+def test_imports():
+    """Test all adaptive learning imports."""
+    print("🧪 Testing Adaptive Learning System Imports")
+    print("=" * 50)
+    
+    try:
+        print("1. Testing analytics imports...")
+        from mcp_server.analytics.performance_tracker import PerformanceTracker
+        from mcp_server.analytics.learning_analytics import LearningAnalytics
+        from mcp_server.analytics.progress_monitor import ProgressMonitor
+        print("   ✅ Analytics imports successful")
+        
+        print("2. Testing algorithms imports...")
+        from mcp_server.algorithms.adaptive_engine import AdaptiveLearningEngine
+        from mcp_server.algorithms.difficulty_adjuster import DifficultyAdjuster
+        from mcp_server.algorithms.path_optimizer import PathOptimizer
+        from mcp_server.algorithms.mastery_detector import MasteryDetector
+        print("   ✅ Algorithms imports successful")
+        
+        print("3. Testing models imports...")
+        from mcp_server.models.student_profile import StudentProfile
+        print("   ✅ Models imports successful")
+        
+        print("4. Testing storage imports...")
+        from mcp_server.storage.memory_store import MemoryStore
+        print("   ✅ Storage imports successful")
+        
+        print("5. Testing component initialization...")
+        performance_tracker = PerformanceTracker()
+        learning_analytics = LearningAnalytics(performance_tracker)
+        progress_monitor = ProgressMonitor(performance_tracker, learning_analytics)
+        adaptive_engine = AdaptiveLearningEngine(performance_tracker, learning_analytics)
+        difficulty_adjuster = DifficultyAdjuster(performance_tracker)
+        path_optimizer = PathOptimizer(performance_tracker, learning_analytics)
+        mastery_detector = MasteryDetector(performance_tracker)
+        print("   ✅ Component initialization successful")
+        
+        print("6. Testing adaptive learning tools import...")
+        import mcp_server.tools.adaptive_learning_tools
+        print("   ✅ Adaptive learning tools import successful")
+        
+        print("\n🎉 All imports successful!")
+        print("The adaptive learning system is ready to use.")
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ Import failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_basic_functionality():
+    """Test basic functionality without async."""
+    print("\n🔧 Testing Basic Functionality")
+    print("=" * 50)
+    
+    try:
+        from mcp_server.analytics.performance_tracker import PerformanceTracker
+        from mcp_server.models.student_profile import StudentProfile
+        from mcp_server.storage.memory_store import MemoryStore
+        
+        # Test performance tracker
+        print("1. Testing PerformanceTracker...")
+        tracker = PerformanceTracker()
+        print(f"   ✅ Created tracker with {len(tracker.student_performances)} students")
+        
+        # Test student profile
+        print("2. Testing StudentProfile...")
+        profile = StudentProfile(student_id="test_001", name="Test Student")
+        print(f"   ✅ Created profile for {profile.name}")
+        
+        # Test memory store
+        print("3. Testing MemoryStore...")
+        store = MemoryStore()
+        store.save_student_profile(profile)
+        retrieved = store.get_student_profile("test_001")
+        print(f"   ✅ Stored and retrieved profile: {retrieved.name if retrieved else 'None'}")
+        
+        print("\n🎉 Basic functionality test successful!")
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ Functionality test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    print("🧠 TutorX-MCP Adaptive Learning System - Import Test")
+    print("=" * 60)
+    
+    # Test imports
+    imports_ok = test_imports()
+    
+    if imports_ok:
+        # Test basic functionality
+        functionality_ok = test_basic_functionality()
+        
+        if functionality_ok:
+            print("\n✅ All tests passed! The system is ready.")
+            sys.exit(0)
+        else:
+            print("\n❌ Functionality tests failed.")
+            sys.exit(1)
+    else:
+        print("\n❌ Import tests failed.")
+        sys.exit(1)

tests/test_interactive_quiz.py

@@ -0,0 +1,106 @@
+"""
+Test script for Interactive Quiz functionality
+"""
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+# Add the current directory to the Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+# Import the interactive quiz tools
+from mcp_server.tools.quiz_tools import (
+    generate_quiz_tool,
+    start_interactive_quiz_tool,
+    submit_quiz_answer_tool,
+    get_quiz_hint_tool,
+    get_quiz_session_status_tool
+)
+
+async def test_interactive_quiz():
+    """Test the complete interactive quiz workflow"""
+    print("🧪 Testing Interactive Quiz Functionality")
+    print("=" * 50)
+    
+    try:
+        # Test 1: Generate a quiz
+        print("\n1. 📝 Generating Quiz...")
+        quiz_data = await generate_quiz_tool("Linear Equations", "medium")
+        print(f"   ✅ Quiz generated: {quiz_data.get('quiz_title', 'N/A')}")
+        
+        if "error" in quiz_data:
+            print(f"   ❌ Error generating quiz: {quiz_data['error']}")
+            return
+        
+        # Test 2: Start interactive quiz session
+        print("\n2. 🚀 Starting Interactive Quiz Session...")
+        session_result = await start_interactive_quiz_tool(quiz_data, "test_student_001")
+        print(f"   ✅ Session started: {session_result.get('session_id', 'N/A')}")
+        
+        if "error" in session_result:
+            print(f"   ❌ Error starting session: {session_result['error']}")
+            return
+        
+        session_id = session_result.get('session_id')
+        first_question = session_result.get('question', {})
+        
+        print(f"   📊 Total questions: {session_result.get('total_questions', 0)}")
+        print(f"   ❓ First question: {first_question.get('question', 'N/A')[:50]}...")
+        
+        # Test 3: Get a hint for the first question
+        print("\n3. 💡 Getting Hint...")
+        question_id = first_question.get('question_id')
+        hint_result = await get_quiz_hint_tool(session_id, question_id)
+        print(f"   ✅ Hint: {hint_result.get('hint', 'N/A')[:50]}...")
+        
+        # Test 4: Submit an answer (let's try the first option)
+        print("\n4. ✍️ Submitting Answer...")
+        options = first_question.get('options', [])
+        if options:
+            selected_answer = options[0]  # Select first option
+            answer_result = await submit_quiz_answer_tool(session_id, question_id, selected_answer)
+            
+            print(f"   ✅ Answer submitted: {selected_answer}")
+            print(f"   📊 Correct: {answer_result.get('is_correct', False)}")
+            print(f"   💯 Score: {answer_result.get('score', 0)}/{answer_result.get('total_questions', 0)}")
+            
+            if answer_result.get('explanation'):
+                print(f"   📖 Explanation: {answer_result['explanation'][:100]}...")
+            
+            # Check if there's a next question
+            if answer_result.get('next_question'):
+                next_q = answer_result['next_question']
+                print(f"   ➡️ Next question: {next_q.get('question', 'N/A')[:50]}...")
+                
+                # Test 5: Submit answer for second question
+                print("\n5. ✍️ Submitting Second Answer...")
+                next_question_id = next_q.get('question_id')
+                next_options = next_q.get('options', [])
+                if next_options:
+                    # Try the second option this time
+                    selected_answer2 = next_options[1] if len(next_options) > 1 else next_options[0]
+                    answer_result2 = await submit_quiz_answer_tool(session_id, next_question_id, selected_answer2)
+                    
+                    print(f"   ✅ Answer submitted: {selected_answer2}")
+                    print(f"   📊 Correct: {answer_result2.get('is_correct', False)}")
+                    print(f"   💯 Score: {answer_result2.get('score', 0)}/{answer_result2.get('total_questions', 0)}")
+        
+        # Test 6: Check session status
+        print("\n6. 📊 Checking Session Status...")
+        status_result = await get_quiz_session_status_tool(session_id)
+        print(f"   ✅ Session status retrieved")
+        print(f"   📈 Progress: {status_result.get('current_question', 0)}/{status_result.get('total_questions', 0)}")
+        print(f"   💯 Final Score: {status_result.get('score', 0)}")
+        print(f"   ✅ Completed: {status_result.get('completed', False)}")
+        
+        print("\n🎉 Interactive Quiz Test Completed Successfully!")
+        
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(test_interactive_quiz())

tests/test_mcp_connection.py

@@ -0,0 +1,58 @@
+"""
+Test MCP connection and tool availability.
+"""
+import asyncio
+import json
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+SERVER_URL = "http://localhost:8000/sse"
+
+async def test_mcp_connection():
+    """Test MCP connection and list available tools."""
+    print("🔗 Testing MCP Connection")
+    print("=" * 40)
+    
+    try:
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                
+                # List available tools
+                print("📋 Available Tools:")
+                tools = session.list_tools()
+                if hasattr(tools, 'tools'):
+                    for tool in tools.tools:
+                        print(f"  ✅ {tool.name}")
+                else:
+                    print(f"  Tools response: {tools}")
+                
+                # Test calling start_adaptive_session
+                print("\n🧪 Testing start_adaptive_session tool...")
+                try:
+                    response = await session.call_tool("start_adaptive_session", {
+                        "student_id": "test_student",
+                        "concept_id": "test_concept",
+                        "initial_difficulty": 0.5
+                    })
+                    print(f"  ✅ Tool call successful: {response}")
+                except Exception as e:
+                    print(f"  ❌ Tool call failed: {e}")
+                
+                # Test calling get_learning_path (existing tool)
+                print("\n🧪 Testing get_learning_path tool...")
+                try:
+                    response = await session.call_tool("get_learning_path", {
+                        "student_id": "test_student",
+                        "concept_ids": ["test_concept"],
+                        "student_level": "beginner"
+                    })
+                    print(f"  ✅ Tool call successful: {type(response)}")
+                except Exception as e:
+                    print(f"  ❌ Tool call failed: {e}")
+                
+    except Exception as e:
+        print(f"❌ Connection failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_mcp_connection())

tests/test_new_adaptive_learning.py

@@ -0,0 +1,106 @@
+"""
+Test script for the new adaptive learning implementation.
+"""
+import asyncio
+import sys
+import os
+from pathlib import Path
+
+# Add the current directory to the Python path
+current_dir = Path(__file__).parent
+sys.path.insert(0, str(current_dir))
+
+# Import the adaptive learning tools
+from mcp_server.tools.learning_path_tools import (
+    start_adaptive_session,
+    record_learning_event,
+    get_adaptive_recommendations,
+    get_adaptive_learning_path,
+    get_student_progress_summary
+)
+
+async def test_adaptive_learning():
+    """Test the new adaptive learning system."""
+    print("🧠 Testing New Adaptive Learning System")
+    print("=" * 50)
+    
+    # Test 1: Start an adaptive session
+    print("\n1. Starting adaptive session...")
+    session_result = await start_adaptive_session(
+        student_id="test_student_001",
+        concept_id="algebra_linear_equations",
+        initial_difficulty=0.5
+    )
+    print(f"Session Result: {session_result}")
+    
+    if session_result.get("success"):
+        session_id = session_result.get("session_id")
+        print(f"✅ Session started successfully: {session_id}")
+        
+        # Test 2: Record some learning events
+        print("\n2. Recording learning events...")
+        
+        # Record a correct answer
+        event_result1 = await record_learning_event(
+            student_id="test_student_001",
+            concept_id="algebra_linear_equations",
+            session_id=session_id,
+            event_type="answer_correct",
+            event_data={"time_taken": 25, "difficulty": 0.5}
+        )
+        print(f"Event 1 (correct): {event_result1}")
+        
+        # Record an incorrect answer
+        event_result2 = await record_learning_event(
+            student_id="test_student_001",
+            concept_id="algebra_linear_equations",
+            session_id=session_id,
+            event_type="answer_incorrect",
+            event_data={"time_taken": 45, "difficulty": 0.5}
+        )
+        print(f"Event 2 (incorrect): {event_result2}")
+        
+        # Record another correct answer
+        event_result3 = await record_learning_event(
+            student_id="test_student_001",
+            concept_id="algebra_linear_equations",
+            session_id=session_id,
+            event_type="answer_correct",
+            event_data={"time_taken": 20, "difficulty": 0.5}
+        )
+        print(f"Event 3 (correct): {event_result3}")
+        
+        # Test 3: Get adaptive recommendations
+        print("\n3. Getting adaptive recommendations...")
+        recommendations = await get_adaptive_recommendations(
+            student_id="test_student_001",
+            concept_id="algebra_linear_equations",
+            session_id=session_id
+        )
+        print(f"Recommendations: {recommendations}")
+        
+        # Test 4: Get adaptive learning path
+        print("\n4. Getting adaptive learning path...")
+        learning_path = await get_adaptive_learning_path(
+            student_id="test_student_001",
+            target_concepts=["algebra_basics", "linear_equations", "quadratic_equations"],
+            strategy="adaptive",
+            max_concepts=5
+        )
+        print(f"Learning Path: {learning_path}")
+        
+        # Test 5: Get progress summary
+        print("\n5. Getting progress summary...")
+        progress = await get_student_progress_summary(
+            student_id="test_student_001",
+            days=7
+        )
+        print(f"Progress Summary: {progress}")
+        
+        print("\n✅ All tests completed successfully!")
+        
+    else:
+        print("❌ Failed to start session")
+
+if __name__ == "__main__":
+    asyncio.run(test_adaptive_learning())