Core and Advanced Features is working with mock data.

app.py

@@ -31,6 +31,126 @@ def image_to_base64(img):
     img_str = base64.b64encode(buffered.getvalue()).decode()
     return img_str
 
+async def load_concept_graph(concept_id: str = None):
+    """
+    Load and visualize the concept graph for a given concept ID.
+    If no concept_id is provided, returns the first available concept.
+    
+    Returns:
+        tuple: (figure, concept_details, related_concepts) or (None, error_dict, [])
+    """
+    try:
+        print(f"[DEBUG] Loading concept graph for concept_id: {concept_id}")
+        
+        # Get concept graph data from the server
+        # First try direct API call, fall back to MCP tool if needed
+        result = await client.get_concept_graph(concept_id, use_mcp=False)
+        
+        # If direct API call fails, try MCP tool
+        if "error" in result:
+            print(f"[DEBUG] Direct API call failed, trying MCP tool: {result}")
+            result = await client.get_concept_graph(concept_id, use_mcp=True)
+        print(f"[DEBUG] Server response: {result}")
+        
+        if not result or not isinstance(result, dict):
+            error_msg = "Invalid server response"
+            print(f"[ERROR] {error_msg}")
+            return None, {"error": error_msg}, []
+        
+        if "error" in result:
+            print(f"[ERROR] Server returned error: {result['error']}")
+            return None, {"error": result["error"]}, []
+        
+        # Handle response when no specific concept_id was requested
+        if "concepts" in result and not concept_id:
+            if not result["concepts"]:
+                error_msg = "No concepts available"
+                print(f"[ERROR] {error_msg}")
+                return None, {"error": error_msg}, []
+            concept = result["concepts"][0]
+            print(f"[DEBUG] Using first concept from list: {concept.get('id')}")
+        else:
+            concept = result
+            print(f"[DEBUG] Using direct concept: {concept.get('id')}")
+        
+        # Validate the concept structure
+        if not isinstance(concept, dict) or not concept.get('id'):
+            error_msg = "Invalid concept data structure"
+            print(f"[ERROR] {error_msg}: {concept}")
+            return None, {"error": error_msg}, []
+        
+        # Create a simple visualization using matplotlib
+        import matplotlib.pyplot as plt
+        import networkx as nx
+        
+        # Create a directed graph
+        G = nx.DiGraph()
+        
+        # Add the main concept node
+        G.add_node(concept["id"], label=concept["name"], type="concept")
+        
+        # Add related concepts
+        related_concepts = []
+        if "related" in concept:
+            for rel_id in concept["related"]:
+                rel_result = await client.get_concept_graph(rel_id)
+                if "error" not in rel_result:
+                    G.add_node(rel_id, label=rel_result["name"], type="related")
+                    G.add_edge(concept["id"], rel_id, relationship="related_to")
+                    related_concepts.append([rel_id, rel_result.get("name", ""), rel_result.get("description", "")])
+        
+        # Add prerequisites if any
+        if "prerequisites" in concept:
+            for prereq_id in concept["prerequisites"]:
+                prereq_result = await client.get_concept_graph(prereq_id)
+                if "error" not in prereq_result:
+                    G.add_node(prereq_id, label=prereq_result["name"], type="prerequisite")
+                    G.add_edge(prereq_id, concept["id"], relationship="prerequisite_for")
+        
+        # Draw the graph
+        plt.figure(figsize=(10, 8))
+        pos = nx.spring_layout(G)
+        
+        # Draw nodes with different colors based on type
+        node_colors = []
+        for node in G.nodes():
+            if G.nodes[node].get("type") == "concept":
+                node_colors.append("lightblue")
+            elif G.nodes[node].get("type") == "prerequisite":
+                node_colors.append("lightcoral")
+            else:
+                node_colors.append("lightgreen")
+        
+        nx.draw_networkx_nodes(G, pos, node_size=2000, node_color=node_colors, alpha=0.8)
+        nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
+        
+        # Add labels
+        labels = {node: G.nodes[node].get("label", node) for node in G.nodes()}
+        nx.draw_networkx_labels(G, pos, labels, font_size=10, font_weight="bold")
+        
+        # Add edge labels
+        edge_labels = {(u, v): d["relationship"] for u, v, d in G.edges(data=True)}
+        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
+        
+        plt.title(f"Concept Graph: {concept.get('name', concept_id)}")
+        plt.axis("off")
+        
+        # Return the figure and concept details
+        concept_details = {
+            "id": concept.get("id", ""),
+            "name": concept.get("name", ""),
+            "description": concept.get("description", ""),
+            "related_concepts_count": len(concept.get("related", [])),
+            "prerequisites_count": len(concept.get("prerequisites", []))
+        }
+        
+        return plt.gcf(), concept_details, related_concepts
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, {"error": f"Failed to load concept graph: {str(e)}"}, []
+
 async def api_request(endpoint, method="GET", params=None, json_data=None):
     """Make an API request to the server"""
     url = f"{SERVER_URL}/api/{endpoint}"
@@ -70,42 +190,45 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
     with gr.Tabs() as tabs:
         # Tab 1: Core Features
         with gr.Tab("Core Features"):
