get_peer_review_completion_analytics

Analyze peer review completion rates for Canvas assignments with student breakdowns and summary statistics to track participation and identify gaps.

Instructions

Get detailed analytics on peer review completion rates with student-by-student breakdown and summary statistics.

    Args:
        course_identifier: Canvas course code (e.g., badm_554_120251_246794) or ID
        assignment_id: Canvas assignment ID
        include_student_details: Include per-student breakdown
        group_by_status: Group students by completion status

Input Schema

TableJSON Schema

Name	Required	Description	Default
`course_identifier`	Yes
`assignment_id`	Yes
`include_student_details`	No
`group_by_status`	No

Implementation Reference

src/canvas_mcp/tools/peer_reviews.py:50-83 (handler)

The MCP tool handler function that executes the 'get_peer_review_completion_analytics' logic. It resolves the course ID, instantiates PeerReviewAnalyzer, fetches completion analytics, handles errors, and returns formatted JSON.

@mcp.tool()
@validate_params
async def get_peer_review_completion_analytics(
    course_identifier: str | int,
    assignment_id: str | int,
    include_student_details: bool = True,
    group_by_status: bool = True
) -> str:
    """Get detailed analytics on peer review completion rates with student-by-student breakdown and summary statistics.

    Args:
        course_identifier: Canvas course code (e.g., badm_554_120251_246794) or ID
        assignment_id: Canvas assignment ID
        include_student_details: Include per-student breakdown
        group_by_status: Group students by completion status
    """
    try:
        course_id = await get_course_id(course_identifier)
        analyzer = PeerReviewAnalyzer()

        result = await analyzer.get_completion_analytics(
            course_id=course_id,
            assignment_id=int(assignment_id),
            include_student_details=include_student_details,
            group_by_status=group_by_status
        )

        if "error" in result:
            return f"Error getting peer review completion analytics: {result['error']}"

        return json.dumps(result, indent=2)

    except Exception as e:
        return f"Error in get_peer_review_completion_analytics: {str(e)}"

src/canvas_mcp/server.py:52-52 (registration)
The call to register_peer_review_tools(mcp) within register_all_tools, which registers all peer review tools including 'get_peer_review_completion_analytics'.
```
register_peer_review_tools(mcp)
```

src/canvas_mcp/tools/peer_reviews.py:12-195 (registration)

The register_peer_review_tools function that defines and registers the peer review MCP tools using @mcp.tool() decorators, including the get_peer_review_completion_analytics handler.

