# School Database MCP Server

A Model Context Protocol (MCP) server for managing a mock school database with automated behavior tracking and alert system.

## Overview

This project implements a school management system backend that provides tools for:
- Managing student and teacher data
- Recording and classifying student behavior incidents
- Automated behavior alert system with email notifications
- Database querying and schema inspection

The server uses SQLite for data storage and integrates with external services (like Gmail) for notifications.

## Features

### Core Database Management
- **Schema Inspection**: Get complete database structure with table relationships
- **Safe Query Execution**: Execute SELECT, INSERT, and UPDATE queries with parameter binding
- **Sample Data**: View sample records from any table

### Behavior Management Workflow
1. **Add Behavior Notes**: Record student behavior incidents with pending classification
2. **LLM Classification**: Automatically classify behaviors as positive, negative, or neutral
3. **Alert System**: Monitor students for concerning behavior patterns
4. **Email Notifications**: Automatically send alerts to relevant parties

### Available Tools
- `get_database_schema` - Inspect database structure and relationships
- `execute_query` - Run SQL queries safely
- `add_behavior_note_pending_classification` - Record new behavior incidents
- `update_behavior_classification` - Classify behavior after LLM analysis
- `get_pending_classifications` - List unclassified behavior notes
- `check_student_alerts_enhanced` - Check if students need behavior alerts
- `send_behavior_alert_email_immediately` - Send automated email alerts

## Database Schema

The system includes tables for:
- **Students**: Student information and contact details
- **Teachers**: Teacher information
- **Behavior Notes**: Incident records with classification and alerts
- **Classes**: Course and enrollment information
- **Grades**: Academic performance tracking

## Installation

### Prerequisites
- Python 3.12+
- SQLite3

### Setup
1. Clone the repository
2. Install dependencies:
   ```bash
   pip install mcp>=1.9.2
   ```
3. Run the server:
   ```bash
   python school_db_mcp.py
   ```

## Usage

### Starting the Server
```bash
python school_db_mcp.py
```

The server runs as an MCP server using stdio for communication.

### Example Workflow

1. **Inspect the database structure**:
   ```json
   {
     "tool": "get_database_schema",
     "arguments": {"include_sample_data": true}
   }
   ```

2. **Add a behavior incident**:
   ```json
   {
     "tool": "add_behavior_note_pending_classification",
     "arguments": {
       "student_name": "John Doe",
       "teacher_id": 1,
       "description": "Student was disruptive during class",
       "location": "Classroom 101"
     }
   }
   ```

3. **Classify the behavior**:
   ```json
   {
     "tool": "update_behavior_classification",
     "arguments": {
       "note_id": 1,
       "behavior_type": "negative",
       "reasoning": "Disruptive behavior affects learning environment"
     }
   }
   ```

4. **Check for alerts**:
   ```json
   {
     "tool": "check_student_alerts_enhanced",
     "arguments": {
       "student_id": 123,
       "days_back": 7
     }
   }
   ```

## Security Features

- **Query Sanitization**: Only SELECT, INSERT, and UPDATE queries allowed
- **Parameter Binding**: Prevents SQL injection attacks
- **Input Validation**: Validates all tool inputs before processing

## Integration

This server is designed to work with:
- **Gmail MCP Server**: For sending behavior alert emails
- **LLM Systems**: For automated behavior classification
- **School Management Systems**: As a backend data service

## Development

### Project Structure
```
school-db-server/
├── school_db_mcp.py    # Main server implementation
├── pyproject.toml      # Project configuration
├── README.md          # This file
└── school_data        # SQLite database file (created on first run)
```

### Key Classes
- `SchoolDatabaseMCP`: Main server class handling MCP protocol
- Database operations use SQLite with row factory for dict-like access
- Async/await pattern for all tool operations

## Notes

- This is a **demonstration/toy project** showcasing MCP server development
- Uses mock data for educational purposes
- Designed to integrate with other MCP servers in a larger system
- Includes comprehensive error handling and logging

## License

This project is for educational and demonstration purposes.