-            gr.Markdown("## Adaptive Learning Engine")
-            
-            with gr.Row():
-                with gr.Column():
-                    concept_id_input = gr.Dropdown(
-                        choices=["math_algebra_basics", "math_algebra_linear_equations", "math_algebra_quadratic_equations"],
-                        label="Select Concept",
-                        value="math_algebra_linear_equations"
-                    )
-                    assess_btn = gr.Button("Assess Skill")
-                
-                with gr.Column():
-                    assessment_output = gr.JSON(label="Skill Assessment")
-            async def on_assess_click(concept_id):
-                result = await api_request("assess_skill", "GET", {"student_id": "student_12345", "concept_id": concept_id})
-                return result
+            with gr.Blocks() as concept_graph_tab:
+                gr.Markdown("## Concept Graph Visualization")
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        concept_id = gr.Dropdown(
+                            label="Select a Concept",
+                            choices=["python", "functions", "oop", "data_structures"],
+                            value="python",
+                            interactive=True
+                        )
+                        load_concept_btn = gr.Button("Load Concept Graph", variant="primary")
+                        
+                        # Concept details
+                        concept_details = gr.JSON(label="Concept Details")
+                        
+                        # Related concepts
+                        related_concepts = gr.Dataframe(
+                            headers=["ID", "Name", "Description"],
+                            datatype=["str", "str", "str"],
+                            label="Related Concepts"
+                        )
+                    
+                    # Graph visualization
+                    with gr.Column(scale=7):
+                        graph_output = gr.Plot(label="Concept Graph")
                 
-            assess_btn.click(
-                fn=on_assess_click,
-                inputs=[concept_id_input],
-                outputs=[assessment_output]
-            )
-            
-            gr.Markdown("## Concept Graph")
-            concept_graph_btn = gr.Button("Show Concept Graph")
-            concept_graph_output = gr.JSON(label="Concept Graph")
-            
-            async def on_concept_graph_click():
-                result = await api_request("concept_graph")
-                return result
+                # Button click handler
+                load_concept_btn.click(
+                    fn=load_concept_graph,
+                    inputs=[concept_id],
+                    outputs=[graph_output, concept_details, related_concepts]
+                )
                 
-            concept_graph_btn.click(
-                fn=on_concept_graph_click,
-                inputs=[],
-                outputs=[concept_graph_output]
-            )
+                # Load default concept on tab click
+                concept_graph_tab.load(
+                    fn=load_concept_graph,
+                    inputs=[concept_id],
+                    outputs=[graph_output, concept_details, related_concepts]
+                )
             
             gr.Markdown("## Assessment Generation")
             with gr.Row():
@@ -122,10 +245,15 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     quiz_output = gr.JSON(label="Generated Quiz")
             
             async def on_generate_quiz(concepts, difficulty):
+                # Convert the request to match the expected format
+                request_data = {
+                    "concept_ids": concepts if isinstance(concepts, list) else [concepts],
+                    "difficulty": int(difficulty)
+                }
                 result = await api_request(
                     "generate_quiz", 
                     "POST", 
-                    json_data={"concept_ids": concepts, "difficulty": difficulty}
+                    json_data=request_data
                 )
                 return result
                 
@@ -148,8 +276,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 
                 with gr.Column():
                     lesson_output = gr.JSON(label="Lesson Plan")
+            async def generate_lesson_async(topic, grade, duration):
+                return await client.generate_lesson(topic, grade, duration)
+                
             gen_lesson_btn.click(
-                fn=lambda x, y, z: asyncio.run(client.generate_lesson(x, y, z)),
+                fn=generate_lesson_async,
                 inputs=[topic_input, grade_input, duration_input],
                 outputs=[lesson_output]
             )
@@ -159,17 +290,49 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
             with gr.Row():
                 with gr.Column():
                     country_input = gr.Dropdown(
-                        choices=["us", "uk"],
+                        choices=["US", "UK"],
                         label="Country",
-                        value="us"
+                        value="US"
                     )
                     standards_btn = gr.Button("Get Standards")
                 
                 with gr.Column():
                     standards_output = gr.JSON(label="Curriculum Standards")
             
+            async def get_standards_async(country):
+                try:
+                    # Convert display text to lowercase for the API
+                    country_code = country.lower()
+                    response = await client.get_curriculum_standards(country_code)
+                    
+                    # Format the response for better display
+                    if "standards" in response:
+                        formatted = {
+                            "country": response["standards"]["name"],
+                            "subjects": {},
+                            "website": response["standards"].get("website", "")
+                        }
+                        
+                        # Format subjects and domains
+                        for subj_key, subj_info in response["standards"]["subjects"].items():
+                            formatted["subjects"][subj_key] = {
+                                "description": subj_info["description"],
+                                "domains": subj_info["domains"]
+                            }
+                        
+                        # Add grade levels or key stages if available
+                        if "grade_levels" in response["standards"]:
+                            formatted["grade_levels"] = response["standards"]["grade_levels"]
+                        elif "key_stages" in response["standards"]:
+                            formatted["key_stages"] = response["standards"]["key_stages"]
+                            
+                        return formatted
+                    return response
+                except Exception as e:
+                    return {"error": f"Failed to fetch standards: {str(e)}"}
+                
             standards_btn.click(
-                fn=lambda x: asyncio.run(client.get_curriculum_standards(x)),
+                fn=get_standards_async,
                 inputs=[country_input],
                 outputs=[standards_output]
             )