def register_peer_review_tools(mcp: FastMCP):
    """Register all peer review analytics MCP tools."""

    @mcp.tool()
    @validate_params
    async def get_peer_review_assignments(
        course_identifier: str | int,
        assignment_id: str | int,
        include_names: bool = True,
        include_submission_details: bool = False
    ) -> str:
        """Get comprehensive peer review assignment mapping showing who is assigned to review whom with accurate completion status.

        Args:
            course_identifier: Canvas course code (e.g., badm_554_120251_246794) or ID
            assignment_id: Canvas assignment ID
            include_names: Include student names (requires additional API call)
            include_submission_details: Include submission metadata
        """
        try:
            course_id = await get_course_id(course_identifier)
            analyzer = PeerReviewAnalyzer()

            result = await analyzer.get_assignments(
                course_id=course_id,
                assignment_id=int(assignment_id),
                include_names=include_names,
                include_submission_details=include_submission_details
            )

            if "error" in result:
                return f"Error getting peer review assignments: {result['error']}"

            return json.dumps(result, indent=2)

        except Exception as e:
            return f"Error in get_peer_review_assignments: {str(e)}"

    @mcp.tool()
    @validate_params
    async def get_peer_review_completion_analytics(
        course_identifier: str | int,
        assignment_id: str | int,
        include_student_details: bool = True,
        group_by_status: bool = True
    ) -> str:
        """Get detailed analytics on peer review completion rates with student-by-student breakdown and summary statistics.

        Args:
            course_identifier: Canvas course code (e.g., badm_554_120251_246794) or ID
            assignment_id: Canvas assignment ID
            include_student_details: Include per-student breakdown
            group_by_status: Group students by completion status
        """
        try:
            course_id = await get_course_id(course_identifier)
            analyzer = PeerReviewAnalyzer()

            result = await analyzer.get_completion_analytics(
                course_id=course_id,
                assignment_id=int(assignment_id),
                include_student_details=include_student_details,
                group_by_status=group_by_status
            )

            if "error" in result:
                return f"Error getting peer review completion analytics: {result['error']}"

            return json.dumps(result, indent=2)

        except Exception as e:
            return f"Error in get_peer_review_completion_analytics: {str(e)}"

    @mcp.tool()
    @validate_params
    async def generate_peer_review_report(
        course_identifier: str | int,
        assignment_id: str | int,
        report_format: str = "markdown",
        include_executive_summary: bool = True,
        include_student_details: bool = True,
        include_action_items: bool = True,
        include_timeline_analysis: bool = True,
        save_to_file: bool = False,
        filename: str = None
    ) -> str:
        """Generate comprehensive peer review completion report with executive summary, detailed analytics, and actionable follow-up recommendations.

        Args:
            course_identifier: Canvas course code (e.g., badm_554_120251_246794) or ID
            assignment_id: Canvas assignment ID
            report_format: Report format (markdown, csv, json)
            include_executive_summary: Include executive summary
            include_student_details: Include student details
            include_action_items: Include action items
            include_timeline_analysis: Include timeline analysis
            save_to_file: Save report to local file
            filename: Custom filename for saved report
        """
        try:
            course_id = await get_course_id(course_identifier)
            analyzer = PeerReviewAnalyzer()

            result = await analyzer.generate_report(
                course_id=course_id,
                assignment_id=int(assignment_id),
                report_format=report_format,
                include_executive_summary=include_executive_summary,
                include_student_details=include_student_details,
                include_action_items=include_action_items,
                include_timeline_analysis=include_timeline_analysis
            )

            if "error" in result:
                return f"Error generating peer review report: {result['error']}"

            # Handle file saving if requested
            if save_to_file and "report" in result:
                import os
                from datetime import datetime

                if not filename:
                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                    filename = f"peer_review_report_{assignment_id}_{timestamp}.{report_format}"

                try:
                    # Save to current working directory
                    with open(filename, 'w', encoding='utf-8') as f:
                        f.write(result["report"])
                    result["saved_to"] = os.path.abspath(filename)
                except Exception as save_error:
                    result["save_error"] = f"Failed to save file: {str(save_error)}"

            if report_format in ["csv", "markdown"]:
                return result.get("report", json.dumps(result, indent=2))
            else:
                return json.dumps(result, indent=2)

        except Exception as e:
            return f"Error in generate_peer_review_report: {str(e)}"

    @mcp.tool()
    @validate_params
    async def get_peer_review_followup_list(
        course_identifier: str | int,
        assignment_id: str | int,
        priority_filter: str = "all",
        include_contact_info: bool = False,
        days_threshold: int = 3
    ) -> str:
        """Get prioritized list of students requiring instructor follow-up based on peer review completion status.

        Args:
            course_identifier: Canvas course code (e.g., badm_554_120251_246794) or ID
            assignment_id: Canvas assignment ID
            priority_filter: Priority filter (urgent, medium, low, all)
            include_contact_info: Include email addresses if available
            days_threshold: Days since assignment for urgency calculation
        """
        try:
            # Validate priority filter
            valid_priorities = ["urgent", "medium", "low", "all"]
            if priority_filter not in valid_priorities:
                return f"Error: priority_filter must be one of {valid_priorities}, got '{priority_filter}'"

            course_id = await get_course_id(course_identifier)
            analyzer = PeerReviewAnalyzer()

            result = await analyzer.get_followup_list(
                course_id=course_id,
                assignment_id=int(assignment_id),
                priority_filter=priority_filter,
                include_contact_info=include_contact_info,
                days_threshold=days_threshold
            )

            if "error" in result:
                return f"Error getting peer review followup list: {result['error']}"

            return json.dumps(result, indent=2)

        except Exception as e:
            return f"Error in get_peer_review_followup_list: {str(e)}"

Canvas MCP Server