Removed gamification features and deployment configuration

README.md

@@ -182,16 +182,6 @@ TutorX-MCP can integrate with various external educational systems:
    - Schedule and manage tutoring sessions
    - Connect students with expert tutors
 
-## Deployment
-
-For production deployment, see [Deployment Guide](docs/deployment.md) which covers:
-
-- Docker-based deployment
-- Manual installation
-- Scaling strategies
-- Monitoring setup
-- Security considerations
-
 ## Documentation
 
 - [API Documentation](docs/api.md): Complete API reference for developers

app.py

@@ -56,7 +56,7 @@ 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(
+            assess_btn.click(
                 fn=lambda concept: client.assess_skill(student_id, concept),
                 inputs=[concept_id_input],
                 outputs=[assessment_output]
@@ -105,7 +105,7 @@ 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(
+            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]
@@ -142,7 +142,7 @@ 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(
+            text_btn.click(
                 fn=lambda query: client.text_interaction(query, student_id),
                 inputs=[text_input],
                 outputs=[text_output]
@@ -171,7 +171,7 @@ 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(
+            analytics_btn.click(
                 fn=lambda days: client.get_student_analytics(student_id, days),
                 inputs=[timeframe],
                 outputs=[analytics_output]
@@ -210,7 +210,7 @@ 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(
+            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]
@@ -240,102 +240,6 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 inputs=[submission_input, reference_input],
                 outputs=[plagiarism_output]
             )
-        
-        # Tab 6: Gamification
-        with gr.Tab("Gamification"):
-            gr.Markdown("## Student Badges")
-            
-            with gr.Row():
-                with gr.Column():
-                    badges_student_id = gr.Textbox(label="Student ID", value=student_id)
-                    get_badges_btn = gr.Button("Get Student Badges")
-                
-                with gr.Column():
-                    badges_output = gr.JSON(label="Student Badges")
-            
-            get_badges_btn.click(
-                fn=lambda sid: client.get_badges_for_student(sid),
-                inputs=[badges_student_id],
-                outputs=[badges_output]
-            )
-            
-            gr.Markdown("## Award Badge")
-            
-            with gr.Row():
-                with gr.Column():
-                    award_student_id = gr.Textbox(label="Student ID", value=student_id)
-                    badge_id = gr.Dropdown(
-                        choices=["beginner", "persistent", "math_whiz", "science_explorer", 
-                                "speed_demon", "accuracy_master", "helping_hand", 
-                                "night_owl", "early_bird", "perfect_streak"],
-                        label="Badge to Award",
-                        value="beginner"
-                    )
-                    award_badge_btn = gr.Button("Award Badge")
-                
-                with gr.Column():
-                    award_output = gr.JSON(label="Award Result")
-            
-            award_badge_btn.click(
-                fn=lambda sid, bid: client.award_student_badge(sid, bid),
-                inputs=[award_student_id, badge_id],
-                outputs=[award_output]
-            )
-            
-            gr.Markdown("## Leaderboards")
-            
-            with gr.Row():
-                with gr.Column():
-                    leaderboard_id = gr.Dropdown(
-                        choices=["weekly_points", "monthly_streak", "problem_solving_speed"],
-                        label="Leaderboard",
-                        value="weekly_points"
-                    )
-                    get_leaderboard_btn = gr.Button("Get Leaderboard")
-                
-                with gr.Column():
-                    leaderboard_output = gr.JSON(label="Leaderboard")
-            
-            get_leaderboard_btn.click(
-                fn=lambda lid: client.get_current_leaderboard(lid),
-                inputs=[leaderboard_id],
-                outputs=[leaderboard_output]
-            )
-            
-            gr.Markdown("## Track Activity")
-            
-            with gr.Row():
-                with gr.Column():
-                    track_student_id = gr.Textbox(label="Student ID", value=student_id)
-                    activity_type = gr.Dropdown(
-                        choices=["lesson_completed", "assessment_completed", "problem_solved", "forum_post", "login"],
-                        label="Activity Type",
-                        value="lesson_completed"
-                    )
-                    activity_score = gr.Slider(minimum=0, maximum=1, value=0.85, step=0.01, label="Score/Performance")
-                    activity_subject = gr.Dropdown(
-                        choices=["math", "science", "language", "history", "other"],
-                        label="Subject",
-                        value="math"
-                    )
-                    track_btn = gr.Button("Track Activity")
-                
-                with gr.Column():
-                    activity_output = gr.JSON(label="Activity Tracking Result")
-            
-            track_btn.click(
-                fn=lambda sid, atype, score, subject: client.track_student_activity(
-                    sid, 
-                    {
-                        "activity_type": atype,
-                        "score": score,
-                        "subject": subject,
-                        "time_seconds": 90  # Simulated time value
-                    }
-                ),
-                inputs=[track_student_id, activity_type, activity_score, activity_subject],
-                outputs=[activity_output]
-            )
 
 # Launch the app
 if __name__ == "__main__":

client.py

@@ -191,50 +191,13 @@ class TutorXClient:
             "student_id": student_id,
             "timeframe_days": timeframe_days
         })
-    
-    def check_submission_originality(self, submission: str, reference_sources: List[str]) -> Dict[str, Any]:
+      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
         })
     
-    # ------------ Gamification ------------
-    
-    def award_student_badge(self, student_id: str, badge_id: str) -> Dict[str, Any]:
-        """Award a badge to a student"""
-        return self._call_tool("award_student_badge", {
-            "student_id": student_id,
-            "badge_id": badge_id
-        })
-    
-    def get_badges_for_student(self, student_id: str) -> Dict[str, Any]:
-        """Get all badges for a student"""
-        return self._call_tool("get_badges_for_student", {
-            "student_id": student_id
-        })
-    
-    def update_student_leaderboard(self, leaderboard_id: str, student_id: str, score: float) -> Dict[str, Any]:
-        """Update a leaderboard with a student's score"""
-        return self._call_tool("update_student_leaderboard", {
-            "leaderboard_id": leaderboard_id,
-            "student_id": student_id,
-            "score": score
-        })
-    
-    def get_current_leaderboard(self, leaderboard_id: str) -> Dict[str, Any]:
-        """Get current leaderboard standings"""
-        return self._call_tool("get_current_leaderboard", {
-            "leaderboard_id": leaderboard_id
-        })
-    
-    def track_student_activity(self, student_id: str, activity_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Track a student's activity and check for achievements"""
-        return self._call_tool("track_student_activity", {
-            "student_id": student_id,
-            "activity_data": activity_data
-        })
-    
     # ------------ External Integrations ------------
     
     def lms_sync_grades(self, lms_type: str, api_url: str, api_key: str, 

deployment/Dockerfile

@@ -1,19 +0,0 @@
-FROM python:3.12-slim
-
-WORKDIR /app
-
-# Install dependencies
-COPY pyproject.toml .
-RUN pip install --no-cache-dir uv && \
-    uv pip install --no-cache -e .
-
-# Copy application code
-COPY main.py .
-COPY client.py .
-COPY utils/ ./utils/
-
-# Expose port for MCP server
-EXPOSE 8000
-
-# Run MCP server
-CMD ["python", "main.py"]

deployment/Dockerfile.web

@@ -1,19 +0,0 @@
-FROM python:3.12-slim
-
-WORKDIR /app
-
-# Install dependencies
-COPY pyproject.toml .
-RUN pip install --no-cache-dir uv && \
-    uv pip install --no-cache -e .
-
-# Copy application code
-COPY app.py .
-COPY client.py .
-COPY utils/ ./utils/
-
-# Expose port for Gradio interface
-EXPOSE 7860
-
-# Run Gradio interface
-CMD ["python", "app.py"]

deployment/docker-compose.yml

@@ -1,46 +0,0 @@
-version: '3'
-
-services:
-  tutorx-mcp:
-    build:
-      context: ..
-      dockerfile: deployment/Dockerfile
-    ports:
-      - "8000:8000"  # MCP server
-    environment:
-      - MCP_HOST=0.0.0.0
-      - MCP_PORT=8000
-      - LOG_LEVEL=INFO
-      - REDIS_HOST=redis
-    volumes:
-      - tutorx-data:/data
-    depends_on:
-      - redis
-    restart: unless-stopped
-
-  tutorx-web:
-    build:
-      context: ..
-      dockerfile: deployment/Dockerfile.web
-    ports:
-      - "7860:7860"  # Gradio interface
-    environment:
-      - GRADIO_SERVER_NAME=0.0.0.0
-      - GRADIO_SERVER_PORT=7860
-      - MCP_SERVER_URL=http://tutorx-mcp:8000
-    depends_on:
-      - tutorx-mcp
-    restart: unless-stopped
-
-  redis:
-    image: redis:alpine
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis-data:/data
-    command: redis-server --appendonly yes
-    restart: unless-stopped
-
-volumes:
-  tutorx-data:
-  redis-data:

docs/deployment.md

@@ -1,85 +0,0 @@
-# TutorX-MCP Deployment Guide
-
-This guide provides instructions for deploying the TutorX-MCP server in production environments.
-
-## Deployment Options
-
-### 1. Docker Deployment (Recommended)
-
-The easiest way to deploy TutorX-MCP is using Docker and Docker Compose:
-
-```bash
-# Navigate to the deployment directory
-cd deployment
-
-# Start the services
-docker-compose up -d
-```
-
-This will start:
-- The MCP server at http://localhost:8000
-- The Gradio web interface at http://localhost:7860
-- A Redis instance for caching and session management
-
-### 2. Manual Deployment
-
-#### Prerequisites
-
-- Python 3.12 or higher
-- Redis (optional, but recommended for production)
-
-#### Steps
-
-1. Install dependencies:
-   ```bash
-   uv install -e .
-   ```
-
-2. Configure environment variables:
-   ```bash
-   # Server configuration
-   export MCP_HOST=0.0.0.0
-   export MCP_PORT=8000
-   
-   # Redis configuration (if using)
-   export REDIS_HOST=localhost
-   export REDIS_PORT=6379
-   ```
-
-3. Run the server:
-   ```bash
-   python run.py --mode both --host 0.0.0.0
-   ```
-
-## Scaling
-
-For high-traffic deployments, consider:
-
-1. Using a reverse proxy like Nginx or Traefik in front of the services
-2. Implementing load balancing for multiple MCP server instances
-3. Scaling the Redis cache using Redis Sentinel or Redis Cluster
-
-## Monitoring
-
-We recommend setting up:
-
-1. Prometheus for metrics collection
-2. Grafana for visualization
-3. ELK stack for log management
-
-## Security Considerations
-
-1. In production, always use HTTPS
-2. Implement proper authentication for API access
-3. Keep dependencies updated
-4. Follow least privilege principles for service accounts
-
-## Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| MCP_HOST | Host address for MCP server | 127.0.0.1 |
-| MCP_PORT | Port for MCP server | 8000 |
-| REDIS_HOST | Redis host address | localhost |
-| REDIS_PORT | Redis port | 6379 |
-| LOG_LEVEL | Logging level (DEBUG, INFO, WARNING, ERROR) | INFO |

main.py

@@ -18,13 +18,6 @@ from utils.assessment import (
     generate_performance_analytics,
     detect_plagiarism
 )
-from utils.gamification import (
-    award_badge,
-    get_student_badges,
-    update_leaderboard,
-    get_leaderboard,
-    check_achievements
-)
 from utils.integrations import (
     LMSIntegration,
     OERIntegration,
@@ -588,89 +581,9 @@ def check_submission_originality(submission: str, reference_sources: List[str])
         reference_sources: List of reference texts to check against
         
     Returns:
-        Originality analysis
-    """
+        Originality analysis    """
     return detect_plagiarism(submission, reference_sources)
 
-# ------------------ Gamification Features ------------------
-
-@mcp.tool()
-def award_student_badge(student_id: str, badge_id: str) -> Dict[str, Any]:
-    """
-    Award a badge to a student
-    
-    Args:
-        student_id: The student's unique identifier
-        badge_id: The badge ID to award
-        
-    Returns:
-        Badge information
-    """
-    return award_badge(student_id, badge_id)
-
-@mcp.tool()
-def get_badges_for_student(student_id: str) -> Dict[str, Any]:
-    """
-    Get all badges for a student
-    
-    Args:
-        student_id: The student's unique identifier
-        
-    Returns:
-        Badge information
-    """
-    return get_student_badges(student_id)
-
-@mcp.tool()
-def update_student_leaderboard(leaderboard_id: str, student_id: str, score: float) -> Dict[str, Any]:
-    """
-    Update a leaderboard with a student's score
-    
-    Args:
-        leaderboard_id: ID of the leaderboard to update
-        student_id: The student's unique identifier
-        score: The score to record
-        
-    Returns:
-        Leaderboard information
-    """
-    return update_leaderboard(leaderboard_id, student_id, score)
-
-@mcp.tool()
-def get_current_leaderboard(leaderboard_id: str) -> Dict[str, Any]:
-    """
-    Get current leaderboard standings
-    
-    Args:
-        leaderboard_id: ID of the leaderboard to get
-        
-    Returns:
-        Leaderboard information
-    """
-    return get_leaderboard(leaderboard_id)
-
-@mcp.tool()
-def track_student_activity(student_id: str, activity_data: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Track a student's activity and check for achievements
-    
-    Args:
-        student_id: The student's unique identifier
-        activity_data: Data about the activity
-        
-    Returns:
-        Tracking information and any new badges
-    """
-    new_badges = check_achievements(student_id, activity_data)
-    
-    return {
-        "student_id": student_id,
-        "activity_tracked": True,
-        "activity_data": activity_data,
-        "new_badges": new_badges,
-        "timestamp": datetime.now().isoformat()
-    }
-
 # ------------------ External Integrations ------------------
 
 @mcp.tool()

utils/gamification.py

@@ -1,306 +0,0 @@
-"""
-Gamification utilities for the TutorX MCP server
-"""
-
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-import random
-
-
-# Dictionary to store badges for students
-# In a real application, this would be stored in a database
-BADGES_DB = {}
-
-# Dictionary to store leaderboards
-# In a real application, this would be stored in a database
-LEADERBOARDS_DB = {
-    "weekly_points": {},
-    "monthly_streak": {},
-    "problem_solving_speed": {}
-}
-
-# Badge definitions
-BADGES = {
-    "beginner": {
-        "name": "Beginner",
-        "description": "Completed your first lesson",
-        "icon": "🔰",
-        "points": 10
-    },
-    "persistent": {
-        "name": "Persistent Learner",
-        "description": "Completed 5 lessons in a row",
-        "icon": "🔄",
-        "points": 25
-    },
-    "math_whiz": {
-        "name": "Math Whiz",
-        "description": "Scored 100% on a math assessment",
-        "icon": "🧮",
-        "points": 50
-    },
-    "science_explorer": {
-        "name": "Science Explorer",
-        "description": "Completed 10 science modules",
-        "icon": "🔬",
-        "points": 50
-    },
-    "speed_demon": {
-        "name": "Speed Demon",
-        "description": "Solved 5 problems in under 2 minutes each",
-        "icon": "⚡",
-        "points": 35
-    },
-    "accuracy_master": {
-        "name": "Accuracy Master",
-        "description": "Maintained 90% accuracy over 20 problems",
-        "icon": "🎯",
-        "points": 40
-    },
-    "helping_hand": {
-        "name": "Helping Hand",
-        "description": "Helped 5 other students in the forum",
-        "icon": "🤝",
-        "points": 30
-    },
-    "night_owl": {
-        "name": "Night Owl",
-        "description": "Studied for 3 hours after 8 PM",
-        "icon": "🌙",
-        "points": 20
-    },
-    "early_bird": {
-        "name": "Early Bird",
-        "description": "Studied for 3 hours before 9 AM",
-        "icon": "🌅",
-        "points": 20
-    },
-    "perfect_streak": {
-        "name": "Perfect Streak",
-        "description": "Logged in for 7 days straight",
-        "icon": "🔥",
-        "points": 45
-    }
-}
-
-
-def award_badge(student_id: str, badge_id: str) -> Dict[str, Any]:
-    """
-    Award a badge to a student
-    
-    Args:
-        student_id: The student's unique identifier
-        badge_id: The badge's unique identifier
-        
-    Returns:
-        Badge information
-    """
-    if badge_id not in BADGES:
-        return {
-            "error": "Invalid badge ID",
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    if student_id not in BADGES_DB:
-        BADGES_DB[student_id] = {}
-    
-    # Check if student already has the badge
-    if badge_id in BADGES_DB[student_id]:
-        return {
-            "message": "Badge already awarded",
-            "badge": BADGES[badge_id],
-            "timestamp": BADGES_DB[student_id][badge_id]["timestamp"]
-        }
-    
-    # Award the badge
-    BADGES_DB[student_id][badge_id] = {
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    return {
-        "message": "Badge awarded!",
-        "badge": BADGES[badge_id],
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def get_student_badges(student_id: str) -> Dict[str, Any]:
-    """
-    Get all badges for a student
-    
-    Args:
-        student_id: The student's unique identifier
-        
-    Returns:
-        Dictionary of badges and points
-    """
-    if student_id not in BADGES_DB or not BADGES_DB[student_id]:
-        return {
-            "student_id": student_id,
-            "badges": [],
-            "total_points": 0,
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    badges_list = []
-    total_points = 0
-    
-    for badge_id in BADGES_DB[student_id]:
-        if badge_id in BADGES:
-            badge_info = BADGES[badge_id].copy()
-            badge_info["awarded_at"] = BADGES_DB[student_id][badge_id]["timestamp"]
-            badges_list.append(badge_info)
-            total_points += badge_info["points"]
-    
-    return {
-        "student_id": student_id,
-        "badges": badges_list,
-        "total_points": total_points,
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def update_leaderboard(leaderboard_id: str, student_id: str, score: float) -> Dict[str, Any]:
-    """
-    Update a leaderboard with a new score for a student
-    
-    Args:
-        leaderboard_id: The leaderboard to update
-        student_id: The student's unique identifier
-        score: The score to record
-        
-    Returns:
-        Updated leaderboard information
-    """
-    if leaderboard_id not in LEADERBOARDS_DB:
-        return {
-            "error": "Invalid leaderboard ID",
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    # Update student's score
-    LEADERBOARDS_DB[leaderboard_id][student_id] = {
-        "score": score,
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    # Get top 10 students
-    top_students = sorted(
-        LEADERBOARDS_DB[leaderboard_id].items(),
-        key=lambda x: x[1]["score"],
-        reverse=True
-    )[:10]
-    
-    # Format leaderboard
-    leaderboard = []
-    for i, (sid, data) in enumerate(top_students):
-        leaderboard.append({
-            "rank": i + 1,
-            "student_id": sid,
-            "score": data["score"],
-            "last_updated": data["timestamp"]
-        })
-    
-    # Find student's rank
-    student_rank = next(
-        (i + 1 for i, (sid, _) in enumerate(top_students) if sid == student_id),
-        len(LEADERBOARDS_DB[leaderboard_id]) + 1
-    )
-    
-    return {
-        "leaderboard_id": leaderboard_id,
-        "leaderboard": leaderboard,
-        "student_rank": student_rank,
-        "student_score": score,
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def get_leaderboard(leaderboard_id: str) -> Dict[str, Any]:
-    """
-    Get the current state of a leaderboard
-    
-    Args:
-        leaderboard_id: The leaderboard to get
-        
-    Returns:
-        Leaderboard information
-    """
-    if leaderboard_id not in LEADERBOARDS_DB:
-        return {
-            "error": "Invalid leaderboard ID",
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    # Get top 10 students
-    top_students = sorted(
-        LEADERBOARDS_DB[leaderboard_id].items(),
-        key=lambda x: x[1]["score"],
-        reverse=True
-    )[:10]
-    
-    # Format leaderboard
-    leaderboard = []
-    for i, (sid, data) in enumerate(top_students):
-        leaderboard.append({
-            "rank": i + 1,
-            "student_id": sid,
-            "score": data["score"],
-            "last_updated": data["timestamp"]
-        })
-    
-    return {
-        "leaderboard_id": leaderboard_id,
-        "leaderboard": leaderboard,
-        "total_students": len(LEADERBOARDS_DB[leaderboard_id]),
-        "timestamp": datetime.now().isoformat()
-    }
-
-
-def check_achievements(student_id: str, activity_data: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """
-    Check if a student's activity unlocks any new badges
-    
-    Args:
-        student_id: The student's unique identifier
-        activity_data: Data about the student's activity
-        
-    Returns:
-        List of newly awarded badges
-    """
-    new_badges = []
-    
-    # Initialize student badge record if needed
-    if student_id not in BADGES_DB:
-        BADGES_DB[student_id] = {}
-    
-    # Check for potential badge earnings based on activity
-    if "activity_type" in activity_data:
-        activity_type = activity_data["activity_type"]
-        
-        # Beginner badge - first lesson
-        if activity_type == "lesson_completed" and "beginner" not in BADGES_DB[student_id]:
-            badge_result = award_badge(student_id, "beginner")
-            if "error" not in badge_result:
-                new_badges.append(badge_result)
-        
-        # Math Whiz - perfect math assessment
-        if (activity_type == "assessment_completed" and 
-            activity_data.get("subject") == "math" and 
-            activity_data.get("score") == 1.0 and
-            "math_whiz" not in BADGES_DB[student_id]):
-            badge_result = award_badge(student_id, "math_whiz")
-            if "error" not in badge_result:
-                new_badges.append(badge_result)
-        
-        # Speed Demon - fast problem solving
-        if (activity_type == "problem_solved" and 
-            activity_data.get("time_seconds", 999) < 120):
-            # In a real system, we'd track the count over time
-            # Here we'll simulate it
-            if random.random() < 0.2 and "speed_demon" not in BADGES_DB[student_id]:
-                badge_result = award_badge(student_id, "speed_demon")
-                if "error" not in badge_result:
-                    new_badges.append(badge_result)
-    
-    return new_badges