@@ -185,8 +348,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 
                 with gr.Column():
                     text_output = gr.JSON(label="Response")
+            async def text_interaction_async(text):
+                return await client.text_interaction(text, "student_12345")
+                
             text_btn.click(
-                fn=lambda x: asyncio.run(client.text_interaction(x, "student_12345")),
+                fn=text_interaction_async,
                 inputs=[text_input],
                 outputs=[text_output]
             )
@@ -201,8 +367,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 with gr.Column():
                     drawing_output = gr.JSON(label="Recognition Results")
             
+            async def handwriting_async(drawing):
+                return await client.handwriting_recognition(image_to_base64(drawing), "student_12345")
+                
             drawing_btn.click(
-                fn=lambda x: asyncio.run(client.handwriting_recognition(image_to_base64(x), "student_12345")),
+                fn=handwriting_async,
                 inputs=[drawing_input],
                 outputs=[drawing_output]
             )
@@ -210,27 +379,21 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
         # Tab 4: Analytics
         with gr.Tab("Analytics"):
             gr.Markdown("## Student Performance")
-            analytics_btn = gr.Button("Generate Analytics Report")
-            timeframe = gr.Slider(minimum=7, maximum=90, value=30, step=1, label="Timeframe (days)")
-            analytics_output = gr.JSON(label="Performance Analytics")
-            analytics_btn.click(
-                fn=lambda x: asyncio.run(client.get_student_analytics("student_12345", x)),
-                inputs=[timeframe],
-                outputs=[analytics_output]
-            )
-            
-            gr.Markdown("## Error Pattern Analysis")
             
+            # Error Pattern Analysis
             error_concept = gr.Dropdown(
                 choices=["math_algebra_basics", "math_algebra_linear_equations", "math_algebra_quadratic_equations"],
-                label="Select Concept for Error Analysis",
+                label="Select Concept for Analysis",
                 value="math_algebra_linear_equations"
             )
-            error_btn = gr.Button("Analyze Errors")
-            error_output = gr.JSON(label="Error Pattern Analysis")
+            error_btn = gr.Button("Analyze Concept")
+            error_output = gr.JSON(label="Analysis Results")
             
+            async def analyze_errors_async(concept):
+                return await client.analyze_error_patterns("student_12345", concept)
+                
             error_btn.click(
-                fn=lambda x: asyncio.run(client.analyze_error_patterns("student_12345", x)),
+                fn=analyze_errors_async,
                 inputs=[error_concept],
                 outputs=[error_output]
             )
@@ -254,8 +417,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 with gr.Column():
                     plagiarism_output = gr.JSON(label="Originality Report")
             
+            async def check_plagiarism_async(submission, reference):
+                return await client.check_submission_originality(submission, [reference])
+                
             plagiarism_btn.click(
-                fn=lambda x, y: asyncio.run(client.check_submission_originality(x, [y])),
+                fn=check_plagiarism_async,
                 inputs=[submission_input, reference_input],
                 outputs=[plagiarism_output]
             )

client.py

@@ -37,13 +37,14 @@ class TutorXClient:
                 }
             )
     
