Added proper MCP client, fixed Gradio-MCP integration, and improved architecture

README.md

@@ -124,6 +124,7 @@ The server exposes the following MCP tools and resources:
 ```
 tutorx-mcp/
 ├── main.py              # MCP server implementation
+├── client.py            # MCP client for calling server tools
 ├── app.py               # Gradio web interface
 ├── run.py               # Runner script for different modes
 ├── utils/               # Utility modules
@@ -133,6 +134,21 @@ tutorx-mcp/
 └── README.md            # Project documentation
 ```
 
+## Architecture
+
+The TutorX-MCP follows a layered architecture:
+
+1. **MCP Server (main.py)**: Core backend that exposes educational tools and resources through the Model Context Protocol.
+
+2. **MCP Client (client.py)**: Client library that communicates with the MCP server through HTTP requests, translating method calls into MCP protocol interactions.
+
+3. **Gradio Interface (app.py)**: Web-based user interface that uses the client to communicate with the MCP server.
+
+This separation of concerns allows:
+- MCP clients (like Claude Desktop App) to directly connect to the MCP server
+- The web interface to interact with the server using standard HTTP
+- Clear boundaries between presentation, business logic, and tool implementation
+
 ## License
 
 This project is licensed under the MIT License - see the LICENSE file for details.

app.py

@@ -10,37 +10,8 @@ from io import BytesIO
 from PIL import Image
 from datetime import datetime
 
-# Import MCP server tools
-from main import (
-    # Core features
-    assess_skill,
-    get_concept_graph,
-    get_learning_path,
-    generate_quiz,
-    analyze_error_patterns,
-    
-    # Advanced features
-    analyze_cognitive_state,
-    get_curriculum_standards,
-    align_content_to_standard,
-    generate_lesson,
-    
-    # User experience
-    get_student_dashboard,
-    get_accessibility_settings,
-    update_accessibility_settings,
-    
-    # Multi-modal
-    text_interaction,
-    voice_interaction,
-    handwriting_recognition,
-    
-    # Assessment
-    create_assessment,
-    grade_assessment,
-    get_student_analytics,
-    check_submission_originality
-)
+# Import MCP client to communicate with the MCP server
+from client import client
 
 # Utility functions
 def image_to_base64(img):
@@ -85,9 +56,8 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 
                 with gr.Column():
                     assessment_output = gr.JSON(label="Skill Assessment")
