Refactor TutorX MCP server to remove legacy client and utility modules, update app.py for SSE integration, and enhance .gitignore to exclude .cursor directory. Clean up main.py for improved server configuration and streamline run script for better usability.

.gitignore

@@ -5,6 +5,7 @@ build/
 dist/
 wheels/
 *.egg-info
+.cursor/
 
 # Virtual environments
 .venv

app.py

@@ -13,11 +13,12 @@ import aiohttp
 import sseclient
 import requests
 
-# Import MCP client to communicate with the MCP server
-from client import client
+# Import MCP SSE client context managers
+from mcp import ClientSession
+from mcp.client.sse import sse_client
 
 # Server configuration
-SERVER_URL = "http://localhost:8001"  # Default port is now 8001 to match main.py
+SERVER_URL = "http://localhost:8000/sse"  # Ensure this is the SSE endpoint
 
 # Utility functions
 
@@ -26,146 +27,89 @@ 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.
+    Uses call_resource for concept graph retrieval (not a tool).
     
     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
-        
+        async with sse_client(SERVER_URL) as (sse, write):
+            async with ClientSession(sse, write) as session:
+                await session.initialize()
+                # Use MCP resource call for concept graph
+                result = await session.call_resource("resources/read", {"uri": f"concept-graph://{concept_id}" if concept_id else "concept-graph://"})
+                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"]}, []
+                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.get("concept", result)
+                    print(f"[DEBUG] Using direct concept: {concept.get('id')}")
+                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}, []
+                import matplotlib.pyplot as plt
+                import networkx as nx
+                G = nx.DiGraph()
+                G.add_node(concept["id"], label=concept["name"], type="concept")
+                related_concepts = []
+                if "related" in concept:
+                    for rel_id in concept["related"]:
+                        rel_result = await session.call_tool("get_concept_graph", {"concept_id": 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", "")])
+                if "prerequisites" in concept:
+                    for prereq_id in concept["prerequisites"]:
+                        prereq_result = await session.call_tool("get_concept_graph", {"concept_id": 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")
+                plt.figure(figsize=(10, 8))
+                pos = nx.spring_layout(G)
+                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)
+                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")
+                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")
+                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}"
-    headers = {"Content-Type": "application/json"}
-    
-    try:
-        async with aiohttp.ClientSession() as session:
-            if method.upper() == "GET":
-                async with session.get(url, params=params, headers=headers) as response:
-                    if response.status == 200:
-                        return await response.json()
-                    else:
-                        error = await response.text()
-                        return {"error": f"API error: {response.status} - {error}"}
-            elif method.upper() == "POST":
-                async with session.post(url, json=json_data, headers=headers) as response:
-                    if response.status == 200:
-                        return await response.json()
-                    else:
-                        error = await response.text()
-                        return {"error": f"API error: {response.status} - {error}"}
-    except Exception as e:
-        return {"error": f"Request failed: {str(e)}"}
-
+        
 # Create Gradio interface
 with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 📚 TutorX Educational AI Platform")
@@ -224,34 +168,57 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
             gr.Markdown("## Assessment Generation")
             with gr.Row():
                 with gr.Column():
-                    concepts_input = gr.CheckboxGroup(
-                        choices=["math_algebra_basics", "math_algebra_linear_equations", "math_algebra_quadratic_equations"],
-                        label="Select Concepts",
-                        value=["math_algebra_linear_equations"]
+                    concept_input = gr.Textbox(
+                        label="Enter Concept",
+                        placeholder="e.g., Linear Equations, Photosynthesis, World War II",
+                        lines=2
                     )
-                    diff_input = gr.Slider(minimum=1, maximum=5, value=2, step=1, label="Difficulty")
-                    gen_quiz_btn = gr.Button("Generate Quiz")
+                    with gr.Row():
+                        diff_input = gr.Slider(
+                            minimum=1, 
+                            maximum=5, 
+                            value=2, 
+                            step=1, 
+                            label="Difficulty Level",
+                            interactive=True
+                        )
+                        gen_quiz_btn = gr.Button("Generate Quiz", variant="primary")
                 
                 with gr.Column():
                     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=request_data
-                )
-                return result
+            async def on_generate_quiz(concept, difficulty):
+                try:
+                    if not concept or not str(concept).strip():
+                        return {"error": "Please enter a concept"}
+                    try:
+                        difficulty = int(float(difficulty))
+                        difficulty = max(1, min(5, difficulty))
+                    except (ValueError, TypeError):
+                        difficulty = 3
+                    # Map numeric difficulty to string
+                    if difficulty <= 2:
+                        difficulty_str = "easy"
+                    elif difficulty == 3:
+                        difficulty_str = "medium"
+                    else:
+                        difficulty_str = "hard"
+                    async with sse_client(SERVER_URL) as (sse, write):
+                        async with ClientSession(sse, write) as session:
+                            await session.initialize()
+                            response = await session.call_tool("generate_quiz_tool", {"concept": concept.strip(), "difficulty": difficulty_str})
+                            return response
+                except Exception as e:
+                    import traceback
+                    return {
+                        "error": f"Error generating quiz: {str(e)}\n\n{traceback.format_exc()}"
+                    }
                 
             gen_quiz_btn.click(
                 fn=on_generate_quiz,
-                inputs=[concepts_input, diff_input],
-                outputs=[quiz_output]
+                inputs=[concept_input, diff_input],
+                outputs=[quiz_output],
+                api_name="generate_quiz"
             )
         
         # Tab 2: Advanced Features
@@ -268,7 +235,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)
+                async with sse_client(SERVER_URL) as (sse, write):
+                    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})
+                        return response
                 
             gen_lesson_btn.click(
                 fn=generate_lesson_async,
@@ -294,31 +265,34 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 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"]
+                    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_curriculum_standards", {"country_code": country_code})
                             
-                        return formatted
-                    return response
+                            # 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)}"}
                 
@@ -340,7 +314,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")
+                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 response
                 
             text_btn.click(
                 fn=text_interaction_async,
@@ -370,7 +348,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     if not file_path or not os.path.exists(file_path):
                         return {"error": "File not found", "success": False}
                         
-                    return await client.pdf_ocr(file_path)
+                    async with sse_client(SERVER_URL) as (sse, write):
+                        async with ClientSession(sse, write) as session:
+                            await session.initialize()
+                            response = await session.call_tool("pdf_ocr", {"pdf_file": file_path})
+                            return response
                 except Exception as e:
                     return {"error": f"Error processing PDF: {str(e)}", "success": False}
                 
@@ -402,7 +384,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     plagiarism_output = gr.JSON(label="Originality Report")
             
             async def check_plagiarism_async(submission, reference):
-                return await client.check_submission_originality(submission, [reference])
+                async with sse_client(SERVER_URL) as (sse, write):
+                    async with ClientSession(sse, write) as session:
+                        await session.initialize()
+                        response = await session.call_tool("check_submission_originality", {"submission": submission, "reference_sources": reference})
+                        return response
                 
             plagiarism_btn.click(
                 fn=check_plagiarism_async,

client.py

@@ -1,390 +0,0 @@
-"""
-MCP client for interacting with the TutorX MCP server.
-This module provides functions that interact with the MCP server
-for use by the Gradio interface.
-"""
-
-import json
-import aiohttp
-import asyncio
-from typing import Dict, Any, List, Optional
-import base64
-from datetime import datetime
-import os
-
-# Get server configuration from environment variables with defaults
-DEFAULT_HOST = os.getenv("MCP_HOST", "127.0.0.1")
-DEFAULT_PORT = int(os.getenv("MCP_PORT", "8001"))  # Default port updated to 8001
-DEFAULT_SERVER_URL = f"http://{DEFAULT_HOST}:{DEFAULT_PORT}"
-
-# API endpoints
-API_PREFIX = "/api"
-
-class TutorXClient:
-    """Client for interacting with the TutorX MCP server"""
-    
-    def __init__(self, server_url=DEFAULT_SERVER_URL):
-        self.server_url = server_url
-        self.session = None
-    
-    async def _ensure_session(self):
-        """Ensure aiohttp session exists"""
-        if self.session is None:
-            self.session = aiohttp.ClientSession(
-                headers={
-                    "Content-Type": "application/json",
-                    "Accept": "application/json"
-                }
-            )
-    
-    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
-        """
-        await self._ensure_session()
-        try:
-            url = f"{self.server_url}{API_PREFIX}/{tool_name}"
-            
-            # 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
-        
-        Args:
-            resource_uri: URI of the resource to get
-            
-        Returns:
-            Resource data
-        """
-        await self._ensure_session()
-        try:
-            # Extract the resource name from the URI (e.g., 'concept-graph' from 'concept-graph://')
-            resource_name = resource_uri.split('://')[0]
-            url = f"{self.server_url}{API_PREFIX}/{resource_name}"
-            
-            async with self.session.get(url, timeout=30) as response:
-                if response.status == 200:
-                    return await response.json()
-                else:
-                    error = await response.text()
-                    return {
-                        "error": f"Failed to get resource: {error}",
-                        "timestamp": datetime.now().isoformat()
-                    }
-        except Exception as e:
-            return {
-                "error": f"Failed to get resource: {str(e)}",
-                "timestamp": datetime.now().isoformat()
-            }
-    
-    async def check_server_connection(self) -> bool:
-        """
-        Check if the server is accessible
-        
-        Returns:
-            bool: True if server is accessible, False otherwise
-        """
-        await self._ensure_session()
-        try:
-            async with self.session.get(
-                f"{self.server_url}{API_PREFIX}/health",
-                timeout=5
-            ) as response:
-                return response.status == 200
-        except Exception as e:
-            print(f"Server connection check failed: {str(e)}")
-            return False
-    
-    # ------------ 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 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"""
-        return await self._get_resource(f"learning-path://{student_id}")
-    
-    async def generate_quiz(self, concept_ids: List[str], difficulty: int = 2) -> Dict[str, Any]:
-        """Generate a quiz based on specified concepts and difficulty"""
-        return await self._call_tool("generate_quiz", {
-            "concept_ids": concept_ids,
-            "difficulty": difficulty
-        })
-    
-
-    
-    # ------------ Advanced Features ------------
-    
-    async def analyze_cognitive_state(self, eeg_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Analyze EEG data to determine cognitive state"""
-        return await self._call_tool("analyze_cognitive_state", {
-            "eeg_data": eeg_data
-        })
-    
-    async def get_curriculum_standards(self, country_code: str) -> Dict[str, Any]:
-        """Get curriculum standards for a specific country"""
-        return await self._get_resource(f"curriculum-standards://{country_code}")
-    
-    async def align_content_to_standard(self, content_id: str, standard_id: str) -> Dict[str, Any]:
-        """Align educational content to a specific curriculum standard"""
-        return await self._call_tool("align_content_to_standard", {
-            "content_id": content_id,
-            "standard_id": standard_id
-        })
-    
-    async def generate_lesson(self, topic: str, grade_level: int, duration_minutes: int = 45) -> Dict[str, Any]:
-        """Generate a complete lesson plan on a topic"""
-        return await self._call_tool("generate_lesson", {
-            "topic": topic,
-            "grade_level": grade_level,
-            "duration_minutes": duration_minutes
-        })
-    
-    # ------------ User Experience ------------
-    
-    async def get_student_dashboard(self, student_id: str) -> Dict[str, Any]:
-        """Get dashboard data for a specific student"""
-        return await self._get_resource(f"student-dashboard://{student_id}")
-    
-    async def get_accessibility_settings(self, student_id: str) -> Dict[str, Any]:
-        """Get accessibility settings for a student"""
-        return await self._call_tool("get_accessibility_settings", {
-            "student_id": student_id
-        })
-    
-    async def update_accessibility_settings(self, student_id: str, settings: Dict[str, Any]) -> Dict[str, Any]:
-        """Update accessibility settings for a student"""
-        return await self._call_tool("update_accessibility_settings", {
-            "student_id": student_id,
-            "settings": settings
-        })
-    
-    # ------------ Multi-Modal Interaction ------------
-    
-    async def text_interaction(self, query: str, student_id: str) -> Dict[str, Any]:
-        """Process a text query from the student"""
-        return await self._call_tool("text_interaction", {
-            "query": query,
-            "student_id": student_id
-        })
-    
-    async def voice_interaction(self, audio_data_base64: str, student_id: str) -> Dict[str, Any]:
-        """Process voice input from the student"""
-        return await self._call_tool("voice_interaction", {
-            "audio_data_base64": audio_data_base64,
-            "student_id": student_id
-        })
-    
-
-    
-    # ------------ Assessment ------------
-    
-    async def create_assessment(self, concept_ids: List[str], num_questions: int, difficulty: int = 3) -> Dict[str, Any]:
-        """Create a complete assessment for given concepts"""
-        return await self._call_tool("create_assessment", {
-            "concept_ids": concept_ids,
-            "num_questions": num_questions,
-            "difficulty": difficulty
-        })
-    
-    async def grade_assessment(self, assessment_id: str, student_answers: Dict[str, str], questions: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Grade a completed assessment"""
-        return await self._call_tool("grade_assessment", {
-            "assessment_id": assessment_id,
-            "student_answers": student_answers,
-            "questions": questions
-        })
-    
-    async def get_student_analytics(self, student_id: str, timeframe_days: int = 30) -> Dict[str, Any]:
-        """Get comprehensive analytics for a student"""
-        return await self._call_tool("get_student_analytics", {
-            "student_id": student_id,
-            "timeframe_days": timeframe_days
-        })
-    
-    async def check_submission_originality(self, submission: str, reference_sources: List[str]) -> Dict[str, Any]:
-        """Check student submission for potential plagiarism"""
-        return await self._call_tool("check_submission_originality", {
-            "submission": submission,
-            "reference_sources": reference_sources
-        })
-        
-    async def pdf_ocr(self, pdf_file: str) -> Dict[str, Any]:
-        """
-        Extract text from a PDF file using OCR
-        
-        Args:
-            pdf_file: Path to the PDF file
-            
-        Returns:
-            Dictionary containing extracted text and metadata
-        """
-        try:
-            # Read the PDF file as binary data
-            with open(pdf_file, "rb") as f:
-                pdf_data = f.read()
-            
-            # Convert to base64 for transmission
-            pdf_base64 = base64.b64encode(pdf_data).decode('utf-8')
-            
-            # Call the server's PDF OCR endpoint
-            return await self._call_tool("pdf_ocr", {
-                "pdf_data": pdf_base64,
-                "filename": os.path.basename(pdf_file)
-            })
-            
-        except Exception as e:
-            return {
-                "error": f"Failed to process PDF: {str(e)}",
-                "success": False,
-                "timestamp": datetime.now().isoformat()
-            }
-    
-
-    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()

docs/sdk.md

@@ -16,33 +16,36 @@
 <!-- omit in toc -->
 ## Table of Contents
 
-- [Overview](#overview)
-- [Installation](#installation)
-- [Quickstart](#quickstart)
-- [What is MCP?](#what-is-mcp)
-- [Core Concepts](#core-concepts)
-  - [Server](#server)
-  - [Resources](#resources)
-  - [Tools](#tools)
-  - [Prompts](#prompts)
-  - [Images](#images)
-  - [Context](#context)
-- [Running Your Server](#running-your-server)
-  - [Development Mode](#development-mode)
-  - [Claude Desktop Integration](#claude-desktop-integration)
-  - [Direct Execution](#direct-execution)
-  - [Mounting to an Existing ASGI Server](#mounting-to-an-existing-asgi-server)
-- [Examples](#examples)
-  - [Echo Server](#echo-server)
-  - [SQLite Explorer](#sqlite-explorer)
-- [Advanced Usage](#advanced-usage)
-  - [Low-Level Server](#low-level-server)
-  - [Writing MCP Clients](#writing-mcp-clients)
-  - [MCP Primitives](#mcp-primitives)
-  - [Server Capabilities](#server-capabilities)
-- [Documentation](#documentation)
-- [Contributing](#contributing)
-- [License](#license)
+- [MCP Python SDK](#mcp-python-sdk)
+  - [Overview](#overview)
+  - [Installation](#installation)
+    - [Adding MCP to your python project](#adding-mcp-to-your-python-project)
+    - [Running the standalone MCP development tools](#running-the-standalone-mcp-development-tools)
+  - [Quickstart](#quickstart)
+  - [What is MCP?](#what-is-mcp)
+  - [Core Concepts](#core-concepts)
+    - [Server](#server)
+    - [Resources](#resources)
+    - [Tools](#tools)
+    - [Prompts](#prompts)
+    - [Images](#images)
+    - [Context](#context)
+  - [Running Your Server](#running-your-server)
+    - [Development Mode](#development-mode)
+    - [Claude Desktop Integration](#claude-desktop-integration)
+    - [Direct Execution](#direct-execution)
+    - [Mounting to an Existing ASGI Server](#mounting-to-an-existing-asgi-server)
+  - [Examples](#examples)
+    - [Echo Server](#echo-server)
+    - [SQLite Explorer](#sqlite-explorer)
+  - [Advanced Usage](#advanced-usage)
+    - [Low-Level Server](#low-level-server)
+    - [Writing MCP Clients](#writing-mcp-clients)
+    - [MCP Primitives](#mcp-primitives)
+    - [Server Capabilities](#server-capabilities)
+  - [Documentation](#documentation)
+  - [Contributing](#contributing)
+  - [License](#license)
 
 [pypi-badge]: https://img.shields.io/pypi/v/mcp.svg
 [pypi-url]: https://pypi.org/project/mcp/
@@ -63,22 +66,31 @@ The Model Context Protocol allows applications to provide context for LLMs in a
 
 - Build MCP clients that can connect to any MCP server
 - Create MCP servers that expose resources, prompts and tools
-- Use standard transports like stdio and SSE
+- Use standard transports like stdio, SSE, and Streamable HTTP
 - Handle all MCP protocol messages and lifecycle events
 
 ## Installation
 
 ### Adding MCP to your python project
 
-We recommend using [uv](https://docs.astral.sh/uv/) to manage your Python projects. In a uv managed python project, add mcp to dependencies by:
+We recommend using [uv](https://docs.astral.sh/uv/) to manage your Python projects. 
 
-```bash
-uv add "mcp[cli]"
-```
+If you haven't created a uv-managed project yet, create one:
+
+   ```bash
+   uv init mcp-server-demo
+   cd mcp-server-demo
+   ```
+
+   Then add MCP to your project dependencies:
+
+   ```bash
+   uv add "mcp[cli]"
+   ```
 
 Alternatively, for projects using pip for dependencies:
 ```bash
-pip install mcp
+pip install "mcp[cli]"
 ```
 
 ### Running the standalone MCP development tools
@@ -143,12 +155,12 @@ The FastMCP server is your core interface to the MCP protocol. It handles connec
 ```python
 # Add lifespan support for startup/shutdown with strong typing
 from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator
 
 from fake_database import Database  # Replace with your actual DB type
 
-from mcp.server.fastmcp import Context, FastMCP
+from mcp.server.fastmcp import FastMCP
 
 # Create a named server
 mcp = FastMCP("My App")
@@ -180,8 +192,9 @@ mcp = FastMCP("My App", lifespan=app_lifespan)
 
 # Access type-safe lifespan context in tools
 @mcp.tool()
-def query_db(ctx: Context) -> str:
+def query_db() -> str:
     """Tool that uses initialized resources"""
+    ctx = mcp.get_context()
     db = ctx.request_context.lifespan_context["db"]
     return db.query()
 ```
@@ -297,6 +310,48 @@ async def long_task(files: list[str], ctx: Context) -> str:
     return "Processing complete"
 ```
 
+### Authentication
+
+Authentication can be used by servers that want to expose tools accessing protected resources.
+
+`mcp.server.auth` implements an OAuth 2.0 server interface, which servers can use by
+providing an implementation of the `OAuthAuthorizationServerProvider` protocol.
+
+```python
+from mcp import FastMCP
+from mcp.server.auth.provider import OAuthAuthorizationServerProvider
+from mcp.server.auth.settings import (
+    AuthSettings,
+    ClientRegistrationOptions,
+    RevocationOptions,
+)
+
+
+class MyOAuthServerProvider(OAuthAuthorizationServerProvider):
+    # See an example on how to implement at `examples/servers/simple-auth`
+    ...
+
+
+mcp = FastMCP(
+    "My App",
+    auth_server_provider=MyOAuthServerProvider(),
+    auth=AuthSettings(
+        issuer_url="https://myapp.com",
+        revocation_options=RevocationOptions(
+            enabled=True,
+        ),
+        client_registration_options=ClientRegistrationOptions(
+            enabled=True,
+            valid_scopes=["myscope", "myotherscope"],
+            default_scopes=["myscope"],
+        ),
+        required_scopes=["myscope"],
+    ),
+)
+```
+
+See [OAuthAuthorizationServerProvider](src/mcp/server/auth/provider.py) for more details.
+
 ## Running Your Server
 
 ### Development Mode
@@ -348,13 +403,97 @@ python server.py
 mcp run server.py
 ```
 
+Note that `mcp run` or `mcp dev` only supports server using FastMCP and not the low-level server variant.
+
+### Streamable HTTP Transport
+
+> **Note**: Streamable HTTP transport is superseding SSE transport for production deployments.
+
+```python
+from mcp.server.fastmcp import FastMCP
+
+# Stateful server (maintains session state)
+mcp = FastMCP("StatefulServer")
+
+# Stateless server (no session persistence)
+mcp = FastMCP("StatelessServer", stateless_http=True)
+
+# Stateless server (no session persistence, no sse stream with supported client)
+mcp = FastMCP("StatelessServer", stateless_http=True, json_response=True)
+
+# Run server with streamable_http transport
+mcp.run(transport="streamable-http")
+```
+
+You can mount multiple FastMCP servers in a FastAPI application:
+
+```python
+# echo.py
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(name="EchoServer", stateless_http=True)
+
+
+@mcp.tool(description="A simple echo tool")
+def echo(message: str) -> str:
+    return f"Echo: {message}"
+```
+
+```python
+# math.py
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(name="MathServer", stateless_http=True)
+
+
+@mcp.tool(description="A simple add tool")
+def add_two(n: int) -> int:
+    return n + 2
+```
+
+```python
+# main.py
+import contextlib
+from fastapi import FastAPI
+from mcp.echo import echo
+from mcp.math import math
+
+
+# Create a combined lifespan to manage both session managers
+@contextlib.asynccontextmanager
+async def lifespan(app: FastAPI):
+    async with contextlib.AsyncExitStack() as stack:
+        await stack.enter_async_context(echo.mcp.session_manager.run())
+        await stack.enter_async_context(math.mcp.session_manager.run())
+        yield
+
+
+app = FastAPI(lifespan=lifespan)
+app.mount("/echo", echo.mcp.streamable_http_app())
+app.mount("/math", math.mcp.streamable_http_app())
+```
+
+For low level server with Streamable HTTP implementations, see:
+- Stateful server: [`examples/servers/simple-streamablehttp/`](examples/servers/simple-streamablehttp/)
+- Stateless server: [`examples/servers/simple-streamablehttp-stateless/`](examples/servers/simple-streamablehttp-stateless/)
+
+The streamable HTTP transport supports:
+- Stateful and stateless operation modes
+- Resumability with event stores
+- JSON or SSE response formats
+- Better scalability for multi-node deployments
+
 ### Mounting to an Existing ASGI Server
 
+> **Note**: SSE transport is being superseded by [Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http).
+
+By default, SSE servers are mounted at `/sse` and Streamable HTTP servers are mounted at `/mcp`. You can customize these paths using the methods described below.
+
 You can mount the SSE server to an existing ASGI server using the `sse_app` method. This allows you to integrate the SSE server with other ASGI applications.
 
 ```python
 from starlette.applications import Starlette
-from starlette.routes import Mount, Host
+from starlette.routing import Mount, Host
 from mcp.server.fastmcp import FastMCP
 
 
@@ -371,6 +510,43 @@ app = Starlette(
 app.router.routes.append(Host('mcp.acme.corp', app=mcp.sse_app()))
 ```
 
+When mounting multiple MCP servers under different paths, you can configure the mount path in several ways:
+
+```python
+from starlette.applications import Starlette
+from starlette.routing import Mount
+from mcp.server.fastmcp import FastMCP
+
+# Create multiple MCP servers
+github_mcp = FastMCP("GitHub API")
+browser_mcp = FastMCP("Browser")
+curl_mcp = FastMCP("Curl")
+search_mcp = FastMCP("Search")
+
+# Method 1: Configure mount paths via settings (recommended for persistent configuration)
+github_mcp.settings.mount_path = "/github"
+browser_mcp.settings.mount_path = "/browser"
+
+# Method 2: Pass mount path directly to sse_app (preferred for ad-hoc mounting)
+# This approach doesn't modify the server's settings permanently
+
+# Create Starlette app with multiple mounted servers
+app = Starlette(
+    routes=[
+        # Using settings-based configuration
+        Mount("/github", app=github_mcp.sse_app()),
+        Mount("/browser", app=browser_mcp.sse_app()),
+        # Using direct mount path parameter
+        Mount("/curl", app=curl_mcp.sse_app("/curl")),
+        Mount("/search", app=search_mcp.sse_app("/search")),
+    ]
+)
+
+# Method 3: For direct execution, you can also pass the mount path to run()
+if __name__ == "__main__":
+    search_mcp.run(transport="sse", mount_path="/search")
+```
+
 For more information on mounting applications in Starlette, see the [Starlette documentation](https://www.starlette.io/routing/#submounting-routes).
 
 ## Examples
@@ -442,7 +618,7 @@ For more control, you can use the low-level server implementation directly. This
 
 ```python
 from contextlib import asynccontextmanager
-from typing import AsyncIterator
+from collections.abc import AsyncIterator
 
 from fake_database import Database  # Replace with your actual DB type
 
@@ -543,9 +719,11 @@ if __name__ == "__main__":
     asyncio.run(run())
 ```
 
+Caution: The `mcp run` and `mcp dev` tool doesn't support low-level server.
+
 ### Writing MCP Clients
 
-The SDK provides a high-level client interface for connecting to MCP servers:
+The SDK provides a high-level client interface for connecting to MCP servers using various [transports](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports):
 
 ```python
 from mcp import ClientSession, StdioServerParameters, types
@@ -609,6 +787,82 @@ if __name__ == "__main__":
     asyncio.run(run())
 ```
 
+Clients can also connect using [Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http):
+
+```python
+from mcp.client.streamable_http import streamablehttp_client
+from mcp import ClientSession
+
+
+async def main():
+    # Connect to a streamable HTTP server
+    async with streamablehttp_client("example/mcp") as (
+        read_stream,
+        write_stream,
+        _,
+    ):
+        # Create a session using the client streams
+        async with ClientSession(read_stream, write_stream) as session:
+            # Initialize the connection
+            await session.initialize()
+            # Call a tool
+            tool_result = await session.call_tool("echo", {"message": "hello"})
+```
+
+### OAuth Authentication for Clients
+
+The SDK includes [authorization support](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) for connecting to protected MCP servers:
+
+```python
+from mcp.client.auth import OAuthClientProvider, TokenStorage
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken
+
+
+class CustomTokenStorage(TokenStorage):
+    """Simple in-memory token storage implementation."""
+
+    async def get_tokens(self) -> OAuthToken | None:
+        pass
+
+    async def set_tokens(self, tokens: OAuthToken) -> None:
+        pass
+
+    async def get_client_info(self) -> OAuthClientInformationFull | None:
+        pass
+
+    async def set_client_info(self, client_info: OAuthClientInformationFull) -> None:
+        pass
+
+
+async def main():
+    # Set up OAuth authentication
+    oauth_auth = OAuthClientProvider(
+        server_url="https://api.example.com",
+        client_metadata=OAuthClientMetadata(
+            client_name="My Client",
+            redirect_uris=["http://localhost:3000/callback"],
+            grant_types=["authorization_code", "refresh_token"],
+            response_types=["code"],
+        ),
+        storage=CustomTokenStorage(),
+        redirect_handler=lambda url: print(f"Visit: {url}"),
+        callback_handler=lambda: ("auth_code", None),
+    )
+
+    # Use with streamable HTTP client
+    async with streamablehttp_client(
+        "https://api.example.com/mcp", auth=oauth_auth
+    ) as (read, write, _):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            # Authenticated session ready
+```
+
+For a complete working example, see [`examples/clients/simple-auth-client/`](examples/clients/simple-auth-client/).
+
+
 ### MCP Primitives
 
 The MCP protocol defines three core primitives that servers can implement:

main.py

@@ -1,859 +1,33 @@
 """
-TutorX MCP Server
+TutorX MCP Server - Main Entry Point
+
+This is the main entry point for the TutorX MCP server.
+It imports and runs the FastAPI application from the mcp_server package.
 """
-from mcp.server.fastmcp import FastMCP
-import json
 import os
-import warnings
 import uvicorn
-from typing import List, Dict, Any, Optional
-from datetime import datetime
-from fastapi import FastAPI, HTTPException, Query, Request
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from difflib import SequenceMatcher
-import re
-import base64
-import tempfile
-import fitz  # PyMuPDF
-import pytesseract
-from PIL import Image
-import io
-import numpy as np
-
-# Filter out the tool registration warning
-warnings.filterwarnings("ignore", message="Tool already exists")
-
-# Import utility functions
-from utils.multimodal import (
-    process_text_query,
-    process_voice_input,
-    process_handwriting,
-    generate_speech_response
-)
-from utils.assessment import (
-    generate_question,
-    evaluate_student_answer,
-    generate_performance_analytics,
-    detect_plagiarism
-)
-from typing import List, Dict, Any, Optional, Union
-import random
-from datetime import datetime, timedelta, timezone
-import json
+from mcp_server import api_app, mcp
 
 # Get server configuration from environment variables with defaults
-SERVER_HOST = os.getenv("MCP_HOST", "0.0.0.0")  # Allow connections from any IP
-SERVER_PORT = int(os.getenv("MCP_PORT", "8001"))  # Changed default port to 8001
-SERVER_TRANSPORT = os.getenv("MCP_TRANSPORT", "http")
-
-# Create FastAPI app
-api_app = FastAPI(title="TutorX MCP Server", version="1.0.0")
-
-# Add CORS middleware
-api_app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Create the TutorX MCP server with explicit configuration
-mcp = FastMCP(
-    "TutorX",
-    dependencies=["mcp[cli]>=1.9.3", "gradio>=4.19.0", "numpy>=1.24.0", "pillow>=10.0.0"],
-    host=SERVER_HOST,
-    port=SERVER_PORT,
-    transport=SERVER_TRANSPORT,
-    cors_origins=["*"]  # Allow CORS from any origin
-)
-
-# For FastMCP, we'll use it directly without mounting
-# as it already creates its own FastAPI app internally
-
-# ------------------ Core Features ------------------
-
-# 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 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']}"}
-    
-    # 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
-        
-    # 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_resource() -> Dict[str, Any]:
-    """Get the full knowledge concept graph"""
-    return {
-        "nodes": [
-            {"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": "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}
-        ]
-    }
-
-@mcp.resource("learning-path://{student_id}")
-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"]
-    }
-
-# 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
-@mcp.tool()
-async def generate_quiz(concept_ids: List[str], difficulty: int = 2) -> Dict[str, Any]:
-    """
-    Generate a quiz based on specified concepts and difficulty
-    
-    Args:
-        concept_ids: List of concept IDs to include in the quiz
-        difficulty: Difficulty level from 1-5
-        
-    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": f"quiz_{int(datetime.utcnow().timestamp())}",
-        "concept_ids": concept_ids,
-        "difficulty": difficulty,
-        "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(
-    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:
-        # 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(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=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)}"
-        )
-
-@mcp.tool()
-async def text_interaction(query: str, student_id: str) -> Dict[str, Any]:
-    """
-    Process a text query from a student and provide an educational response
-    
-    Args:
-        query: The student's question or input text
-        student_id: Unique identifier for the student
-        
-    Returns:
-        Dictionary containing the response and metadata
-    """
-    # In a real implementation, this would use an LLM to generate a response
-    # For now, we'll return a mock response
-    responses = {
-        "how do i solve a quadratic equation?": {
-            "response": "To solve a quadratic equation in the form ax² + bx + c = 0, you can use the quadratic formula: x = [-b ± √(b² - 4ac)] / (2a). First, identify the coefficients a, b, and c from your equation. Then plug them into the formula and simplify.",
-            "related_concepts": ["quadratic_equations", "algebra"],
-            "difficulty": "intermediate"
-        },
-        "what is photosynthesis?": {
-            "response": "Photosynthesis is the process by which green plants, algae, and some bacteria convert light energy, usually from the sun, into chemical energy. The overall reaction can be summarized as: 6CO₂ + 6H₂O + light energy → C₆H₁₂O₆ + 6O₂. This process occurs in the chloroplasts of plant cells.",
-            "related_concepts": ["biology", "plant_biology", "cellular_processes"],
-            "difficulty": "beginner"
-        },
-        "explain newton's laws of motion": {
-            "response": "Newton's three laws of motion are fundamental principles of physics:\\n\\n1. First Law (Inertia): An object at rest stays at rest, and an object in motion stays in motion at constant velocity unless acted upon by an external force.\\n2. Second Law: The acceleration of an object is directly proportional to the net force acting on it and inversely proportional to its mass (F=ma).\\n3. Third Law: For every action, there is an equal and opposite reaction.",
-            "related_concepts": ["physics", "mechanics", "newtonian_physics"],
-            "difficulty": "intermediate"
-        }
-    }
-    
-    # Convert query to lowercase for case-insensitive matching
-    query_lower = query.lower()
-    
-    # Check if we have a predefined response
-    if query_lower in responses:
-        response = responses[query_lower]
-    else:
-        # Default response for unknown queries
-        response = {
-            "response": f"I'm sorry, I don't have a specific response for that question. Could you rephrase or ask about something else?\\n\\nYour question was: {query}",
-            "related_concepts": [],
-            "difficulty": "unknown"
-        }
-    
-    return {
-        "query": query,
-        "student_id": student_id,
-        "timestamp": datetime.utcnow().isoformat(),
-        **response
-    }
-
-# Add API endpoint for text interaction
-@api_app.post("/api/text_interaction")
-async def api_text_interaction(request: Dict[str, Any]):
-    """
-    Handle text interaction requests from the client
-    
-    Expected request format:
-    {
-        "query": "user's question",
-        "student_id": "student_12345"
-    }
-    """
-    try:
-        # Validate request
-        if not isinstance(request, dict) or "query" not in request:
-            raise HTTPException(
-                status_code=400,
-                detail="Request must be a JSON object with 'query' key"
-            )
-            
-        # Get parameters
-        query = request.get("query", "")
-        student_id = request.get("student_id", "anonymous")
-        
-        # Process the query
-        result = await text_interaction(query, student_id)
-        return result
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to process text interaction: {str(e)}")
-
-@api_app.post("/api/check_submission_originality")
-async def check_submission_originality(request: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Check a student's submission for potential plagiarism against reference sources.
-    
-    Args:
-        request: Dictionary containing:
-            - submission: The student's submission text
-            - reference_sources: List of reference texts to check against
-            
-    Returns:
-        Dictionary with originality analysis results
-    """
-    submission = request.get("submission", "")
-    reference_sources = request.get("reference_sources", [])
-    
-    if not submission or not reference_sources:
-        return {
-            "error": "Both submission and reference_sources are required",
-            "score": 0.0,
-            "is_original": False
-        }
-    
-    def calculate_similarity(text1: str, text2: str) -> float:
-        """Calculate similarity between two texts (0.0 to 1.0)"""
-        # Simple similarity using SequenceMatcher
-        return SequenceMatcher(None, text1.lower(), text2.lower()).ratio()
-    
-    # Clean and preprocess texts
-    def preprocess(text: str) -> str:
-        # Remove extra whitespace and normalize
-        text = re.sub(r'\s+', ' ', text).strip()
-        # Remove common words and punctuation for better matching
-        common_words = {'the', 'a', 'an', 'and', 'or', 'but', 'is', 'are', 'was', 'were'}
-        words = [word for word in re.findall(r'\w+', text.lower()) if word not in common_words]
-        return ' '.join(words)
-    
-    # Calculate similarity scores against all references
-    preprocessed_submission = preprocess(submission)
-    matches = []
-    
-    for i, ref in enumerate(reference_sources):
-        if not ref:
-            continue
-            
-        preprocessed_ref = preprocess(ref)
-        similarity = calculate_similarity(preprocessed_submission, preprocessed_ref)
-        
-        matches.append({
-            "reference_index": i,
-            "similarity_score": round(similarity, 4),
-            "is_potential_plagiarism": similarity > 0.7  # Threshold can be adjusted
-        })
-    
-    # Calculate overall originality score (1.0 - max similarity)
-    max_similarity = max((m["similarity_score"] for m in matches), default=0.0)
-    originality_score = 1.0 - max_similarity
-    
-    # Basic plagiarism detection
-    is_original = all(m["similarity_score"] < 0.7 for m in matches)
-    
-    return {
-        "submission_length": len(submission),
-        "reference_count": len(reference_sources),
-        "originality_score": round(originality_score, 4),
-        "is_original": is_original,
-        "matches": matches,
-        "analysis": {
-            "similarity_threshold": 0.7,
-            "detection_method": "text_similarity"
-        }
-    }
-
-@api_app.post("/api/pdf_ocr")
-async def pdf_ocr(request: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Extract text from a PDF file using OCR
-    
-    Args:
-        request: Dictionary containing:
-            - pdf_data: Base64 encoded PDF data
-            - filename: Original filename (for reference)
-            
-    Returns:
-        Dictionary containing extracted text and metadata
-    """
-    try:
-        # Get the base64 encoded PDF data
-        pdf_base64 = request.get("pdf_data")
-        if not pdf_base64:
-            return {"error": "No PDF data provided", "success": False}
-            
-        # Decode the base64 data
-        pdf_bytes = base64.b64decode(pdf_base64)
-        
-        # Create a temporary file to store the PDF
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
-            temp_pdf.write(pdf_bytes)
-            temp_pdf_path = temp_pdf.name
-        
-        try:
-            # Extract text using PyMuPDF
-            text_content = []
-            image_pages = []
-            
-            # Open the PDF
-            doc = fitz.open(temp_pdf_path)
-            
-            # Extract text from each page
-            for page_num in range(len(doc)):
-                page = doc.load_page(page_num)
-                
-                # First try to extract text directly
-                page_text = page.get_text()
-                if page_text.strip():
-                    text_content.append(page_text)
-                else:
-                    # If no text found, try OCR on the page image
-                    pix = page.get_pixmap()
-                    img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-                    image_pages.append(img)
-            
-            # Close the document
-            doc.close()
-            
-            # If we have images to OCR, process them
-            if image_pages:
-                for img in image_pages:
-                    # Convert to grayscale for better OCR
-                    img_gray = img.convert('L')
-                    # Use pytesseract to do OCR on the image
-                    text = pytesseract.image_to_string(img_gray)
-                    if text.strip():
-                        text_content.append(text)
-            
-            # Combine all text
-            full_text = "\n\n".join(text_content).strip()
-            
-            # Generate a summary (this is a placeholder - you might want to use an LLM for better summarization)
-            summary = "\n".join([line for line in full_text.split('\n') if line.strip()][:10]) + "..."
-            
-            return {
-                "success": True,
-                "filename": request.get("filename", "document.pdf"),
-                "page_count": len(doc),
-                "text": full_text,
-                "summary": summary,
-                "has_ocr_applied": len(image_pages) > 0,
-                "ocr_page_count": len(image_pages)
-            }
-            
-        finally:
-            # Clean up the temporary file
-            try:
-                os.unlink(temp_pdf_path)
-            except:
-                pass
-                
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return {
-            "error": f"Failed to process PDF: {str(e)}",
-            "success": False
-        }
-
-# Mount MCP app to /mcp path
-mcp.app = api_app
+SERVER_HOST = os.getenv("MCP_HOST", "0.0.0.0")
+SERVER_PORT = int(os.getenv("MCP_PORT", "8001"))
+SERVER_TRANSPORT = os.getenv("MCP_TRANSPORT", "sse")
 
 def run_server():
-    """Run the MCP server with configured transport and port"""
-    print(f"Starting TutorX MCP Server on {SERVER_HOST}:{SERVER_PORT} using {SERVER_TRANSPORT} transport...")
-    try:
-        # Run the MCP server directly
-        import uvicorn
-        uvicorn.run(
-            "main:mcp.app",
-            host=SERVER_HOST,
-            port=SERVER_PORT,
-            log_level="info",
-            reload=True
-        )
-    except Exception as e:
-        print(f"Error starting server: {str(e)}")
-        raise
+    """Run the MCP server with the configured settings."""
+    print(f"Starting TutorX MCP server on {SERVER_HOST}:{SERVER_PORT}...")
+    print(f"MCP transport: {SERVER_TRANSPORT}")
+    print(f"API docs: http://{SERVER_HOST}:{SERVER_PORT}/docs")
+    print(f"MCP endpoint: http://{SERVER_HOST}:{SERVER_PORT}/mcp")
+    
+    # Configure uvicorn to run the FastAPI app
+    uvicorn.run(
+        "server:api_app",
+        host=SERVER_HOST,
+        port=SERVER_PORT,
+        reload=True,
+        log_level="info"
+    )
 
 if __name__ == "__main__":
     run_server()

mcp_server/__init__.py

@@ -0,0 +1,11 @@
+"""
+TutorX MCP Server Package
+
+This package contains the Model Context Protocol (MCP) server for the TutorX educational platform.
+"""
+
+__version__ = "0.1.0"
+
+def get_version() -> str:
+    """Return the current version of the TutorX MCP server."""
+    return __version__

mcp_server/mcp_instance.py

@@ -0,0 +1,7 @@
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(
+    "TutorX",
+    dependencies=["mcp[cli]>=1.9.3"],
+    cors_origins=["*"]
+) 

mcp_server/model/__init__.py

@@ -0,0 +1,3 @@
+from .gemini_flash import GeminiFlash
+
+__all__ = ['GeminiFlash']

mcp_server/model/gemini_flash.py

@@ -0,0 +1,147 @@
+import google.generativeai as genai
+from typing import Dict, Any, Optional, List, Literal, Union, TypeVar, Callable
+import os
+from functools import wraps
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T')
+
+class ModelError(Exception):
+    """Custom exception for model-related errors"""
+    pass
+
+def fallback_to_15_flash(method: Callable[..., T]) -> Callable[..., T]:
+    """
+    Decorator to automatically fall back to 1.5 if 2.0 fails.
+    Only applies when the instance's version is '2.0'.
+    """
+    @wraps(method)
+    async def wrapper(self: 'GeminiFlash', *args: Any, **kwargs: Any) -> T:
+        if self.version != '2.0' or not self._should_fallback:
+            return await method(self, *args, **kwargs)
+            
+        try:
+            return await method(self, *args, **kwargs)
+        except Exception as e:
+            logger.warning(f"Error with Gemini 2.0 Flash: {str(e)}")
+            
+            # Only fallback if we haven't already tried 1.5
+            if self.version == '2.0':
+                logger.info("Falling back to Gemini 1.5 Flash...")
+                fallback = GeminiFlash(version='1.5', api_key=self.api_key, _is_fallback=True)
+                return await getattr(fallback, method.__name__)(*args, **kwargs)
+            raise ModelError(f"Error with Gemini 1.5 Flash: {str(e)}")
+    return wrapper
+
+class GeminiFlash:
+    """
+    Google Gemini Flash model implementation with automatic fallback from 2.0 to 1.5.
+    """
+    
+    SUPPORTED_VERSIONS = ['2.0', '1.5']
+    
+    def __init__(self, version: str = '2.0', api_key: Optional[str] = None, _is_fallback: bool = False):
+        """
+        Initialize the Gemini Flash model.
+        
+        Args:
+            version: Model version ('2.0' or '1.5')
+            api_key: Google AI API key. If not provided, will look for GOOGLE_API_KEY env var.
+            _is_fallback: Internal flag to indicate if this is a fallback instance.
+        """
+        if version not in self.SUPPORTED_VERSIONS:
+            raise ValueError(f"Unsupported version: {version}. Supported versions: {self.SUPPORTED_VERSIONS}")
+            
+        self.version = version
+        api_key="AIzaSyC3TpRUinxSCASXncgqhD1FJ6yqAq3j9rY"
+        self.api_key = api_key 
+        if not self.api_key:
+            raise ValueError("GOOGLE_API_KEY environment variable not set and no API key provided")
+        
+        self._should_fallback = version == '2.0' and not _is_fallback
+        genai.configure(api_key=self.api_key)
+        self.model_name = f'gemini-{version}-flash'
+        self.model = genai.GenerativeModel(self.model_name)
+    
+    @fallback_to_15_flash
+    async def generate_text(
+        self,
+        prompt: str,
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        top_p: float = 0.9,
+        top_k: int = 40,
+        **kwargs
+    ) -> str:
+        """
+        Generate text using Gemini Flash.
+        
+        Args:
+            prompt: The input prompt
+            temperature: Controls randomness (0.0 to 1.0)
+            max_tokens: Maximum number of tokens to generate
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter
+            **kwargs: Additional generation parameters
+            
+        Returns:
+            Generated text response
+            
+        Raises:
+            ModelError: If both 2.0 and 1.5 models fail
+        """
+        response = await self.model.generate_content_async(
+            prompt,
+            generation_config={
+                'temperature': temperature,
+                'max_output_tokens': max_tokens,
+                'top_p': top_p,
+                'top_k': top_k,
+                **kwargs
+            }
+        )
+        return response.text
+    
+    @fallback_to_15_flash
+    async def chat(
+        self,
+        messages: List[Dict[Literal['role', 'content'], str]],
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        **kwargs
+    ) -> str:
+        """
+        Chat completion using Gemini Flash.
+        
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            temperature: Controls randomness (0.0 to 1.0)
+            max_tokens: Maximum number of tokens to generate
+            **kwargs: Additional generation parameters
+            
+        Returns:
+            Model's response
+            
+        Raises:
+            ModelError: If both 2.0 and 1.5 models fail
+        """
+        chat = self.model.start_chat(history=[])
+        # Process all but the last message as history
+        for message in messages[:-1]:
+            if message['role'] == 'user':
+                chat.send_message(message['content'])
+        
+        # Get response for the last message
+        response = await chat.send_message_async(
+            messages[-1]['content'],
+            generation_config={
+                'temperature': temperature,
+                'max_output_tokens': max_tokens,
+                **kwargs
+            }
+        )
+        return response.text

mcp_server/prompts/quiz_generation.txt

@@ -0,0 +1,25 @@
+You are an expert quiz generator. Create a 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
+
+Return the quiz in the following JSON format:
+{{
+  "quiz_title": "Quiz about [Concept]",
+  "questions": [
+    {{
+      "question": "...",
+      "options": ["...", "...", "...", "..."],
+      "correct_answer": "...",
+      "explanation": "..."
+    }}
+  ]
+}}
+
+Make sure the quiz is appropriate for {difficulty} difficulty level.

mcp_server/resources/concept_graph.py

@@ -0,0 +1,83 @@
+"""
+Concept graph data structure for TutorX knowledge base.
+"""
+from typing import Dict, Any
+
+# 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"]
+    }
+}
+
+def get_concept(concept_id: str) -> Dict[str, Any]:
+    """Get a specific concept by ID or return None if not found."""
+    return CONCEPT_GRAPH.get(concept_id)
+
+def get_all_concepts() -> Dict[str, Any]:
+    """Get all concepts in the graph."""
+    return {"concepts": list(CONCEPT_GRAPH.values())}
+
+def get_concept_graph() -> Dict[str, Any]:
+    """Get the complete concept graph."""
+    return CONCEPT_GRAPH

mcp_server/resources/curriculum_standards.py

@@ -0,0 +1,106 @@
+"""
+Curriculum standards for different countries and education systems.
+"""
+from typing import Dict, Any
+
+# Sample curriculum standards data
+CURRICULUM_STANDARDS = {
+    "us": {
+        "name": "Common Core State Standards (US)",
+        "subjects": {
+            "math": {
+                "k-5": ["Counting & Cardinality", "Operations & Algebraic Thinking", "Number & Operations"],
+                "6-8": ["Ratios & Proportional Relationships", "The Number System", "Expressions & Equations"],
+                "9-12": ["Number & Quantity", "Algebra", "Functions", "Modeling", "Geometry", "Statistics & Probability"]
+            },
+            "ela": {
+                "k-5": ["Reading: Literature", "Reading: Informational Text", "Foundational Skills"],
+                "6-12": ["Reading: Literature", "Reading: Informational Text", "Writing", "Speaking & Listening", "Language"]
+            },
+            "csta": {
+                "k-5": ["Algorithms & Programming", "Computing Systems", "Data & Analysis", "Impacts of Computing"],
+                "6-8": ["Algorithms & Programming", "Computing Systems", "Data & Analysis", "Impacts of Computing", "Networks & Internet"],
+                "9-12": ["Algorithms & Programming", "Computing Systems", "Data & Analysis", "Impacts of Computing", "Networks & Internet"]
+            }
+        },
+        "url": "http://www.corestandards.org/"
+    },
+    "uk": {
+        "name": "National Curriculum (UK)",
+        "subjects": {
+            "computing": {
+                "ks1": ["Computer Science", "Information Technology", "Digital Literacy"],
+                "ks2": ["Computer Science", "Information Technology", "Digital Literacy"],
+                "ks3": ["Computer Science", "Information Technology", "Digital Literacy"],
+                "ks4": ["Computer Science", "Information Technology", "Creative iMedia"]
+            },
+            "maths": {
+                "ks1": ["Number", "Measurement", "Geometry", "Statistics"],
+                "ks2": ["Number", "Ratio & Proportion", "Algebra", "Measurement", "Geometry", "Statistics"]
+            }
+        },
+        "url": "https://www.gov.uk/government/collections/national-curriculum"
+    },
+    "in": {
+        "name": "National Education Policy (India)",
+        "subjects": {
+            "mathematics": {
+                "foundation": ["Numeracy", "Shapes & Spatial Understanding"],
+                "preparatory": ["Numbers", "Basic Mathematical Operations", "Shapes & Geometry"],
+                "middle": ["Number System", "Algebra", "Geometry", "Mensuration", "Data Handling"],
+                "secondary": ["Number Systems", "Algebra", "Coordinate Geometry", "Geometry", "Trigonometry", "Mensuration", "Statistics & Probability"]
+            },
+            "computer_science": {
+                "middle": ["Computational Thinking", "Computer Systems", "Networking", "Data Analysis"],
+                "secondary": ["Programming", "Computer Networks", "Database Management", "Web Technologies"]
+            }
+        },
+        "url": "https://www.education.gov.in/en/nep2020"
+    },
+    "sg": {
+        "name": "Singapore Curriculum",
+        "subjects": {
+            "mathematics": {
+                "primary": ["Number & Algebra", "Measurement & Geometry", "Statistics"],
+                "secondary": ["Number & Algebra", "Geometry & Measurement", "Statistics & Probability", "Trigonometry & Calculus"]
+            },
+            "computing": {
+                "primary": ["Computational Thinking", "Coding", "Digital Literacy"],
+                "secondary": ["Computing", "Infocomm", "Media Studies"]
+            }
+        },
+        "url": "https://www.moe.gov.sg/"
+    },
+    "ca": {
+        "name": "Canadian Curriculum",
+        "subjects": {
+            "mathematics": {
+                "elementary": ["Number Sense & Numeration", "Measurement", "Geometry & Spatial Sense", "Patterning & Algebra", "Data Management & Probability"],
+                "secondary": ["Mathematics", "Advanced Functions", "Calculus & Vectors", "Data Management"]
+            },
+            "computer_studies": {
+                "grades_10-12": ["Computer Science", "Computer Engineering", "Computer Programming"]
+            }
+        },
+        "url": "https://www.cmec.ca/"
+    }
+}
+
+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', 'in', 'sg', 'ca')
+        
+    Returns:
+        Dictionary containing curriculum standards for the specified country
+    """
+    country_code = country_code.lower()
+    if country_code not in CURRICULUM_STANDARDS:
+        return {
+            "error": f"Curriculum standards for country code '{country_code}' not found. "
+                    f"Available countries: {', '.join(CURRICULUM_STANDARDS.keys())}"
+        }
+    
+    return CURRICULUM_STANDARDS[country_code]

mcp_server/server.py

@@ -0,0 +1,186 @@
+"""
+TutorX MCP Server
+
+This is the main entry point for the TutorX MCP server.
+"""
+import base64
+import os
+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 uvicorn
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from mcp.server.fastmcp import FastMCP
+
+# Import all tools to register them with MCP
+from tools import (
+    concept_tools,
+    lesson_tools,
+    quiz_tools,
+    interaction_tools,
+    ocr_tools,
+    learning_path_tools
+)
+
+# Import resources
+from resources import concept_graph, curriculum_standards
+
+# Create FastAPI app
+api_app = FastAPI(
+    title="TutorX MCP Server",
+    description="Model Context Protocol server for TutorX educational platform",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+api_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Import the shared mcp instance
+from mcp_server.mcp_instance import mcp
+
+# Explicitly import all tool modules so their @mcp.tool() decorators run
+from mcp_server.tools import concept_tools
+from mcp_server.tools import lesson_tools
+from mcp_server.tools import quiz_tools
+from mcp_server.tools import interaction_tools
+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())
+
+# Health check endpoint
+@api_app.get("/health")
+async def health_check():
+    return {"status": "healthy", "service": "tutorx-mcp"}
+
+# API endpoints - Concepts
+@api_app.get("/api/concept_graph")
+async def get_concept_graph(concept_id: str = None):
+    if concept_id:
+        concept = concept_graph.get_concept(concept_id)
+        if not concept:
+            raise HTTPException(status_code=404, detail={"error": f"Concept {concept_id} not found"})
+        return concept
+    return {"concepts": list(concept_graph.get_concept_graph().values())}
+
+@api_app.get("/api/concept/{concept_id}")
+async def get_concept_endpoint(concept_id: str):
+    concept = concept_graph.get_concept(concept_id)
+    if not concept:
+        raise HTTPException(status_code=404, detail=f"Concept {concept_id} not found")
+    return concept
+
+@api_app.get("/api/concepts")
+async def list_concepts():
+    return concept_graph.get_all_concepts()
+
+# API endpoints - Curriculum Standards
+@api_app.get("/api/curriculum-standards")
+async def get_curriculum_standards(country: str = "us"):
+    return curriculum_standards.get_curriculum_standards(country)
+
+# API endpoints - Text Interaction
+@api_app.post("/api/text-interaction")
+async def text_interaction_endpoint(request: dict):
+    query = request.get("query")
+    student_id = request.get("student_id")
+    if not query or not student_id:
+        raise HTTPException(status_code=400, detail="Both query and student_id are required")
+    return await interaction_tools.text_interaction(query, student_id)
+
+# API endpoints - Submission Originality Check
+@api_app.post("/api/check-originality")
+async def check_originality_endpoint(request: dict):
+    submission = request.get("submission")
+    reference_sources = request.get("reference_sources", [])
+    if not submission or not isinstance(reference_sources, list):
+        raise HTTPException(status_code=400, detail="submission (string) and reference_sources (array) are required")
+    return await interaction_tools.check_submission_originality(submission, reference_sources)
+
+# API endpoints - PDF OCR
+@api_app.post("/api/pdf-ocr")
+async def pdf_ocr_endpoint(
+    file: UploadFile = File(...),
+    filename: str = Form(None)
+):
+    try:
+        pdf_data = await file.read()
+        pdf_b64 = base64.b64encode(pdf_data).decode('utf-8')
+        result = await ocr_tools.pdf_ocr({
+            "pdf_data": pdf_b64,
+            "filename": filename or file.filename
+        })
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# API endpoints - Learning Path
+@api_app.post("/api/learning-path")
+async def learning_path_endpoint(request: dict):
+    student_id = request.get("student_id")
+    concept_ids = request.get("concept_ids", [])
+    student_level = request.get("student_level")
+    if not student_id or not concept_ids:
+        raise HTTPException(status_code=400, detail="student_id and concept_ids are required")
+    return await learning_path_tools.get_learning_path(
+        student_id=student_id,
+        concept_ids=concept_ids,
+        student_level=student_level
+    )
+
+# API endpoints - Assess Skill
+from 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")
+    concept_id = request.get("concept_id")
+    if not student_id or not concept_id:
+        raise HTTPException(status_code=400, detail="Both student_id and concept_id are required")
+    return await assess_skill_tool(student_id, concept_id)
+
+# API endpoints - Generate Lesson
+from tools.lesson_tools import generate_lesson_tool
+@api_app.post("/api/generate-lesson")
+async def generate_lesson_endpoint(request: dict):
+    topic = request.get("topic")
+    grade_level = request.get("grade_level")
+    duration_minutes = request.get("duration_minutes")
+    if not topic or grade_level is None or duration_minutes is None:
+        raise HTTPException(status_code=400, detail="topic, grade_level, and duration_minutes are required")
+    return await generate_lesson_tool(topic, grade_level, duration_minutes)
+
+# API endpoints - Generate Quiz
+from tools.quiz_tools import generate_quiz_tool
+@api_app.post("/api/generate-quiz")
+async def generate_quiz_endpoint(request: dict):
+    concept = request.get("concept", "")
+    difficulty = request.get("difficulty", 2)
+    if not concept or not isinstance(concept, str) or not concept.strip():
+        raise HTTPException(status_code=400, detail="concept must be a non-empty string")
+    if isinstance(difficulty, (int, float)):
+        if difficulty <= 2:
+            difficulty = "easy"
+        elif difficulty <= 4:
+            difficulty = "medium"
+        else:
+            difficulty = "hard"
+    if difficulty not in ["easy", "medium", "hard"]:
+        difficulty = "medium"
+    return await generate_quiz_tool(concept.strip(), difficulty)
+
+# Entrypoint for running with MCP SSE transport
+if __name__ == "__main__":
+    mcp.run(transport="sse")

mcp_server/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="mcp-server",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "fastapi>=0.68.0",
+        "uvicorn>=0.15.0",
+        "mcp[cli]>=1.9.3",
+        "pymupdf>=1.19.0",
+        "pytesseract>=0.3.8",
+        "Pillow>=8.3.1",
+        "numpy>=1.21.0",
+    ],
+    python_requires=">=3.8",
+)

mcp_server/tools/__init__.py

@@ -0,0 +1,38 @@
+"""
+TutorX MCP Tools
+
+This module contains all the MCP tools for the TutorX application.
+"""
+
+# Import all tools to make them available when importing the package
+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 .interaction_tools import text_interaction, check_submission_originality  # noqa
+from .ocr_tools import pdf_ocr, image_to_text  # noqa
+from .learning_path_tools import get_learning_path  # noqa
+
+__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
+    'pdf_ocr',
+    'image_to_text',
+    
+    # Learning path tools
+    'get_learning_path',
+]

mcp_server/tools/concept_graph_tools.py

@@ -0,0 +1,46 @@
+"""
+Concept graph tools for TutorX MCP.
+"""
+from typing import Dict, Any, Optional
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to the Python path
+current_dir = Path(__file__).parent
+parent_dir = current_dir.parent.parent
+sys.path.insert(0, str(parent_dir))
+
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to the Python path
+current_dir = Path(__file__).parent
+parent_dir = current_dir.parent
+sys.path.insert(0, str(parent_dir))
+
+# Import from local resources
+from resources import concept_graph
+
+# Import MCP
+from mcp_server.mcp_instance import mcp
+
+@mcp.tool()
+async def get_concept_graph_tool(concept_id: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Get the complete concept graph or a specific concept.
+    
+    Args:
+        concept_id: Optional concept ID to get a specific concept
+        
+    Returns:
+        Dictionary containing the concept graph or a specific concept
+    """
+    if concept_id:
+        concept = concept_graph.get_concept(concept_id)
+        if not concept:
+            return {"error": f"Concept {concept_id} not found"}
+        return {"concept": concept}
+    
+    return {"concepts": list(concept_graph.get_concept_graph().values())}

mcp_server/tools/concept_tools.py

@@ -0,0 +1,100 @@
+"""
+Concept-related MCP tools for TutorX.
+"""
+import random
+from typing import Dict, Any, Optional
+from datetime import datetime, timezone
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to the Python path
+current_dir = Path(__file__).parent
+parent_dir = current_dir.parent.parent
+sys.path.insert(0, str(parent_dir))
+
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to the Python path
+current_dir = Path(__file__).parent
+parent_dir = current_dir.parent
+sys.path.insert(0, str(parent_dir))
+
+# Import from local resources
+from resources.concept_graph import get_concept, get_all_concepts
+
+# Import MCP
+from mcp_server.mcp_instance import mcp
+
+@mcp.tool()
+async def get_concept_tool(concept_id: str = None) -> Dict[str, Any]:
+    """
+    Get a specific concept or all concepts from the knowledge graph.
+    
+    Args:
+        concept_id: Optional concept ID to retrieve a specific concept
+        
+    Returns:
+        Dictionary containing the requested concept(s)
+    """
+    if concept_id:
+        concept = get_concept(concept_id)
+        if not concept:
+            return {"error": f"Concept {concept_id} not found"}
+        return {"concept": concept}
+    return get_all_concepts()
+
+@mcp.tool()
+async def assess_skill_tool(student_id: str, concept_id: str) -> Dict[str, Any]:
+    """
+    Assess a student's understanding of a specific concept.
+    
+    Args:
+        student_id: Unique identifier for the student
+        concept_id: ID of the concept to assess
+        
+    Returns:
+        Dictionary containing assessment results
+    """
+    # Get concept data
+    concept_data = get_concept(concept_id)
+    if not concept_data:
+        return {"error": f"Cannot assess skill: Concept {concept_id} not found"}
+    
+    concept_name = concept_data.get("name", concept_id)
+    
+    # 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"] = [
+            f"Needs to strengthen fundamental knowledge of {concept_name}",
+            f"Practice more exercises on {concept_name}"
+        ]
+    
+    # Return assessment results
+    return {
+        "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
+    }

mcp_server/tools/interaction_tools.py

@@ -0,0 +1,127 @@
+"""
+Text interaction and submission checking tools for TutorX.
+"""
+import re
+from difflib import SequenceMatcher
+from typing import Dict, Any, List, Optional
+from mcp_server.mcp_instance import mcp
+
+def calculate_similarity(text1: str, text2: str) -> float:
+    """Calculate the similarity ratio between two texts."""
+    return SequenceMatcher(None, text1, text2).ratio()
+
+@mcp.tool()
+async def text_interaction(query: str, student_id: str) -> Dict[str, Any]:
+    """
+    Process a text query from a student and provide an educational response.
+    
+    Args:
+        query: The student's question or input text
+        student_id: Unique identifier for the student
+        
+    Returns:
+        Dictionary containing the response and metadata
+    """
+    # Simple response generation based on keywords
+    query_lower = query.lower()
+    
+    # Check for greetings
+    if any(word in query_lower for word in ["hello", "hi", "hey"]):
+        return {
+            "response": f"Hello! I'm your TutorX assistant. How can I help you today, Student {student_id}?",
+            "suggested_actions": [
+                "Ask a question about programming",
+                "Request a lesson on a topic",
+                "Take a quiz"
+            ]
+        }
+    
+    # Check for help request
+    if "help" in query_lower or "confused" in query_lower:
+        return {
+            "response": "I'm here to help! Could you please tell me what specific topic or concept you're struggling with?",
+            "suggested_actions": [
+                "Explain functions in Python",
+                "What is object-oriented programming?",
+                "Help me debug my code"
+            ]
+        }
+    
+    # Default response for other queries
+    return {
+        "response": f"I understand you're asking about: {query}. Here's what I can tell you...",
+        "metadata": {
+            "student_id": student_id,
+            "query_type": "general_inquiry"
+        },
+        "suggested_resources": [
+            {"title": "Related Documentation", "url": "https://docs.python.org/3/"},
+            {"title": "Tutorial Video", "url": "https://www.youtube.com/"},
+            {"title": "Practice Exercises", "url": "https://www.hackerrank.com/"}
+        ]
+    }
+
+@mcp.tool()
+async def check_submission_originality(submission: str, reference_sources: List[str]) -> Dict[str, Any]:
+    """
+    Check a student's submission for potential plagiarism against reference sources.
+    
+    Args:
+        submission: The student's submission text
+        reference_sources: List of reference texts to check against
+        
+    Returns:
+        Dictionary with originality analysis results
+    """
+    if not submission or not reference_sources:
+        return {"error": "Both submission and reference_sources are required"}
+    
+    # Simple plagiarism check using string similarity
+    results = []
+    for i, source in enumerate(reference_sources, 1):
+        if not source:
+            continue
+            
+        similarity = calculate_similarity(submission, source)
+        results.append({
+            "source_index": i,
+            "similarity_score": round(similarity, 4),
+            "is_original": similarity < 0.7,  # Threshold for originality
+            "suspicious_sections": []
+        })
+    
+    # Check for exact matches
+    exact_matches = []
+    submission_words = submission.split()
+    for i in range(len(submission_words) - 4):  # Check 5-word sequences
+        seq = ' '.join(submission_words[i:i+5])
+        for j, source in enumerate(reference_sources):
+            if seq in source:
+                exact_matches.append({
+                    "source_index": j + 1,
+                    "matched_text": seq,
+                    "position": i
+                })
+    
+    # Calculate overall originality score (weighted average)
+    if results:
+        avg_similarity = sum(r["similarity_score"] for r in results) / len(results)
+        originality_score = max(0, 1 - avg_similarity)
+    else:
+        originality_score = 1.0
+    
+    return {
+        "originality_score": round(originality_score, 2),
+        "is_original": all(r["is_original"] for r in results) if results else True,
+        "sources_checked": len(reference_sources),
+        "source_comparisons": results,
+        "exact_matches": exact_matches,
+        "recommendations": [
+            "Paraphrase any sections with high similarity scores",
+            "Add proper citations for referenced material",
+            "Use your own words to explain concepts"
+        ] if any(not r["is_original"] for r in results) else [
+            "Good job! Your work appears to be original.",
+            "Remember to always cite your sources properly."
+        ]
+    }

mcp_server/tools/learning_path_tools.py

@@ -0,0 +1,162 @@
+"""
+Learning path generation tools for TutorX.
+"""
+import random
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to the Python path
+current_dir = Path(__file__).parent
+parent_dir = current_dir.parent.parent
+sys.path.insert(0, str(parent_dir))
+
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to the Python path
+current_dir = Path(__file__).parent
+parent_dir = current_dir.parent
+sys.path.insert(0, str(parent_dir))
+
+# Import from local resources
+from resources.concept_graph import CONCEPT_GRAPH
+
+# Import MCP
+from mcp_server.mcp_instance import mcp
+
+def get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:
+    """
+    Get all prerequisites for a concept recursively.
+    
+    Args:
+        concept_id: ID of the concept to get prerequisites for
+        visited: Set of already visited concepts to avoid cycles
+        
+    Returns:
+        List of prerequisite concepts in order
+    """
+    if visited is None:
+        visited = set()
+    
+    if concept_id not in CONCEPT_GRAPH or concept_id in visited:
+        return []
+    
+    visited.add(concept_id)
+    prerequisites = []
+    
+    # Get direct prerequisites
+    for prereq_id in CONCEPT_GRAPH[concept_id].get("prerequisites", []):
+        if prereq_id in CONCEPT_GRAPH and prereq_id not in visited:
+            prerequisites.extend(get_prerequisites(prereq_id, visited))
+    
+    # Add the current concept
+    prerequisites.append(CONCEPT_GRAPH[concept_id])
+    return prerequisites
+
+def generate_learning_path(concept_ids: List[str], student_level: str = "beginner") -> Dict[str, Any]:
+    """
+    Generate a personalized learning path for a student.
+    
+    Args:
+        concept_ids: List of concept IDs to include in the learning path
+        student_level: Student's current level (beginner, intermediate, advanced)
+        
+    Returns:
+        Dictionary containing the learning path
+    """
+    if not concept_ids:
+        return {"error": "At least one concept ID is required"}
+    
+    # Get all prerequisites for each concept
+    all_prerequisites = []
+    visited = set()
+    
+    for concept_id in concept_ids:
+        if concept_id in CONCEPT_GRAPH:
+            prereqs = get_prerequisites(concept_id, visited)
+            all_prerequisites.extend(prereqs)
+    
+    # Remove duplicates while preserving order
+    unique_concepts = []
+    seen = set()
+    for concept in all_prerequisites:
+        if concept["id"] not in seen:
+            seen.add(concept["id"])
+            unique_concepts.append(concept)
+    
+    # Add any target concepts not already in the path
+    for concept_id in concept_ids:
+        if concept_id in CONCEPT_GRAPH and concept_id not in seen:
+            unique_concepts.append(CONCEPT_GRAPH[concept_id])
+    
+    # Estimate time required for each concept based on student level
+    time_estimates = {
+        "beginner": {"min": 30, "max": 60},    # 30-60 minutes per concept
+        "intermediate": {"min": 20, "max": 45},  # 20-45 minutes per concept
+        "advanced": {"min": 15, "max": 30}      # 15-30 minutes per concept
+    }
+    
+    level = student_level.lower()
+    if level not in time_estimates:
+        level = "beginner"
+    
+    time_min = time_estimates[level]["min"]
+    time_max = time_estimates[level]["max"]
+    
+    # Generate learning path with estimated times
+    learning_path = []
+    total_minutes = 0
+    
+    for i, concept in enumerate(unique_concepts, 1):
+        # Random time estimate within range
+        minutes = random.randint(time_min, time_max)
+        total_minutes += minutes
+        
+        learning_path.append({
+            "step": i,
+            "concept_id": concept["id"],
+            "concept_name": concept["name"],
+            "description": concept.get("description", ""),
+            "estimated_time_minutes": minutes,
+            "resources": [
+                f"Video tutorial on {concept['name']}",
+                f"{concept['name']} documentation",
+                f"Practice exercises for {concept['name']}"
+            ]
+        })
+    
+    # Calculate total time
+    hours, minutes = divmod(total_minutes, 60)
+    total_time = f"{hours}h {minutes}m" if hours > 0 else f"{minutes}m"
+    
+    return {
+        "learning_path": learning_path,
+        "total_steps": len(learning_path),
+        "total_time_minutes": total_minutes,
+        "total_time_display": total_time,
+        "student_level": student_level,
+        "generated_at": datetime.utcnow().isoformat() + "Z"
+    }
+
+@mcp.tool()
+async def get_learning_path(student_id: str, concept_ids: List[str], student_level: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Generate a personalized learning path for a student.
+    
+    Args:
+        student_id: Unique identifier for the student
+        concept_ids: List of concept IDs to include in the learning path
+        student_level: Optional student level (beginner, intermediate, advanced)
+        
+    Returns:
+        Dictionary containing the learning path
+    """
+    # In a real implementation, we would look up the student's level from their profile
+    if not student_level:
+        student_level = "beginner"  # Default level
+    
+    return generate_learning_path(concept_ids, student_level)

mcp_server/tools/lesson_tools.py

@@ -0,0 +1,123 @@
+"""
+Lesson generation tools for TutorX MCP.
+"""
+from typing import Dict, Any, List
+from mcp_server.mcp_instance import mcp
+
+@mcp.tool()
+async def generate_lesson_tool(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
+    """
+    # Validate inputs
+    if not topic or not isinstance(topic, str):
+        return {"error": "Topic must be a non-empty string"}
+    
+    if not isinstance(grade_level, int) or grade_level < 1 or grade_level > 12:
+        return {"error": "Grade level must be an integer between 1 and 12"}
+    
+    if not isinstance(duration_minutes, (int, float)) or duration_minutes <= 0:
+        return {"error": "Duration must be a positive number"}
+    
+    # Calculate time allocation (example: 10% intro, 30% instruction, 40% practice, 20% review)
+    intro_time = max(5, duration_minutes * 0.1)  # At least 5 minutes
+    instruction_time = duration_minutes * 0.3
+    practice_time = duration_minutes * 0.4
+    review_time = duration_minutes - (intro_time + instruction_time + practice_time)
+    
+    # Generate learning objectives based on grade level and topic
+    difficulty = {
+        1: "basic",
+        2: "basic",
+        3: "basic",
+        4: "intermediate",
+        5: "intermediate",
+        6: "intermediate",
+        7: "advanced",
+        8: "advanced",
+        9: "advanced",
+        10: "expert",
+        11: "expert",
+        12: "expert"
+    }.get(grade_level, "intermediate")
+    
+    # Create lesson plan
+    lesson_plan = {
+        "topic": topic,
+        "grade_level": grade_level,
+        "duration_minutes": duration_minutes,
+        "difficulty": difficulty,
+        "objectives": [
+            f"Understand the {difficulty} concepts of {topic}",
+            f"Apply {topic} concepts to solve problems",
+            f"Analyze and evaluate {topic} in different contexts"
+        ],
+        "materials": [
+            "Whiteboard and markers",
+            "Printed worksheets",
+            "Example code snippets",
+            "Interactive coding environment"
+        ],
+        "activities": [
+            {
+                "type": "introduction",
+                "duration_minutes": intro_time,
+                "description": f"Introduce the topic of {topic} and its importance"
+            },
+            {
+                "type": "direct_instruction",
+                "duration_minutes": instruction_time,
+                "description": f"Teach the core concepts of {topic}"
+            },
+            {
+                "type": "guided_practice",
+                "duration_minutes": practice_time,
+                "description": "Work through examples together"
+            },
+            {
+                "type": "independent_practice",
+                "duration_minutes": practice_time,
+                "description": "Students work on exercises independently"
+            },
+            {
+                "type": "review",
+                "duration_minutes": review_time,
+                "description": "Review key concepts and answer questions"
+            }
+        ],
+        "assessment": {
+            "type": "formative",
+            "methods": ["Exit ticket", "Class participation", "Worksheet completion"]
+        },
+        "differentiation": {
+            "for_struggling_students": [
+                "Provide additional examples",
+                "Offer one-on-one support",
+                "Use visual aids"
+            ],
+            "for_advanced_students": [
+                "Provide extension activities",
+                "Challenge with advanced problems",
+                "Encourage to help peers"
+            ]
+        },
+        "homework": {
+            "description": f"Complete practice problems on {topic}",
+            "estimated_time_minutes": 20,
+            "resources": [
+                f"{topic} practice worksheet",
+                "Online practice problems",
+                "Reading assignment"
+            ]
+        }
+    }
+    
+    return lesson_plan

mcp_server/tools/ocr_tools.py

@@ -0,0 +1,166 @@
+"""
+OCR (Optical Character Recognition) tools for TutorX.
+"""
+import base64
+import io
+import tempfile
+from typing import Dict, Any, Optional, Tuple
+# import fitz  # PyMuPDFuv run 
+import pytesseract
+from PIL import Image, ImageEnhance
+import numpy as np
+from mcp_server.mcp_instance import mcp
+
+def preprocess_image(image: Image.Image) -> Image.Image:
+    """
+    Preprocess image to improve OCR accuracy.
+    
+    Args:
+        image: Input PIL Image
+        
+    Returns:
+        Preprocessed PIL Image
+    """
+    # Convert to grayscale
+    image = image.convert('L')
+    
+    # Enhance contrast
+    enhancer = ImageEnhance.Contrast(image)
+    image = enhancer.enhance(2.0)
+    
+    # Enhance sharpness
+    enhancer = ImageEnhance.Sharpness(image)
+    image = enhancer.enhance(2.0)
+    
+    return image
+
+def extract_text_from_image(image: Image.Image) -> str:
+    """
+    Extract text from an image using Tesseract OCR.
+    
+    Args:
+        image: PIL Image to process
+        
+    Returns:
+        Extracted text
+    """
+    try:
+        # Preprocess the image
+        processed_image = preprocess_image(image)
+        
+        # Use Tesseract to do OCR on the image
+        text = pytesseract.image_to_string(processed_image, lang='eng')
+        return text.strip()
+    except Exception as e:
+        raise RuntimeError(f"Error during OCR processing: {str(e)}")
+
+def extract_text_from_pdf(pdf_data: bytes) -> Tuple[str, int]:
+    """
+    Extract text from a PDF file.
+    
+    Args:
+        pdf_data: PDF file content as bytes
+        
+    Returns:
+        Tuple of (extracted_text, page_count)
+    """
+    try:
+        # Open the PDF file
+        with fitz.open(stream=pdf_data, filetype="pdf") as doc:
+            page_count = len(doc)
+            extracted_text = []
+            
+            # Extract text from each page
+            for page_num in range(page_count):
+                page = doc.load_page(page_num)
+                text = page.get_text()
+                
+                # If no text is found, try OCR
+                if not text.strip():
+                    pix = page.get_pixmap()
+                    img_data = pix.tobytes("png")
+                    img = Image.open(io.BytesIO(img_data))
+                    text = extract_text_from_image(img)
+                
+                extracted_text.append(text)
+            
+            return "\n\n".join(extracted_text), page_count
+    except Exception as e:
+        raise RuntimeError(f"Error processing PDF: {str(e)}")
+
+@mcp.tool()
+async def pdf_ocr(request: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Extract text from a PDF file using OCR.
+    
+    Expected request format:
+    {
+        "pdf_data": "base64_encoded_pdf_data",
+        "filename": "document.pdf"  # Optional
+    }
+    
+    Returns:
+        Dictionary containing extracted text and metadata
+    """
+    try:
+        # Get and validate input
+        pdf_data_b64 = request.get("pdf_data")
+        if not pdf_data_b64:
+            return {"error": "Missing required field: pdf_data"}
+        
+        # Decode base64 data
+        try:
+            pdf_data = base64.b64decode(pdf_data_b64)
+        except Exception as e:
+            return {"error": f"Invalid base64 data: {str(e)}"}
+        
+        # Extract text from PDF
+        extracted_text, page_count = extract_text_from_pdf(pdf_data)
+        
+        # Prepare response
+        result = {
+            "success": True,
+            "filename": request.get("filename", "document.pdf"),
+            "page_count": page_count,
+            "extracted_text": extracted_text,
+            "character_count": len(extracted_text),
+            "word_count": len(extracted_text.split()),
+            "processing_time_ms": 0  # Could be calculated if needed
+        }
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error processing PDF: {str(e)}"}
+
+@mcp.tool()
+async def image_to_text(image_data: str) -> Dict[str, Any]:
+    """
+    Extract text from an image using OCR.
+    
+    Args:
+        image_data: Base64 encoded image data
+        
+    Returns:
+        Dictionary containing extracted text and metadata
+    """
+    try:
+        # Decode base64 image data
+        image_bytes = base64.b64decode(image_data)
+        
+        # Open image
+        image = Image.open(io.BytesIO(image_bytes))
+        
+        # Extract text
+        text = extract_text_from_image(image)
+        
+        return {
+            "success": True,
+            "extracted_text": text,
+            "character_count": len(text),
+            "word_count": len(text.split()),
+            "image_size": image.size,
+            "image_mode": image.mode
+        }
+    except Exception as e:
+        return {"error": f"Error processing image: {str(e)}"}

mcp_server/tools/quiz_tools.py

@@ -0,0 +1,62 @@
+"""
+Quiz generation tools for TutorX MCP.
+"""
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from mcp_server.mcp_instance import mcp
+from model import GeminiFlash
+
+# Load prompt template
+PROMPT_TEMPLATE = (Path(__file__).parent.parent / "prompts" / "quiz_generation.txt").read_text(encoding="utf-8")
+
+# Initialize Gemini model
+MODEL = GeminiFlash()
+
+@mcp.tool()
+async def generate_quiz_tool(concept: str, difficulty: str = "medium") -> Dict[str, Any]:
+    """
+    Generate a quiz based on a concept and difficulty using Gemini.
+    
+    Args:
+        concept: The concept to generate a quiz about
+        difficulty: Difficulty level (easy, medium, hard)
+        
+    Returns:
+        Dict containing the generated quiz in JSON format
+    """
+    try:
+        # Validate inputs
+        if not concept or not isinstance(concept, str):
+            return {"error": "concept must be a non-empty string"}
+            
+        valid_difficulties = ["easy", "medium", "hard"]
+        if difficulty.lower() not in valid_difficulties:
+            return {"error": f"difficulty must be one of {valid_difficulties}"}
+            
+        # Format the prompt
+        prompt = PROMPT_TEMPLATE.format(
+            concept=concept,
+            difficulty=difficulty.lower()
+        )
+        
+        # Generate quiz using Gemini
+        response = await MODEL.generate_text(prompt, temperature=0.7)
+        
+        # Try to parse the JSON response
+        try:
+            # Extract JSON from markdown code block if present
+            if '```json' in response:
+                json_str = response.split('```json')[1].split('```')[0].strip()
+            else:
+                json_str = response
+                
+            quiz_data = json.loads(json_str)
+            return quiz_data
+            
+        except json.JSONDecodeError as e:
+            return {"error": f"Failed to parse quiz response: {str(e)}", "raw_response": response}
+            
+    except Exception as e:
+        return {"error": f"Error generating quiz: {str(e)}"}

pyproject.toml

@@ -14,6 +14,12 @@ dependencies = [
     "pillow>=10.0.0",
     "python-multipart>=0.0.6",
     "pydantic>=2.6.0",
+    "networkx>=3.0",
+    "python-dotenv>=1.0.0",
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+    "pytest-asyncio>=0.23.0",
+    "httpx>=0.26.0",
 ]
 
 [project.optional-dependencies]
@@ -22,6 +28,7 @@ test = [
     "pytest-cov>=4.1.0",
     "pytest-asyncio>=0.23.0",
     "httpx>=0.26.0",
+    "pytest-mock>=3.12.0",
 ]
 
 [tool.pytest.ini_options]

run.py

@@ -1,130 +1,164 @@
 """
-Script to run either the MCP server or the Gradio interface
+Script to run either the MCP server or the Gradio interface for TutorX
 """
 
-import argparse
-import importlib.util
 import os
 import sys
-import time
-import subprocess
-
-def load_module(name, path):
-    """Load a module from path"""
-    spec = importlib.util.spec_from_file_location(name, path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
+import argparse
+import uvicorn
+from pathlib import Path
+import socket
 
-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...")
+def run_mcp_server(host="0.0.0.0", port=8001):
+    """
+    Run the MCP server using uvicorn
+    
+    Args:
+        host: Host to bind the server to
+        port: Port to run the server on
+    """
+    print(f"Starting TutorX MCP Server on {host}:{port}...")
     
-    # Set environment variables for MCP server
+    # Set environment variables
     os.environ["MCP_HOST"] = host
     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
-    if hasattr(main_module, "run_server"):
-        main_module.run_server()
-    else:
-        print("Error: run_server function not found in main.py")
+    try:
+        # Add the mcp-server directory to Python path
+        mcp_server_dir = str(Path(__file__).parent / "mcp-server")
+        if mcp_server_dir not in sys.path:
+            sys.path.insert(0, mcp_server_dir)
+        
+        # Import the FastAPI app
+        from server import api_app
+        
+        # Run the server using uvicorn
+        uvicorn.run(
+            "mcp-server.server:api_app",
+            host=host,
+            port=port,
+            reload=True,
+            reload_dirs=[mcp_server_dir],
+            log_level="info"
+        )
+    except ImportError as e:
+        print(f"Error: {e}")
+        print("Make sure you have installed all required dependencies:")
+        print("  pip install uvicorn fastapi")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error starting MCP server: {e}")
         sys.exit(1)
 
-def run_gradio_interface():
-    """Run the Gradio interface"""
-    print("Starting TutorX Gradio Interface...")
-    app_module = load_module("app", "app.py")
+def run_gradio_interface(port=7860):
+    """
+    Run the Gradio interface
     
-    # Run the Gradio demo
-    if hasattr(app_module, "demo"):
-        app_module.demo.launch(server_name="0.0.0.0", server_port=7860)
-    else:
-        print("Error: Gradio demo not found in app.py")
+    Args:
+        port: Port to run the Gradio interface on
+    """
+    print(f"Starting TutorX Gradio Interface on port {port}...")
+    
+    try:
+        # Make sure the mcp-server directory is in the path
+        mcp_server_dir = str(Path(__file__).parent / "mcp-server")
+        if mcp_server_dir not in sys.path:
+            sys.path.insert(0, mcp_server_dir)
+            
+        # Import and run the Gradio app
+        from app import demo
+        
+        # Launch the Gradio interface
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=port,
+            share=False
+        )
+    except Exception as e:
+        print(f"Failed to start Gradio interface: {e}")
         sys.exit(1)
 
 def check_port_available(port):
-    """Check if a port is available"""
-    import socket
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        sock.bind(('127.0.0.1', port))
-        sock.close()
-        return True
-    except:
-        return False
+    """
+    Check if a port is available
+    
+    Args:
+        port: Port number to check
+        
+    Returns:
+        bool: True if port is available, False otherwise
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(('localhost', port)) != 0
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Run TutorX MCP Server or Gradio Interface")
+    parser = argparse.ArgumentParser(
+        description="TutorX - Run MCP Server and/or Gradio Interface"
+    )
+    
+    # Add command line arguments
     parser.add_argument(
         "--mode", 
+        type=str, 
         choices=["mcp", "gradio", "both"], 
         default="both",
-        help="Run mode: 'mcp' for MCP server, 'gradio' for Gradio interface, 'both' for both"
+        help="Run mode: 'mcp' for MCP server, 'gradio' for Gradio interface, 'both' for both (default)"
     )
     parser.add_argument(
         "--host", 
+        type=str, 
         default="0.0.0.0",
-        help="Host address to use"
+        help="Host to bind the server to (default: 0.0.0.0)"
     )
     parser.add_argument(
-        "--port", 
-        type=int,
+        "--mcp-port", 
+        type=int, 
         default=8001,
-        help="Port to use for MCP server (default: 8001)"
+        help="Port for MCP server (default: 8001)"
     )
     parser.add_argument(
         "--gradio-port", 
-        type=int,
+        type=int, 
         default=7860,
-        help="Port to use for Gradio interface (default: 7860)"
-    )
-    parser.add_argument(
-        "--transport",
-        default="http",
-        help="Transport protocol to use (default: http)"
+        help="Port for Gradio interface (default: 7860)"
     )
     
     args = parser.parse_args()
     
-    if args.mode == "mcp":
-        if not check_port_available(args.port):
-            print(f"Warning: Port {args.port} is already in use. Trying to use the server anyway...")
-        run_mcp_server(args.host, args.port, args.transport)
-    elif args.mode == "gradio":
-        run_gradio_interface()
-    elif args.mode == "both":
-        # For 'both' mode, we'll start MCP server in a separate process
-        if not check_port_available(args.port):
-            print(f"Warning: Port {args.port} is already in use. Trying to use the server anyway...")
-            
-        # Start MCP server in a background process
-        mcp_process = subprocess.Popen(
-            [
-                sys.executable, 
-                "run.py", 
-                "--mode", "mcp", 
-                "--host", args.host, 
-                "--port", str(args.port),
-                "--transport", args.transport
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
+    # Check if ports are available
+    if args.mode in ["mcp", "both"] and not check_port_available(args.mcp_port):
+        print(f"Error: Port {args.mcp_port} is already in use (MCP server)")
+        sys.exit(1)
         
-        # Give the MCP server a moment to start up
-        print("Starting MCP server in background...")
-        time.sleep(2)
+    if args.mode in ["gradio", "both"] and not check_port_available(args.gradio_port):
+        print(f"Error: Port {args.gradio_port} is already in use (Gradio interface)")
+        sys.exit(1)
+    
+    try:
+        if args.mode in ["mcp", "both"]:
+            # Start MCP server in a separate process
+            mcp_process = multiprocessing.Process(
+                target=run_mcp_server,
+                kwargs={
+                    "host": args.host,
+                    "port": args.mcp_port
+                }
+            )
+            mcp_process.start()
+            
+            # Give the server a moment to start
+            time.sleep(2)
         
-        try:
-            # Then start Gradio interface
-            run_gradio_interface()
-        finally:
-            # Make sure to terminate the MCP server process when exiting
-            print("Shutting down MCP server...")
+        if args.mode in ["gradio", "both"]:
+            # Run Gradio in the main process
+            run_gradio_interface(port=args.gradio_port)
+            
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+    finally:
+        if 'mcp_process' in locals() and mcp_process.is_alive():
             mcp_process.terminate()
-            mcp_process.wait(timeout=5)
+            mcp_process.join(timeout=5)

utils/__init__.py

@@ -1,3 +0,0 @@
-"""
-TutorX MCP Server utilities.
-"""

utils/assessment.py

@@ -1,357 +0,0 @@
-"""
-Assessment and analytics utilities for the TutorX MCP server.
-"""
-
-from typing import Dict, Any, List, Optional, Tuple
-from datetime import datetime, timedelta
-import random
-import json
-
-def generate_question(concept_id: str, difficulty: int) -> Dict[str, Any]:
-    """
-    Generate a question for a specific concept at the given difficulty level
-    
-    Args:
-        concept_id: The concept identifier
-        difficulty: Difficulty level from 1-5
-        
-    Returns:
-        Question object
-    """
-    # In a real implementation, this would use templates and context to generate appropriate questions
-    # Here we'll simulate with some hardcoded examples
-    
-    question_templates = {
-        "math_algebra_basics": [
-            {
-                "text": "Simplify: {a}x + {b}x",
-                "variables": {"a": (1, 10), "b": (1, 10)},
-                "solution_template": "{a}x + {b}x = {sum}x",
-                "answer_template": "{sum}x"
-            },
-            {
-                "text": "Solve: x + {a} = {b}",
-                "variables": {"a": (1, 20), "b": (5, 30)},
-                "solution_template": "x + {a} = {b}\nx = {b} - {a}\nx = {answer}",
-                "answer_template": "x = {answer}"
-            }
-        ],
-        "math_algebra_linear_equations": [
-            {
-                "text": "Solve for x: {a}x + {b} = {c}",
-                "variables": {"a": (2, 5), "b": (1, 10), "c": (10, 30)},
-                "solution_template": "{a}x + {b} = {c}\n{a}x = {c} - {b}\n{a}x = {c_minus_b}\nx = {c_minus_b} / {a}\nx = {answer}",
-                "answer_template": "x = {answer}"
-            }
-        ],
-        "math_algebra_quadratic_equations": [
-            {
-                "text": "Solve: x² + {b}x + {c} = 0",
-                "variables": {"b": (-10, 10), "c": (-20, 20)},
-                "solution_template": "Using the quadratic formula: x = (-b ± √(b² - 4ac)) / 2a\nWith a=1, b={b}, c={c}:\nx = (-({b}) ± √(({b})² - 4(1)({c}))) / 2(1)\nx = (-{b} ± √({b_squared} - {four_c})) / 2\nx = (-{b} ± √{discriminant}) / 2\nx = (-{b} ± {sqrt_discriminant}) / 2\nx = ({neg_b_plus_sqrt} / 2) or x = ({neg_b_minus_sqrt} / 2)\nx = {answer1} or x = {answer2}",
-                "answer_template": "x = {answer1} or x = {answer2}"
-            }
-        ]
-    }
-    
-    # Select a template based on concept_id or return a default
-    templates = question_templates.get(concept_id, [
-        {
-            "text": "Define the term: {concept}",
-            "variables": {"concept": concept_id.replace("_", " ")},
-            "solution_template": "Definition of {concept}",
-            "answer_template": "Definition varies"
-        }
-    ])
-    
-    # Select a template based on difficulty
-    template_index = min(int(difficulty / 2), len(templates) - 1)
-    template = templates[template_index]
-    
-    # Fill in template variables
-    variables = {}
-    for var_name, var_range in template.get("variables", {}).items():
-        if isinstance(var_range, tuple) and len(var_range) == 2:
-            # For numeric ranges
-            variables[var_name] = random.randint(var_range[0], var_range[1])
-        else:
-            # For non-numeric values
-            variables[var_name] = var_range
-    
-    # Process the variables further for the solution
-    solution_vars = dict(variables)
-    
-    # For algebra basics
-    if concept_id == "math_algebra_basics" and "a" in variables and "b" in variables:
-        solution_vars["sum"] = variables["a"] + variables["b"]
-        solution_vars["answer"] = variables["b"] - variables["a"]
-    
-    # For linear equations
-    if concept_id == "math_algebra_linear_equations" and all(k in variables for k in ["a", "b", "c"]):
-        solution_vars["c_minus_b"] = variables["c"] - variables["b"]
-        solution_vars["answer"] = (variables["c"] - variables["b"]) / variables["a"]
-    
-    # For quadratic equations
-    if concept_id == "math_algebra_quadratic_equations" and all(k in variables for k in ["b", "c"]):
-        a = 1  # Assuming a=1 for simplicity
-        b = variables["b"]
-        c = variables["c"]
-        solution_vars["b_squared"] = b**2
-        solution_vars["four_c"] = 4 * c
-        solution_vars["discriminant"] = b**2 - 4*a*c
-        
-        if solution_vars["discriminant"] >= 0:
-            solution_vars["sqrt_discriminant"] = round(solution_vars["discriminant"] ** 0.5, 3)
-            solution_vars["neg_b_plus_sqrt"] = -b + solution_vars["sqrt_discriminant"]
-            solution_vars["neg_b_minus_sqrt"] = -b - solution_vars["sqrt_discriminant"]
-            solution_vars["answer1"] = round((-b + solution_vars["sqrt_discriminant"]) / (2*a), 3)
-            solution_vars["answer2"] = round((-b - solution_vars["sqrt_discriminant"]) / (2*a), 3)
-        else:
-            # Complex roots
-            solution_vars["sqrt_discriminant"] = f"{round((-solution_vars['discriminant']) ** 0.5, 3)}i"
-            solution_vars["answer1"] = f"{round(-b/(2*a), 3)} + {round(((-solution_vars['discriminant']) ** 0.5)/(2*a), 3)}i"
-            solution_vars["answer2"] = f"{round(-b/(2*a), 3)} - {round(((-solution_vars['discriminant']) ** 0.5)/(2*a), 3)}i"
-    
-    # Format text and solution
-    text = template["text"].format(**variables)
-    solution = template["solution_template"].format(**solution_vars) if "solution_template" in template else ""
-    answer = template["answer_template"].format(**solution_vars) if "answer_template" in template else ""
-    
-    return {
-        "id": f"q_{concept_id}_{random.randint(1000, 9999)}",
-        "concept_id": concept_id,
-        "difficulty": difficulty,
-        "text": text,
-        "solution": solution,
-        "answer": answer,
-        "variables": variables
-    }
-
-
-def evaluate_student_answer(question: Dict[str, Any], student_answer: str) -> Dict[str, Any]:
-    """
-    Evaluate a student's answer to a question
-    
-    Args:
-        question: The question object
-        student_answer: The student's answer as a string
-        
-    Returns:
-        Evaluation results
-    """
-    # In a real implementation, this would use NLP and math parsing to evaluate the answer
-    # Here we'll do a simple string comparison with some basic normalization
-    
-    def normalize_answer(answer):
-        """Normalize an answer string for comparison"""
-        return (answer.lower()
-                .replace(" ", "")
-                .replace("x=", "")
-                .replace("y=", ""))
-    
-    correct_answer = normalize_answer(question["answer"])
-    student_answer_norm = normalize_answer(student_answer)
-    
-    # Simple exact match for now
-    is_correct = student_answer_norm == correct_answer
-    
-    # In a real implementation, we would have partial matching and error analysis
-    error_type = None
-    if not is_correct:
-        # Try to guess error type - very simplified example
-        if question["concept_id"] == "math_algebra_linear_equations":
-            # Check for sign error
-            if "-" in correct_answer and "+" in student_answer_norm:
-                error_type = "sign_error"
-            # Check for arithmetic error (within 20% of correct value)
-            elif student_answer_norm.replace("-", "").isdigit() and correct_answer.replace("-", "").isdigit():
-                try:
-                    student_val = float(student_answer_norm)
-                    correct_val = float(correct_answer)
-                    if abs((student_val - correct_val) / correct_val) < 0.2:
-                        error_type = "arithmetic_error"
-                except (ValueError, ZeroDivisionError):
-                    pass
-    
-    return {
-        "question_id": question["id"],
-        "is_correct": is_correct,
-        "error_type": error_type,
-        "correct_answer": question["answer"],
-        "student_answer": student_answer,
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def generate_performance_analytics(student_id: str, timeframe_days: int = 30) -> Dict[str, Any]:
-    """
-    Generate performance analytics for a student
-    
-    Args:
-        student_id: The student's unique identifier
-        timeframe_days: Number of days to include in the analysis
-        
-    Returns:
-        Performance analytics
-    """
-    # In a real implementation, this would query a database
-    # Here we'll generate sample data
-    
-    # Generate some sample data points over the timeframe
-    start_date = datetime.now() - timedelta(days=timeframe_days)
-    data_points = []
-    
-    # Simulate an improving learning curve
-    accuracy_base = 0.65
-    speed_base = 120  # seconds
-    
-    for day in range(timeframe_days):
-        current_date = start_date + timedelta(days=day)
-        
-        # Simulate improvement over time with some random variation
-        improvement_factor = min(day / timeframe_days * 0.3, 0.3)  # Max 30% improvement
-        random_variation = random.uniform(-0.05, 0.05)
-        
-        accuracy = min(accuracy_base + improvement_factor + random_variation, 0.98)
-        speed = max(speed_base * (1 - improvement_factor) + random.uniform(-10, 10), 30)
-        
-        # Generate 1-3 data points per day
-        daily_points = random.randint(1, 3)
-        for _ in range(daily_points):
-            hour = random.randint(9, 20)  # Between 9 AM and 8 PM
-            timestamp = current_date.replace(hour=hour, minute=random.randint(0, 59))
-            
-            data_points.append({
-                "timestamp": timestamp.isoformat(),
-                "accuracy": round(accuracy, 2),
-                "speed_seconds": round(speed),
-                "difficulty": random.randint(1, 5),
-                "concepts": [f"concept_{random.randint(1, 10)}" for _ in range(random.randint(1, 3))]
-            })
-    
-    # Calculate aggregate metrics
-    if data_points:
-        avg_accuracy = sum(point["accuracy"] for point in data_points) / len(data_points)
-        avg_speed = sum(point["speed_seconds"] for point in data_points) / len(data_points)
-        
-        # Calculate improvement
-        first_week = [p for p in data_points if datetime.fromisoformat(p["timestamp"]) < start_date + timedelta(days=7)]
-        last_week = [p for p in data_points if datetime.fromisoformat(p["timestamp"]) > datetime.now() - timedelta(days=7)]
-        
-        accuracy_improvement = 0
-        speed_improvement = 0
-        
-        if first_week and last_week:
-            first_week_acc = sum(p["accuracy"] for p in first_week) / len(first_week)
-            last_week_acc = sum(p["accuracy"] for p in last_week) / len(last_week)
-            accuracy_improvement = round((last_week_acc - first_week_acc) * 100, 1)
-            
-            first_week_speed = sum(p["speed_seconds"] for p in first_week) / len(first_week)
-            last_week_speed = sum(p["speed_seconds"] for p in last_week) / len(last_week)
-            speed_improvement = round((first_week_speed - last_week_speed) / first_week_speed * 100, 1)
-    else:
-        avg_accuracy = 0
-        avg_speed = 0
-        accuracy_improvement = 0
-        speed_improvement = 0
-    
-    # Compile strengths and weaknesses
-    concept_performance = {}
-    for point in data_points:
-        for concept in point["concepts"]:
-            if concept not in concept_performance:
-                concept_performance[concept] = {"total": 0, "correct": 0}
-            concept_performance[concept]["total"] += 1
-            concept_performance[concept]["correct"] += point["accuracy"]
-    
-    strengths = []
-    weaknesses = []
-    
-    for concept, perf in concept_performance.items():
-        avg = perf["correct"] / perf["total"] if perf["total"] > 0 else 0
-        if avg > 0.85 and perf["total"] >= 3:
-            strengths.append(concept)
-        elif avg < 0.7 and perf["total"] >= 3:
-            weaknesses.append(concept)
-    
-    return {
-        "student_id": student_id,
-        "timeframe_days": timeframe_days,
-        "metrics": {
-            "avg_accuracy": round(avg_accuracy * 100, 1),
-            "avg_speed_seconds": round(avg_speed, 1),
-            "accuracy_improvement": accuracy_improvement,  # percentage points
-            "speed_improvement": speed_improvement,  # percentage
-            "total_questions_attempted": len(data_points),
-            "study_sessions": len(set(p["timestamp"].split("T")[0] for p in data_points))
-        },
-        "strengths": strengths[:3],  # Top 3 strengths
-        "weaknesses": weaknesses[:3],  # Top 3 weaknesses
-        "learning_style": "visual" if random.random() > 0.5 else "interactive",
-        "recommendations": [
-            "Focus on quadratic equations",
-            "Try more word problems",
-            "Schedule a tutoring session for challenging topics"
-        ],
-        "generated_at": datetime.now().isoformat()
-    }
-
-
-def detect_plagiarism(submission: str, reference_sources: List[str]) -> Dict[str, Any]:
-    """
-    Check for potential plagiarism in a student's submission
-    
-    Args:
-        submission: The student's submission
-        reference_sources: List of reference sources to check against
-        
-    Returns:
-        Plagiarism analysis
-    """
-    # In a real implementation, this would use sophisticated text comparison
-    # Here we'll do a simple similarity check
-    
-    def normalize_text(text):
-        return text.lower().replace(" ", "")
-    
-    norm_submission = normalize_text(submission)
-    matches = []
-    
-    for i, source in enumerate(reference_sources):
-        norm_source = normalize_text(source)
-        
-        # Check for exact substring matches of significant length
-        min_match_length = 30  # Characters
-        
-        for start in range(len(norm_submission) - min_match_length + 1):
-            chunk = norm_submission[start:start + min_match_length]
-            if chunk in norm_source:
-                source_start = norm_source.find(chunk)
-                
-                # Try to extend the match
-                match_length = min_match_length
-                while (start + match_length < len(norm_submission) and 
-                       source_start + match_length < len(norm_source) and
-                       norm_submission[start + match_length] == norm_source[source_start + match_length]):
-                    match_length += 1
-                
-                matches.append({
-                    "source_index": i,
-                    "source_start": source_start,
-                    "submission_start": start,
-                    "length": match_length,
-                    "match_text": submission[start:start + match_length]
-                })
-    
-    # Calculate overall similarity
-    total_matched_chars = sum(match["length"] for match in matches)
-    similarity_score = min(total_matched_chars / len(submission) if submission else 0, 1.0)
-    
-    return {
-        "similarity_score": round(similarity_score, 2),
-        "plagiarism_detected": similarity_score > 0.2,
-        "suspicious_threshold": 0.2,
-        "matches": matches,
-        "recommendation": "Review academic integrity guidelines" if similarity_score > 0.2 else "No issues detected",
-        "timestamp": datetime.now().isoformat()
-    }

utils/multimodal.py

@@ -1,140 +0,0 @@
-"""
-Utility functions for multi-modal interactions including text processing,
-voice recognition and handwriting recognition for the TutorX MCP server.
-"""
-
-from typing import Dict, Any, List, Optional
-import base64
-import json
-from datetime import datetime
-
-
-def process_text_query(query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """
-    Process a text query from the student
-    
-    Args:
-        query: The text query from the student
-        context: Optional context about the student and current session
-        
-    Returns:
-        Processed response
-    """
-    # In a real implementation, this would use NLP to understand the query
-    # and generate an appropriate response
-    
-    # Simple keyword-based response for demonstration
-    keywords = {
-        "solve": {
-            "type": "math_solution",
-            "response": "To solve this equation, first isolate the variable by..."
-        },
-        "what is": {
-            "type": "definition",
-            "response": "This concept refers to..."
-        },
-        "how do i": {
-            "type": "procedure",
-            "response": "Follow these steps: 1)..."
-        },
-        "help": {
-            "type": "assistance",
-            "response": "I'm here to help! You can ask me questions about..."
-        }
-    }
-    
-    for key, value in keywords.items():
-        if key in query.lower():
-            return {
-                "query": query,
-                "response_type": value["type"],
-                "response": value["response"],
-                "confidence": 0.85,
-                "timestamp": datetime.now().isoformat()
-            }
-    
-    # Default response if no keywords match
-    return {
-        "query": query,
-        "response_type": "general",
-        "response": "That's an interesting question. Let me think about how to help you with that.",
-        "confidence": 0.6,
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def process_voice_input(audio_data_base64: str) -> Dict[str, Any]:
-    """
-    Process voice input from the student
-    
-    Args:
-        audio_data_base64: Base64 encoded audio data
-        
-    Returns:
-        Transcription and analysis
-    """
-    # In a real implementation, this would use ASR to transcribe the audio
-    # and then process the transcribed text
-    
-    # For demonstration purposes, we'll simulate a transcription
-    return {
-        "transcription": "What is the quadratic formula?",
-        "confidence": 0.92,
-        "detected_emotions": {
-            "confusion": 0.7,
-            "interest": 0.9,
-            "frustration": 0.2
-        },
-        "audio_quality": "good",
-        "background_noise": "low",
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def process_handwriting(image_data_base64: str) -> Dict[str, Any]:
-    """
-    Process handwritten input from the student
-    
-    Args:
-        image_data_base64: Base64 encoded image data of handwriting
-        
-    Returns:
-        Transcription and analysis
-    """
-    # In a real implementation, this would use OCR/handwriting recognition
-    # to transcribe the handwritten text or equations
-    
-    # For demonstration purposes, we'll simulate a transcription
-    return {
-        "transcription": "x^2 + 5x + 6 = 0",
-        "confidence": 0.85,
-        "detected_content_type": "math_equation",
-        "equation_type": "quadratic",
-        "parsed_latex": "x^2 + 5x + 6 = 0",
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def generate_speech_response(text: str, voice_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """
-    Generate speech response from text
-    
-    Args:
-        text: The text to convert to speech
-        voice_params: Parameters for the voice (gender, age, accent, etc.)
-        
-    Returns:
-        Speech data and metadata
-    """
-    # In a real implementation, this would use TTS to generate audio
-    
-    # For demonstration, we'll simulate audio generation metadata
-    return {
-        "text": text,
-        "audio_format": "mp3",
-        "audio_data_base64": "SIMULATED_BASE64_AUDIO_DATA",
-        "voice_id": voice_params.get("voice_id", "default"),
-        "duration_seconds": len(text) / 15,  # Rough estimate of speech duration
-        "sample_rate": 24000,
-        "timestamp": datetime.now().isoformat()
-    }

uv.lock

@@ -688,6 +688,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/84/5d/e17845bb0fa76334477d5de38654d27946d5b5d3695443987a094a71b440/multidict-6.4.4-py3-none-any.whl", hash = "sha256:bd4557071b561a8b3b6075c3ce93cf9bfb6182cb241805c3d66ced3b75eff4ac", size = 10481, upload-time = "2025-05-19T14:16:36.024Z" },
 ]
 
+[[package]]
+name = "networkx"
+version = "3.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload-time = "2025-05-29T11:35:04.961Z" },
+]
+
 [[package]]
 name = "numpy"
 version = "2.2.6"
@@ -1044,6 +1053,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/28/d0/def53b4a790cfb21483016430ed828f64830dd981ebe1089971cd10cab25/pytest_cov-6.1.1-py3-none-any.whl", hash = "sha256:bddf29ed2d0ab6f4df17b4c55b0a657287db8684af9c42ea546b21b1041b3dde", size = 23841, upload-time = "2025-04-05T14:07:49.641Z" },
 ]
 
+[[package]]
+name = "pytest-mock"
+version = "3.14.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/28/67172c96ba684058a4d24ffe144d64783d2a270d0af0d9e792737bddc75c/pytest_mock-3.14.1.tar.gz", hash = "sha256:159e9edac4c451ce77a5cdb9fc5d1100708d2dd4ba3c3df572f14097351af80e", size = 33241, upload-time = "2025-05-26T13:58:45.167Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/05/77b60e520511c53d1c1ca75f1930c7dd8e971d0c4379b7f4b3f9644685ba/pytest_mock-3.14.1-py3-none-any.whl", hash = "sha256:178aefcd11307d874b4cd3100344e7e2d888d9791a6a1d9bfe90fbc1b74fd1d0", size = 9923, upload-time = "2025-05-26T13:58:43.487Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -1263,10 +1284,16 @@ dependencies = [
     { name = "aiohttp" },
     { name = "fastapi" },
     { name = "gradio" },
+    { name = "httpx" },
     { name = "mcp", extra = ["cli"] },
+    { name = "networkx" },
     { name = "numpy" },
     { name = "pillow" },
     { name = "pydantic" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "python-dotenv" },
     { name = "python-multipart" },
     { name = "uvicorn" },
 ]
@@ -1277,6 +1304,7 @@ test = [
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-cov" },
+    { name = "pytest-mock" },
 ]
 
 [package.metadata]
@@ -1284,14 +1312,21 @@ requires-dist = [
     { name = "aiohttp", specifier = ">=3.9.0" },
     { name = "fastapi", specifier = ">=0.109.0" },
     { name = "gradio", specifier = ">=4.19.0" },
+    { name = "httpx", specifier = ">=0.26.0" },
     { name = "httpx", marker = "extra == 'test'", specifier = ">=0.26.0" },
     { name = "mcp", extras = ["cli"], specifier = ">=1.9.3" },
+    { name = "networkx", specifier = ">=3.0" },
     { name = "numpy", specifier = ">=1.24.0" },
     { name = "pillow", specifier = ">=10.0.0" },
     { name = "pydantic", specifier = ">=2.6.0" },
+    { name = "pytest", specifier = ">=7.4.0" },
     { name = "pytest", marker = "extra == 'test'", specifier = ">=7.4.0" },
+    { name = "pytest-asyncio", specifier = ">=0.23.0" },
     { name = "pytest-asyncio", marker = "extra == 'test'", specifier = ">=0.23.0" },
+    { name = "pytest-cov", specifier = ">=4.1.0" },
     { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=4.1.0" },
+    { name = "pytest-mock", marker = "extra == 'test'", specifier = ">=3.12.0" },
+    { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "python-multipart", specifier = ">=0.0.6" },
     { name = "uvicorn", specifier = ">=0.27.0" },
 ]