-    async def _call_tool(self, tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
+    async def _call_tool(self, tool_name: str, params: Dict[str, Any], method: str = "POST") -> Dict[str, Any]:
         """
         Call an MCP tool on the server
         
         Args:
             tool_name: Name of the tool to call
             params: Parameters to pass to the tool
+            method: HTTP method to use (GET or POST)
             
         Returns:
             Tool response
@@ -51,21 +52,36 @@ class TutorXClient:
         await self._ensure_session()
         try:
             url = f"{self.server_url}{API_PREFIX}/{tool_name}"
-            async with self.session.get(url, params=params, timeout=30) as response:
-                if response.status == 200:
-                    return await response.json()
-                else:
-                    error = await response.text()
-                    return {
-                        "error": f"API error ({response.status}): {error}",
-                        "timestamp": datetime.now().isoformat()
-                    }
+            
+            # Convert params to query string for GET requests
+            if method.upper() == "GET":
+                from urllib.parse import urlencode
+                if params:
+                    query_string = urlencode(params, doseq=True)
+                    url = f"{url}?{query_string}"
+                async with self.session.get(url, timeout=30) as response:
+                    return await self._handle_response(response)
+            else:
+                async with self.session.post(url, json=params, timeout=30) as response:
+                    return await self._handle_response(response)
+                    
         except Exception as e:
             return {
                 "error": f"Failed to call tool: {str(e)}",
                 "timestamp": datetime.now().isoformat()
             }
     
+    async def _handle_response(self, response) -> Dict[str, Any]:
+        """Handle the HTTP response"""
+        if response.status == 200:
+            return await response.json()
+        else:
+            error = await response.text()
+            return {
+                "error": f"API error ({response.status}): {error}",
+                "timestamp": datetime.now().isoformat()
+            }
+    
     async def _get_resource(self, resource_uri: str) -> Dict[str, Any]:
         """
         Get an MCP resource from the server
@@ -117,16 +133,74 @@ class TutorXClient:
     
     # ------------ Core Features ------------
     
+    async def get_concept_graph(self, concept_id: str = None, use_mcp: bool = False) -> Dict[str, Any]:
+        """
+        Get the concept graph for a specific concept or all concepts.
+        
+        Args:
+            concept_id: Optional ID of the concept to fetch. If None, returns all concepts.
+            use_mcp: If True, uses the MCP tool interface instead of direct API call.
+            
+        Returns:
+            Dict containing concept data or error information.
+        """
+        try:
+            # Ensure we have a session
+            await self._ensure_session()
+            
+            if use_mcp:
+                # Use MCP tool interface
+                print(f"[CLIENT] Using MCP tool to get concept graph for: {concept_id}")
+                return await self._call_tool("get_concept_graph", {"concept_id": concept_id} if concept_id else {})
+            
+            # Use direct API call (default)
+            url = f"{self.server_url}/api/concept_graph"
+            params = {}
+            if concept_id:
+                params["concept_id"] = concept_id
+            
+            print(f"[CLIENT] Fetching concept graph from {url} with params: {params}")
+            
+            async with self.session.get(
+                url,
+                params=params,
+                timeout=30
+            ) as response:
+                print(f"[CLIENT] Response status: {response.status}")
+                
+                if response.status == 404:
+                    error_msg = f"Concept {concept_id} not found"
+                    print(f"[CLIENT] {error_msg}")
+                    return {"error": error_msg}
+                    
+                response.raise_for_status()
+                
+                # Parse the JSON response
+                result = await response.json()
+                print(f"[CLIENT] Received response: {result}")
+                
+                return result
+                
+        except asyncio.TimeoutError:
+            error_msg = "Request timed out"
+            print(f"[CLIENT] {error_msg}")
+            return {"error": error_msg}
+            
+        except aiohttp.ClientError as e:
+            error_msg = f"HTTP client error: {str(e)}"
+            print(f"[CLIENT] {error_msg}")
+            return {"error": error_msg}
+            
+        except Exception as e:
+            error_msg = f"Unexpected error: {str(e)}"
+            print(f"[CLIENT] {error_msg}")
+            import traceback
+            traceback.print_exc()
+            return {"error": error_msg}
+        
     async def assess_skill(self, student_id: str, concept_id: str) -> Dict[str, Any]:
-        """Assess student's skill level on a specific concept"""
-        return await self._call_tool("assess_skill", {
-            "student_id": student_id,
-            "concept_id": concept_id
-        })
-    
-    async def get_concept_graph(self) -> Dict[str, Any]:
-        """Get the full knowledge concept graph"""
-        return await self._get_resource("concept-graph://")
+        """Assess a student's skill on a specific concept"""
+        return await self._call_tool("assess_skill", {"student_id": student_id, "concept_id": concept_id})
     
     async def get_learning_path(self, student_id: str) -> Dict[str, Any]:
         """Get personalized learning path for a student"""
@@ -247,11 +321,49 @@ class TutorXClient:
             "reference_sources": reference_sources
         })
     
+
+    async def get_curriculum_standards(self, country_code: str = "us") -> Dict[str, Any]:
+        """
+        Get curriculum standards for a specific country
+        
+        Args:
+            country_code: ISO country code (e.g., 'us', 'uk')
+            
+        Returns:
+            Dictionary containing curriculum standards
+        """
+        return await self._call_tool(
+            "curriculum-standards",  # Note the endpoint name matches the API route
+            {"country": country_code.lower()},  # Note the parameter name matches the API
+            method="GET"  # Use GET for this endpoint
+        )
+    
     async def close(self):
         """Close the aiohttp session"""
         if self.session:
             await self.session.close()
             self.session = None
 
+    async def generate_lesson(self, topic: str, grade_level: int, duration_minutes: int) -> Dict[str, Any]:
+        """
+        Generate a lesson plan for the given topic, grade level, and duration
+        
+        Args:
+            topic: The topic for the lesson
+            grade_level: The grade level (1-12)
+            duration_minutes: Duration of the lesson in minutes
+            
+        Returns:
+            Dictionary containing the generated lesson plan
+        """
+        return await self._call_tool(
+            "generate_lesson",
+            {
+                "topic": topic,
+                "grade_level": grade_level,
+                "duration_minutes": duration_minutes
+            }
+        )
+
 # Create a default client instance for easy import
 client = TutorXClient()

main.py

@@ -28,6 +28,9 @@ from utils.assessment import (
     generate_performance_analytics,
     detect_plagiarism
 )
+from typing import List, Dict, Any, Optional, Union
+import random
+from datetime import datetime, timedelta, timezone
 
 # Get server configuration from environment variables with defaults
 SERVER_HOST = os.getenv("MCP_HOST", "0.0.0.0")  # Allow connections from any IP