-            
-            assess_btn.click(
-                fn=lambda concept: assess_skill(student_id, concept),
+              assess_btn.click(
+                fn=lambda concept: client.assess_skill(student_id, concept),
                 inputs=[concept_id_input],
                 outputs=[assessment_output]
             )
@@ -97,7 +67,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
             concept_graph_output = gr.JSON(label="Concept Graph")
             
             concept_graph_btn.click(
-                fn=lambda: get_concept_graph(),
+                fn=lambda: client.get_concept_graph(),
                 inputs=[],
                 outputs=[concept_graph_output]
             )
@@ -117,7 +87,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     quiz_output = gr.JSON(label="Generated Quiz")
             
             gen_quiz_btn.click(
-                fn=lambda concepts, diff: generate_quiz(concepts, diff),
+                fn=lambda concepts, diff: client.generate_quiz(concepts, diff),
                 inputs=[concepts_input, diff_input],
                 outputs=[quiz_output]
             )
@@ -135,9 +105,8 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 
                 with gr.Column():
                     lesson_output = gr.JSON(label="Lesson Plan")
-            
-            gen_lesson_btn.click(
-                fn=lambda topic, grade, duration: generate_lesson(topic, grade, duration),
+              gen_lesson_btn.click(
+                fn=lambda topic, grade, duration: client.generate_lesson(topic, grade, duration),
                 inputs=[topic_input, grade_input, duration_input],
                 outputs=[lesson_output]
             )
@@ -157,7 +126,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     standards_output = gr.JSON(label="Curriculum Standards")
             
             standards_btn.click(
-                fn=lambda country: get_curriculum_standards(country),
+                fn=lambda country: client.get_curriculum_standards(country),
                 inputs=[country_input],
                 outputs=[standards_output]
             )
@@ -173,9 +142,8 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 
                 with gr.Column():
                     text_output = gr.JSON(label="Response")
-            
-            text_btn.click(
-                fn=lambda query: text_interaction(query, student_id),
+              text_btn.click(
+                fn=lambda query: client.text_interaction(query, student_id),
                 inputs=[text_input],
                 outputs=[text_output]
             )
@@ -192,7 +160,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
             
             # Convert drawing to base64 then process
             drawing_btn.click(
-                fn=lambda img: handwriting_recognition(image_to_base64(img), student_id),
+                fn=lambda img: client.handwriting_recognition(image_to_base64(img), student_id),
                 inputs=[drawing_input],
                 outputs=[drawing_output]
             )
@@ -203,9 +171,8 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
             analytics_btn = gr.Button("Generate Analytics Report")
             timeframe = gr.Slider(minimum=7, maximum=90, value=30, step=1, label="Timeframe (days)")
             analytics_output = gr.JSON(label="Performance Analytics")
-            
-            analytics_btn.click(
-                fn=lambda days: get_student_analytics(student_id, days),
+              analytics_btn.click(
+                fn=lambda days: client.get_student_analytics(student_id, days),
                 inputs=[timeframe],
                 outputs=[analytics_output]
             )
@@ -221,7 +188,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
             error_output = gr.JSON(label="Error Pattern Analysis")
             
             error_btn.click(
-                fn=lambda concept: analyze_error_patterns(student_id, concept),
+                fn=lambda concept: client.analyze_error_patterns(student_id, concept),
                 inputs=[error_concept],
                 outputs=[error_output]
             )
@@ -243,9 +210,8 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 
                 with gr.Column():
                     assessment_output = gr.JSON(label="Generated Assessment")
-            
-            create_assess_btn.click(
-                fn=lambda concepts, num, diff: create_assessment(concepts, num, diff),
+              create_assess_btn.click(
+                fn=lambda concepts, num, diff: client.create_assessment(concepts, num, diff),
                 inputs=[assess_concepts, assess_questions, assess_diff],
                 outputs=[assessment_output]
             )
@@ -270,7 +236,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     plagiarism_output = gr.JSON(label="Originality Report")
             
             plagiarism_btn.click(
-                fn=lambda sub, ref: check_submission_originality(sub, [ref]),
+                fn=lambda sub, ref: client.check_submission_originality(sub, [ref]),
                 inputs=[submission_input, reference_input],
                 outputs=[plagiarism_output]
             )

client.py

@@ -0,0 +1,203 @@
+"""
+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 requests
+from typing import Dict, Any, List, Optional
+import base64
+from datetime import datetime
+
+# Default MCP server URL
+MCP_SERVER_URL = "http://localhost:8000"
+
+class TutorXClient:
+    """Client for interacting with the TutorX MCP server"""
+    
+    def __init__(self, server_url=MCP_SERVER_URL):
+        self.server_url = server_url
+    
+    def _call_tool(self, tool_name: str, params: Dict[str, Any]) -> 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
+            
+        Returns:
+            Tool response
+        """
+        try:
+            response = requests.post(
+                f"{self.server_url}/tools/{tool_name}",
+                json=params,
+                headers={"Content-Type": "application/json"}
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {
+                "error": f"Failed to call tool: {str(e)}",
+                "timestamp": datetime.now().isoformat()
+            }
+    
+    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
+        """
+        try:
+            response = requests.get(
+                f"{self.server_url}/resources?uri={resource_uri}",
+                headers={"Accept": "application/json"}
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            return {
+                "error": f"Failed to get resource: {str(e)}",
+                "timestamp": datetime.now().isoformat()
+            }
+    
+    # ------------ Core Features ------------
+    
+    def assess_skill(self, student_id: str, concept_id: str) -> Dict[str, Any]:
+        """Assess student's skill level on a specific concept"""
+        return self._call_tool("assess_skill", {
+            "student_id": student_id,
+            "concept_id": concept_id
+        })
+    
+    def get_concept_graph(self) -> Dict[str, Any]:
+        """Get the full knowledge concept graph"""
+        return self._get_resource("concept-graph://")
+    
+    def get_learning_path(self, student_id: str) -> Dict[str, Any]:
+        """Get personalized learning path for a student"""
+        return self._get_resource(f"learning-path://{student_id}")
+    
+    def generate_quiz(self, concept_ids: List[str], difficulty: int = 2) -> Dict[str, Any]:
+        """Generate a quiz based on specified concepts and difficulty"""
+        return self._call_tool("generate_quiz", {
+            "concept_ids": concept_ids,
+            "difficulty": difficulty
+        })
+    
+    def analyze_error_patterns(self, student_id: str, concept_id: str) -> Dict[str, Any]:
+        """Analyze common error patterns for a student on a specific concept"""
+        return self._call_tool("analyze_error_patterns", {
+            "student_id": student_id,
+            "concept_id": concept_id
+        })
+    
+    # ------------ Advanced Features ------------
+    
+    def analyze_cognitive_state(self, eeg_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze EEG data to determine cognitive state"""
+        return self._call_tool("analyze_cognitive_state", {
+            "eeg_data": eeg_data
+        })
+    
+    def get_curriculum_standards(self, country_code: str) -> Dict[str, Any]:
+        """Get curriculum standards for a specific country"""
+        return self._get_resource(f"curriculum-standards://{country_code}")
+    
+    def align_content_to_standard(self, content_id: str, standard_id: str) -> Dict[str, Any]:
+        """Align educational content to a specific curriculum standard"""
+        return self._call_tool("align_content_to_standard", {
+            "content_id": content_id,
+            "standard_id": standard_id
+        })
+    
+    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 self._call_tool("generate_lesson", {
+            "topic": topic,
+            "grade_level": grade_level,
+            "duration_minutes": duration_minutes
+        })
+    
+    # ------------ User Experience ------------
+    
+    def get_student_dashboard(self, student_id: str) -> Dict[str, Any]:
+        """Get dashboard data for a specific student"""
+        return self._get_resource(f"student-dashboard://{student_id}")
+    
+    def get_accessibility_settings(self, student_id: str) -> Dict[str, Any]:
+        """Get accessibility settings for a student"""
+        return self._call_tool("get_accessibility_settings", {
+            "student_id": student_id
+        })
+    
+    def update_accessibility_settings(self, student_id: str, settings: Dict[str, Any]) -> Dict[str, Any]:
+        """Update accessibility settings for a student"""
+        return self._call_tool("update_accessibility_settings", {
+            "student_id": student_id,
+            "settings": settings
+        })
+    
+    # ------------ Multi-Modal Interaction ------------
+    
+    def text_interaction(self, query: str, student_id: str) -> Dict[str, Any]:
+        """Process a text query from the student"""
+        return self._call_tool("text_interaction", {
+            "query": query,
+            "student_id": student_id
+        })
+    
+    def voice_interaction(self, audio_data_base64: str, student_id: str) -> Dict[str, Any]:
+        """Process voice input from the student"""
+        return self._call_tool("voice_interaction", {
+            "audio_data_base64": audio_data_base64,
+            "student_id": student_id
+        })
+    
+    def handwriting_recognition(self, image_data_base64: str, student_id: str) -> Dict[str, Any]:
+        """Process handwritten input from the student"""
+        return self._call_tool("handwriting_recognition", {
+            "image_data_base64": image_data_base64,
+            "student_id": student_id
+        })
+    
+    # ------------ Assessment ------------
+    
+    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 self._call_tool("create_assessment", {
+            "concept_ids": concept_ids,
+            "num_questions": num_questions,
+            "difficulty": difficulty
+        })
+    
+    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 self._call_tool("grade_assessment", {
+            "assessment_id": assessment_id,
+            "student_answers": student_answers,
+            "questions": questions
+        })
+    
+    def get_student_analytics(self, student_id: str, timeframe_days: int = 30) -> Dict[str, Any]:
+        """Get comprehensive analytics for a student"""
+        return self._call_tool("get_student_analytics", {
+            "student_id": student_id,
+            "timeframe_days": timeframe_days
+        })
+    
+    def check_submission_originality(self, submission: str, reference_sources: List[str]) -> Dict[str, Any]:
+        """Check student submission for potential plagiarism"""
+        return self._call_tool("check_submission_originality", {
+            "submission": submission,
+            "reference_sources": reference_sources
+        })
+
+# Create a default client instance for easy import
+client = TutorXClient()

main.py

@@ -362,6 +362,7 @@ def update_accessibility_settings(student_id: str, settings: Dict[str, Any]) ->
 
 # ------------------ Multi-Modal Interaction ------------------
 
+@mcp.tool()
 @mcp.tool()
 def text_interaction(query: str, student_id: str, session_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """

pyproject.toml

@@ -9,4 +9,5 @@ dependencies = [
     "gradio>=4.19.0",
     "numpy>=1.24.0",
     "pillow>=10.0.0",
+    "requests>=2.31.0",
 ]