@@ -61,50 +64,171 @@ mcp = FastMCP(
 
 # ------------------ Core Features ------------------
 
-# Adaptive Learning Engine
+# Store the concept graph data in memory
+CONCEPT_GRAPH = {
+    "python": {
+        "id": "python",
+        "name": "Python Programming",
+        "description": "Fundamentals of Python programming language",
+        "prerequisites": [],
+        "related": ["functions", "oop", "data_structures"]
+    },
+    "functions": {
+        "id": "functions",
+        "name": "Python Functions",
+        "description": "Creating and using functions in Python",
+        "prerequisites": ["python"],
+        "related": ["decorators", "lambdas"]
+    },
+    "oop": {
+        "id": "oop",
+        "name": "Object-Oriented Programming",
+        "description": "Classes and objects in Python",
+        "prerequisites": ["python"],
+        "related": ["inheritance", "polymorphism"]
+    },
+    "data_structures": {
+        "id": "data_structures",
+        "name": "Data Structures",
+        "description": "Built-in data structures in Python",
+        "prerequisites": ["python"],
+        "related": ["algorithms"]
+    },
+    "decorators": {
+        "id": "decorators",
+        "name": "Python Decorators",
+        "description": "Function decorators in Python",
+        "prerequisites": ["functions"],
+        "related": ["python", "functions"]
+    },
+    "lambdas": {
+        "id": "lambdas",
+        "name": "Lambda Functions",
+        "description": "Anonymous functions in Python",
+        "prerequisites": ["functions"],
+        "related": ["python", "functions"]
+    },
+    "inheritance": {
+        "id": "inheritance",
+        "name": "Inheritance in OOP",
+        "description": "Creating class hierarchies in Python",
+        "prerequisites": ["oop"],
+        "related": ["python", "oop"]
+    },
+    "polymorphism": {
+        "id": "polymorphism",
+        "name": "Polymorphism in OOP",
+        "description": "Multiple forms of methods in Python",
+        "prerequisites": ["oop"],
+        "related": ["python", "oop"]
+    },
+    "algorithms": {
+        "id": "algorithms",
+        "name": "Basic Algorithms",
+        "description": "Common algorithms in Python",
+        "prerequisites": ["data_structures"],
+        "related": ["python", "data_structures"]
+    }
+}
+
+@api_app.get("/api/concept_graph")
+async def api_get_concept_graph(concept_id: str = None):
+    """API endpoint to get concept graph data for a specific concept or all concepts"""
+    if concept_id:
+        concept = CONCEPT_GRAPH.get(concept_id)
+        if not concept:
+            return JSONResponse(
+                status_code=404,
+                content={"error": f"Concept {concept_id} not found"}
+            )
+        return JSONResponse(content=concept)
+    return JSONResponse(content={"concepts": list(CONCEPT_GRAPH.values())})
+
+@mcp.tool()
+async def get_concept(concept_id: str = None) -> Dict[str, Any]:
+    """MCP tool to get a specific concept or all concepts"""
+    if concept_id:
+        concept = CONCEPT_GRAPH.get(concept_id)
+        if not concept:
+            return {"error": f"Concept {concept_id} not found"}
+        return {"concept": concept}
+    return {"concepts": list(CONCEPT_GRAPH.values())}
+
 @mcp.tool()
 async def assess_skill(student_id: str, concept_id: str) -> Dict[str, Any]:
-    """
-    Assess student's skill level on a specific concept
+    """Assess a student's understanding of a specific concept"""
+    # Check if concept exists in our concept graph
+    concept_data = await get_concept(concept_id)
+    if isinstance(concept_data, dict) and "error" in concept_data:
+        return {"error": f"Cannot assess skill: {concept_data['error']}"}
     
-    Args:
-        student_id: The unique identifier for the student
-        concept_id: The concept to assess
+    # Get concept name, handling both direct dict and concept graph response
+    if isinstance(concept_data, dict) and "concept" in concept_data:
+        concept_name = concept_data["concept"].get("name", concept_id)
+    elif isinstance(concept_data, dict) and "name" in concept_data:
+        concept_name = concept_data["name"]
+    else:
+        concept_name = concept_id
         
-    Returns:
-        Dictionary containing skill level and recommendations
-    """
-    try:
-        # Simulated skill assessment
-        return {
-            "student_id": student_id,
-            "concept_id": concept_id,
-            "skill_level": 0.75,
-            "confidence": 0.85,
-            "recommendations": [
-                "Practice more complex problems",
-                "Review related concept: algebra_linear_equations"
-            ],
-            "timestamp": datetime.now().isoformat()
-        }
-    except Exception as e:
-        return {
-            "error": str(e),
-            "timestamp": datetime.now().isoformat()
-        }
+    # Generate a score based on concept difficulty or random
+    score = random.uniform(0.2, 1.0)  # Random score between 0.2 and 1.0
+    
+    # Set timestamp with timezone
+    timestamp = datetime.now(timezone.utc).isoformat()
+    
+    # Generate feedback based on score
+    feedback = {
+        "strengths": [f"Good understanding of {concept_name} fundamentals"],
+        "areas_for_improvement": [f"Could work on advanced applications of {concept_name}"],
+        "recommendations": [
+            f"Review {concept_name} practice problems",
+            f"Watch tutorial videos on {concept_name}"
+        ]
+    }
+    
+    # Adjust feedback based on score
+    if score < 0.5:
+        feedback["strengths"] = [f"Basic understanding of {concept_name}"]
+        feedback["areas_for_improvement"].append("Needs to review fundamental concepts")
+    elif score > 0.8:
+        feedback["strengths"].append(f"Excellent grasp of {concept_name} concepts")
+        feedback["recommendations"].append("Try more advanced problems")
+    
+    # Create assessment response
+    assessment = {
+        "student_id": student_id,
+        "concept_id": concept_id,
+        "concept_name": concept_name,
+        "score": round(score, 2),  # Round to 2 decimal places
+        "timestamp": timestamp,
+        "feedback": feedback
+    }
+    return assessment
 
 @mcp.resource("concept-graph://")
-async def get_concept_graph() -> Dict[str, Any]:
+async def get_concept_graph_resource() -> Dict[str, Any]:
     """Get the full knowledge concept graph"""
     return {
         "nodes": [
-            {"id": "math_algebra_basics", "name": "Algebra Basics", "difficulty": 1},
-            {"id": "math_algebra_linear_equations", "name": "Linear Equations", "difficulty": 2},
-            {"id": "math_algebra_quadratic_equations", "name": "Quadratic Equations", "difficulty": 3},
+            {"id": "python", "name": "Python Basics", "difficulty": 1, "type": "foundation"},
+            {"id": "functions", "name": "Functions", "difficulty": 2, "type": "concept"},
+            {"id": "oop", "name": "OOP in Python", "difficulty": 3, "type": "paradigm"},
+            {"id": "data_structures", "name": "Data Structures", "difficulty": 2, "type": "concept"},
+            {"id": "decorators", "name": "Decorators", "difficulty": 4, "type": "advanced"},
+            {"id": "lambdas", "name": "Lambda Functions", "difficulty": 2, "type": "concept"},
+            {"id": "inheritance", "name": "Inheritance", "difficulty": 3, "type": "oop"},
+            {"id": "polymorphism", "name": "Polymorphism", "difficulty": 3, "type": "oop"},
+            {"id": "algorithms", "name": "Algorithms", "difficulty": 3, "type": "concept"}
         ],
         "edges": [
-            {"from": "math_algebra_basics", "to": "math_algebra_linear_equations", "weight": 1.0},
-            {"from": "math_algebra_linear_equations", "to": "math_algebra_quadratic_equations", "weight": 0.8},
+            {"from": "python", "to": "functions", "weight": 0.9},
+            {"from": "python", "to": "oop", "weight": 0.8},
+            {"from": "python", "to": "data_structures", "weight": 0.9},
+            {"from": "functions", "to": "decorators", "weight": 0.8},
+            {"from": "functions", "to": "lambdas", "weight": 0.7},
+            {"from": "oop", "to": "inheritance", "weight": 0.9},
+            {"from": "oop", "to": "polymorphism", "weight": 0.8},
+            {"from": "data_structures", "to": "algorithms", "weight": 0.9}
         ]
     }
 
@@ -113,10 +237,63 @@ async def get_learning_path(student_id: str) -> Dict[str, Any]:
     """Get personalized learning path for a student"""
     return {
         "student_id": student_id,
-        "current_concepts": ["math_algebra_linear_equations"],
-        "recommended_next": ["math_algebra_quadratic_equations"],
-        "mastered": ["math_algebra_basics"],
-        "estimated_completion_time": "2 weeks"
+        "current_concepts": ["math_algebra_linear_equations"]
+    }
+
+# Lesson Generation
+@mcp.tool()
+async def generate_lesson(topic: str, grade_level: int, duration_minutes: int) -> Dict[str, Any]:
+    """
+    Generate a lesson plan for the given topic, grade level, and duration
+    
+    Args:
+        topic: The topic for the lesson
+        grade_level: The grade level (1-12)
+        duration_minutes: Duration of the lesson in minutes
+        
+    Returns:
+        Dictionary containing the generated lesson plan
+    """
+    # In a real implementation, this would generate a lesson plan using an LLM
+    # For now, we'll return a mock lesson plan
+    return {
+        "lesson_id": f"lesson_{int(datetime.utcnow().timestamp())}",
+        "topic": topic,
+        "grade_level": grade_level,
+        "duration_minutes": duration_minutes,
+        "objectives": [
+            f"Understand the key concepts of {topic}",
+            f"Apply {topic} to solve problems",
+            f"Analyze examples of {topic} in real-world contexts"
+        ],
+        "materials": ["Whiteboard", "Markers", "Printed worksheets"],
+        "activities": [
+            {
+                "name": "Introduction",
+                "duration": 5,
+                "description": f"Brief introduction to {topic} and its importance"
+            },
+            {
+                "name": "Direct Instruction",
+                "duration": 15,
+                "description": f"Explain the main concepts of {topic} with examples"
+            },
+            {
+                "name": "Guided Practice",
+                "duration": 15,
+                "description": "Work through example problems together"
+            },
+            {
+                "name": "Independent Practice",
+                "duration": 10,
+                "description": "Students work on problems independently"
+            }
+        ],
+        "assessment": {
+            "type": "formative",
+            "description": "Exit ticket with 2-3 problems related to the lesson"
+        },
+        "timestamp": datetime.utcnow().isoformat()
     }
 
 # Assessment Suite
@@ -132,46 +309,269 @@ async def generate_quiz(concept_ids: List[str], difficulty: int = 2) -> Dict[str
     Returns:
         Quiz object with questions and answers
     """
+    # In a real implementation, this would generate questions based on the concepts
+    # For now, we'll return a mock quiz
+    questions = []
+    for i, concept_id in enumerate(concept_ids[:5]):  # Limit to 5 questions max
+        concept = CONCEPT_GRAPH.get(concept_id, {"name": f"Concept {concept_id}"})
+        questions.append({
+            "id": f"q{i+1}",
+            "concept_id": concept_id,
+            "concept_name": concept.get("name", f"Concept {concept_id}"),
+            "question": f"Sample question about {concept.get('name', concept_id)}?",
+            "options": ["Option 1", "Option 2", "Option 3", "Option 4"],
+            "correct_answer": random.randint(0, 3),  # Random correct answer index
+            "difficulty": min(max(1, difficulty), 5),  # Clamp difficulty between 1-5
+            "explanation": f"This is an explanation for the question about {concept.get('name', concept_id)}"
+        })
+    
     return {
-        "quiz_id": "q12345",
+        "quiz_id": f"quiz_{int(datetime.utcnow().timestamp())}",
         "concept_ids": concept_ids,
         "difficulty": difficulty,
-        "questions": [
-            {
-                "id": "q1",
-                "text": "Solve for x: 2x + 3 = 7",
-                "type": "algebraic_equation",
-                "answer": "x = 2",
-                "solution_steps": [
-                    "2x + 3 = 7",
-                    "2x = 7 - 3",
-                    "2x = 4",
-                    "x = 4/2 = 2"
-                ]
-            }
-        ]
+        "questions": questions,
+        "timestamp": datetime.utcnow().isoformat()
     }
 
+
+
 # API Endpoints
 @api_app.get("/api/health")
 async def health_check():
     return {"status": "ok", "timestamp": datetime.now().isoformat()}
 
 @api_app.get("/api/assess_skill")
-async def assess_skill_api(student_id: str = Query(...), concept_id: str = Query(...)):
+async def assess_skill_api(
+    request: Request,
+    student_id: Optional[str] = Query(None, description="Student ID"),
+    concept_id: Optional[str] = Query(None, description="Concept ID to assess")
+):
+    """
+    Assess a student's understanding of a specific concept
+    
+    Args:
+        student_id: Student's unique identifier
+        concept_id: Concept ID to assess
+        
+    Returns:
+        Assessment results with score and feedback
+    """
     try:
+        # Get query parameters
+        params = dict(request.query_params)
+        
+        # Check for required parameters
+        if not student_id or not concept_id:
+            raise HTTPException(
+                status_code=400,
+                detail="Both student_id and concept_id are required parameters"
+            )
+        
+        # Call the assess_skill function
         result = await assess_skill(student_id, concept_id)
+        
+        # Handle error responses
+        if isinstance(result, dict) and "error" in result:
+            raise HTTPException(status_code=404, detail=result["error"])
+            
         return result
+        
+    except HTTPException as http_err:
+        # Re-raise HTTP exceptions as is
+        raise http_err
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        # Log the error for debugging
+        print(f"Error in assess_skill_api: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        
+        # Return a user-friendly error message
+        raise HTTPException(
+            status_code=500,
+            detail=f"An error occurred while processing your request: {str(e)}"
+        )
+
+@api_app.post("/api/generate_lesson")
+async def generate_lesson_api(request: Dict[str, Any]):
+    """
+    Generate a lesson plan based on the provided parameters
+    
+    Expected request format:
+    {
+        "topic": "Lesson Topic",
+        "grade_level": 9,  # 1-12
+        "duration_minutes": 45
+    }
+    """
+    try:
+        # Validate request
+        if not isinstance(request, dict):
+            raise HTTPException(
+                status_code=400,
+                detail="Request must be a JSON object"
+            )
+            
+        # Get parameters with validation
+        topic = request.get("topic")
+        if not topic or not isinstance(topic, str):
+            raise HTTPException(
+                status_code=400,
+                detail="Topic is required and must be a string"
+            )
+            
+        grade_level = request.get("grade_level")
+        if not isinstance(grade_level, int) or not (1 <= grade_level <= 12):
+            raise HTTPException(
+                status_code=400,
+                detail="Grade level must be an integer between 1 and 12"
+            )
+            
+        duration_minutes = request.get("duration_minutes")
+        if not isinstance(duration_minutes, (int, float)) or duration_minutes <= 0:
+            raise HTTPException(
+                status_code=400,
+                detail="Duration must be a positive number"
+            )
+        
+        # Generate the lesson plan
+        result = await generate_lesson(topic, grade_level, int(duration_minutes))
+        return result
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to generate lesson: {str(e)}")
 
 @api_app.post("/api/generate_quiz")
-async def generate_quiz_api(concept_ids: List[str], difficulty: int = 2):
+async def generate_quiz_api(request: Dict[str, Any]):
+    """
+    Generate a quiz based on specified concepts and difficulty
+    
+    Expected request format:
+    {
+        "concept_ids": ["concept1", "concept2", ...],
+        "difficulty": 2  # Optional, default is 2
+    }
+    """
     try:
+        # Validate request
+        if not isinstance(request, dict) or "concept_ids" not in request:
+            raise HTTPException(
+                status_code=400,
+                detail="Request must be a JSON object with 'concept_ids' key"
+            )
+        
+        # Get parameters with defaults
+        concept_ids = request.get("concept_ids", [])
+        difficulty = request.get("difficulty", 2)
+        
+        # Validate types
+        if not isinstance(concept_ids, list):
+            concept_ids = [concept_ids]  # Convert single concept to list
+            
+        if not all(isinstance(cid, str) for cid in concept_ids):
+            raise HTTPException(
+                status_code=400,
+                detail="All concept IDs must be strings"
+            )
+            
+        difficulty = int(difficulty)  # Ensure difficulty is an integer
+        
+        # Generate the quiz
         result = await generate_quiz(concept_ids, difficulty)
         return result
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Failed to generate quiz: {str(e)}")
+
+@mcp.tool()
+async def get_curriculum_standards(country_code: str = "us") -> Dict[str, Any]:
+    """
+    Get curriculum standards for a specific country
+    
+    Args:
+        country_code: ISO country code (e.g., 'us', 'uk')
+        
+    Returns:
+        Dictionary containing curriculum standards
+    """
+    # Mock data - in a real implementation, this would come from a database or external API
+    standards = {
+        "us": {
+            "name": "Common Core State Standards (US)",
+            "subjects": {
+                "math": {
+                    "description": "Mathematics standards focusing on conceptual understanding, procedural skills, and problem solving",
+                    "domains": ["Number & Operations", "Algebra", "Geometry", "Statistics & Probability"]
+                },
+                "ela": {
+                    "description": "English Language Arts standards for reading, writing, speaking, and listening",
+                    "domains": ["Reading", "Writing", "Speaking & Listening", "Language"]
+                }
+            },
+            "grade_levels": list(range(1, 13)),
+            "website": "http://www.corestandards.org"
+        },
+        "uk": {
+            "name": "National Curriculum (UK)",
+            "subjects": {
+                "maths": {
+                    "description": "Mathematics programme of study for key stages 1-4",
+                    "domains": ["Number", "Algebra", "Ratio & Proportion", "Geometry", "Statistics"]
+                },
+                "english": {
+                    "description": "English programme of study for key stages 1-4",
+                    "domains": ["Reading", "Writing", "Grammar & Vocabulary", "Spoken English"]
+                }
+            },
+            "key_stages": ["KS1 (5-7)", "KS2 (7-11)", "KS3 (11-14)", "KS4 (14-16)"],
+            "website": "https://www.gov.uk/government/collections/national-curriculum"
+        }
+    }
+    
+    # Default to US standards if country not found
+    country_code = country_code.lower()
+    if country_code not in standards:
+        country_code = "us"
+    
+    return {
+        "country_code": country_code,
+        "standards": standards[country_code],
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+@api_app.get("/api/curriculum-standards")
+async def get_curriculum_standards_api(country: str = "us"):
+    """
+    Get curriculum standards for a specific country
+    
+    Args:
+        country: ISO country code (e.g., 'us', 'uk')
+        
+    Returns:
+        Dictionary containing curriculum standards
+    """
+    try:
+        # Validate country code
+        if not isinstance(country, str) or len(country) != 2:
+            raise HTTPException(
+                status_code=400,
+                detail="Country code must be a 2-letter ISO code"
+            )
+            
+        # Get the standards
+        result = await get_curriculum_standards(country)
+        return result
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to fetch curriculum standards: {str(e)}"
+        )
 
 # Mount MCP app to /mcp path
 mcp.app = api_app

requirements.txt

@@ -16,4 +16,6 @@ pytest-cov>=3.0.0
 black>=22.0.0
 isort>=5.10.0
 mypy>=0.910
-ruff>=0.0.262 
+ruff>=0.0.262
+networkx>=3.0
+matplotlib>=3.5.0

run.py

@@ -16,7 +16,7 @@ def load_module(name, path):
     spec.loader.exec_module(module)
     return module
 
-def run_mcp_server(host="127.0.0.1", port=8000, transport="streamable-http"):
+def run_mcp_server(host="0.0.0.0", port=8001, transport="http"):
     """Run the MCP server with specified configuration"""
     print(f"Starting TutorX MCP Server on {host}:{port} using {transport} transport...")
     
@@ -25,6 +25,7 @@ def run_mcp_server(host="127.0.0.1", port=8000, transport="streamable-http"):
     os.environ["MCP_PORT"] = str(port)
     os.environ["MCP_TRANSPORT"] = transport
     
+    # Import and run the main module
     main_module = load_module("main", "main.py")
     
     # Access the mcp instance and run it
@@ -41,7 +42,7 @@ def run_gradio_interface():
     
     # Run the Gradio demo
     if hasattr(app_module, "demo"):
-        app_module.demo.launch()
+        app_module.demo.launch(server_name="0.0.0.0", server_port=7860)
     else:
         print("Error: Gradio demo not found in app.py")
         sys.exit(1)
@@ -62,25 +63,30 @@ if __name__ == "__main__":
     parser.add_argument(
         "--mode", 
         choices=["mcp", "gradio", "both"], 
-        default="mcp",
+        default="both",
         help="Run mode: 'mcp' for MCP server, 'gradio' for Gradio interface, 'both' for both"
     )
     parser.add_argument(
         "--host", 
-        default="127.0.0.1",
+        default="0.0.0.0",
         help="Host address to use"
     )
     parser.add_argument(
         "--port", 
         type=int,
-        default=8000,
-        help="Port to use"
+        default=8001,
+        help="Port to use for MCP server (default: 8001)"
+    )
+    parser.add_argument(
+        "--gradio-port", 
+        type=int,
+        default=7860,
+        help="Port to use for Gradio interface (default: 7860)"
     )
     parser.add_argument(
         "--transport",
-        choices=["stdio", "streamable-http", "sse"],
-        default="streamable-http",
-        help="Transport protocol to use"
+        default="http",
+        help="Transport protocol to use (default: http)"
     )
     
     args = parser.parse_args()