canvas-grader-mcp
An MCP server for Canvas LMS grading that lets an AI assistant inspect courses, assignments, and student submissions, then stage and post grades/comments with confirmation.
Identify the connected Canvas account and list courses where you can grade, optionally including concluded courses.
List assignments with counts needing grading, and read assignment descriptions, rubrics, points, due dates, and late policy.
List/filter submissions by status such as needs grading, submitted, graded, late, missing, or unsubmitted.
Read a student's submission as text, including files and linked Google Docs where enabled, plus lateness, previous comments, grade, and earlier attempts.
Extract screenshots, photos, and scanned pages from submitted files as images, with adjustable detail and image count.
Find groups of students who submitted byte-identical files.
Save/retrieve per-course grading guidelines and manual late-penalty tiers locally.
Stage proposed grades, rubric scores, score breakdowns, extra credit, late penalties, and student-facing comments locally; review or discard staged grades.
Post staged grades/comments or standalone comments to Canvas only with
confirm=true; otherwise preview only.Open SpeedGrader in the browser for an assignment or specific student.
Delete locally cached copies of student submission files.
Integrates with Canvas LMS to list grading courses and assignments, read assignment details, rubrics, due dates, and late policies, fetch and analyze student submissions, stage proposed grades and comments locally, and post approved grades and feedback back to Canvas SpeedGrader.
Reads publicly shared Google Docs, Slides, and Sheets linked in student submissions and converts them to text for grading.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@canvas-grader-mcp Grade ungraded Lab 3 submissions in CSE 110 using the rubric. Stage, don't post."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
canvas-grader-mcp
An MCP server that helps teachers and TAs grade Canvas LMS submissions with an AI assistant (Claude Code, Claude Desktop, Cursor, VS Code, …).
It reads each assignment's description, rubric, due dates and late policy, pulls in every student's submitted work as text, and lets the assistant propose a grade and written feedback about what's missing. Proposed grades are staged on your computer first; nothing reaches Canvas until you review it and approve posting. Posted grades and comments appear in SpeedGrader like any other.
Read Privacy and responsible use before using this with real student work. The server runs locally, but the student work it reads is sent to whichever AI model your MCP client uses.
What it can do
Find your grading work: every course where you're a teacher/TA with grading permission, assignments with how many submissions need grading.
Understand the assignment: description (as clean text), points, grading type, rubric criteria and ratings, per-student due dates (overrides and extensions), the course's automatic late policy.
Read submissions: text entries, URLs, and uploaded files: PDF, Word (.docx), Jupyter notebooks, Scratch projects (.sb3), zip archives, source code and other text files; publicly shared Google Docs/Slides/Sheets the student linked instead of uploading; links hidden behind text in PDFs; QR codes in screenshots; and files uploaded without (or with the wrong) extension, detected from their contents.
Read submitted websites: for link submissions (e.g. a LinkedIn post or portfolio site), the public page is opened and its text, author, date, hashtags, photos and whether it has a video are read, so the assistant can grade the post itself. Only public pages are read (no logins), and local/private network addresses are refused.
Check videos and links: every link in a submission is classified (video, photo, document, not public), so a photo album isn't mistaken for the required video, and frames can be pulled from submitted videos, e.g. when a student recorded their code instead of taking screenshots. Screenshots and photos inside PDFs and Word files (and uploaded images) are passed to the AI as images, so program screenshots get graded too. Files are downloaded to a local cache only.
Account for due dates: how late each submission was. If the course has an automatic late policy, it shows the deduction Canvas will apply (so you enter the raw score); if not, it flags that any penalty from the syllabus must be applied by the grader.
Your grading rules, per course: save guidelines (how lenient to be, what earns extra credit, what counts as evidence) and a manual late-penalty scale for each course. They're stored only on your computer and shown to the assistant with every assignment in that course.
Score breakdowns: stage a grade as per-category scores plus late penalty and extra credit; the tool totals it and writes the breakdown into the student's comment.
Consistency checks: find students who submitted identical files, and read any earlier attempt when a student re-uploaded the wrong file.
Stage → review → post: grades, rubric scores and comments are staged locally, previewed, then posted only with explicit confirmation. Comments explain to the student what was missing.
SpeedGrader links for every submission, or open SpeedGrader directly in your browser.
Related MCP server: Onboard GEO Precheck MCP Server
Requirements
A Canvas account with teacher, TA, or another role with "Grade submissions" permission in the courses you want to grade.
uv (installs Python 3.10+ automatically). Works on Linux, macOS and Windows.
Setup
1. Create a Canvas access token
In Canvas: Account → Settings → Approved Integrations → + New Access Token. Give it a purpose (e.g. "grading assistant") and an expiry date. Copy the token.
Some schools disable personal access tokens. If you don't see the button, ask your Canvas administrator.
2. Save your credentials (stored only on your computer)
uvx --from git+https://github.com/kaushikgunasekaren/canvas-grader-mcp canvas-grader-mcp configureThis asks for your Canvas URL and token (or pass them as configure --url <url> --token <token> where you can't type at a prompt), checks that they work, and saves them to ~/.config/canvas-grader-mcp/config.json (readable only by you; %APPDATA%\canvas-grader-mcp on Windows). Alternatively set the CANVAS_BASE_URL and CANVAS_API_TOKEN environment variables in your MCP client config.
Check it can see your courses:
uvx --from git+https://github.com/kaushikgunasekaren/canvas-grader-mcp canvas-grader-mcp check3. Add it to your MCP client
Claude Code
claude mcp add canvas-grader --scope user -- uvx --from git+https://github.com/kaushikgunasekaren/canvas-grader-mcp canvas-grader-mcpClaude Desktop, Cursor and other JSON-configured clients
{
"mcpServers": {
"canvas-grader": {
"command": "uvx",
"args": ["--from", "git+https://github.com/kaushikgunasekaren/canvas-grader-mcp", "canvas-grader-mcp"]
}
}
}VS Code (.vscode/mcp.json): the same, under "servers" instead of "mcpServers".
Using it
Example prompts:
"Which of my courses have assignments that need grading?"
"Grade the ungraded submissions for Lab 3 in CSE 110 using the rubric. Stage them, don't post yet."
"Show me what you staged for Lab 3, with your reasoning."
"Change Alice's score to 8 and soften the comment, then post all of them."
"Leave a comment on Bob's Lab 3 submission saying his tests are missing."
The intended workflow is:
get_assignment: the assistant reads the description, rubric and late policy.get_submissionper student: reads their work and lateness, plusget_submission_imagesfor screenshots/photos.stage_grade: proposes a grade, rubric scores and a student-facing comment, plus a private rationale for you.list_staged/post_staged_grades(preview): you review.post_staged_gradeswithconfirm=true: grades and comments go to Canvas.
Per-course grading guidelines
Every course is graded differently, so rules live with the course, not in the tool. Tell the assistant once, for example:
"For course 12345, save these grading guidelines: be lenient on short answers, give +1 for each optional challenge completed, and require a screenshot of working code. Late penalty: nothing under 1 day late, 5% under a week, 10% after that (at least 3 points)."
That calls set_grading_guidelines, which stores the rules in ~/.local/share/canvas-grader-mcp/guidelines.json (owner-only). From then on, get_assignment includes them, and every late submission gets a suggested_penalty from your tiers. Different courses can have completely different rules.
If the assignment posts grades automatically, students see them immediately once posted; the tool warns you. With a manual posting policy they stay hidden until you post them in the Gradebook or SpeedGrader.
Tools
Tool | Writes to Canvas? | What it does |
| no | Account and Canvas instance in use |
| no | Courses where you can grade |
| no | Assignments, due dates, needs-grading counts |
| no | Description, rubric, points, dates, late policy, posting policy |
| no | Students' submission status, lateness, scores (filter: needs_grading, late, missing, …) |
| no | A student's work as text, lateness, previous comments |
| no | Screenshots, photos and scanned pages from the submitted files, as images the AI can look at ( |
| no | Open a public page a student submitted (LinkedIn post, portfolio, blog) and return its text and photos |
| no | Groups of students who submitted byte-identical files |
| no (local) | Your per-course grading rules and late-penalty tiers |
| no | Save a proposed grade/rubric/comment locally, optionally from a per-category breakdown |
| no | Review or drop staged grades |
| yes (with | Send staged grades and comments to Canvas |
| yes (with | Comment on a submission without grading |
| notes only (with | Staff-only notes in the Gradebook Notes column (never visible to students) |
| no | Open SpeedGrader in your browser |
| no | Delete cached copies of student files |
Privacy and responsible use
Where data goes. This server only talks to your Canvas instance. But everything a tool returns, including student names, submissions and feedback, is passed to the AI model behind your MCP client (e.g. Anthropic for Claude). Student work is an education record under FERPA (US) and similar laws elsewhere. Check your institution's policy on sharing student work with AI services, and use an account/plan your school has approved where required.
Local data. Downloaded files are cached in
~/.cache/canvas-grader-mcpand staged grades in~/.local/share/canvas-grader-mcp/staged.json(owner-only permissions). Runclear_downloaded_fileswhen done.You are the grader. AI-suggested grades can be wrong, especially for scanned work, images, or anything that needs judgment the description doesn't spell out. Review every staged grade before posting. Consider telling students that AI assists your grading if your institution requires disclosure.
Token safety. Your token can do anything your Canvas account can. Give it an expiry date, never commit it, and revoke it in Canvas settings if it leaks. The server only sends it to your Canvas host.
Limitations
Anonymous and moderated assignments are read-only (grade them in SpeedGrader).
Classic quizzes, discussions, annotations, LTI tools, and audio/video submissions aren't converted to text; the tool points you to SpeedGrader.
Videos aren't watched end to end: the tool confirms a link or file is a video, reports its length, and can show sample frames. Only Google Drive/Photos, YouTube and common QR/short-link hosts are checked; other links are listed as web pages.
Account admins without a course enrollment aren't listed by
list_grading_courses.
Development
git clone https://github.com/kaushikgunasekaren/canvas-grader-mcp.git
cd canvas-grader-mcp
uv sync
uv run pytest # runs against a fake Canvas API, no account neededLicense
MIT. Not affiliated with Instructure.
Available Tools
17 toolsclear_downloaded_filesA
Delete locally cached copies of student submission files.
Inputs: no named parameters. Returns: result
discard_stagedA
Delete staged grades (all for the assignment, or only the given students). Does not touch Canvas.
Inputs: course_id (required), assignment_id (required), user_ids. Returns: result
get_assignmentB
Everything needed to grade an assignment: description, rubric, points, due dates and late policy.
Inputs: course_id (required), assignment_id (required).
get_grading_guidelinesC
The saved grading guidelines and late-penalty tiers for a course.
Inputs: course_id (required).
get_submissionC
A student's submitted work as text (text entry, URL, PDF/DOCX/code/notebook/.sb3 files, linked Google Docs), QR-code links, lateness, previous comments and grade.
Inputs: user_id (required), course_id (required), assignment_id (required), attempt, +2 more.
get_submission_imagesB
Screenshots, photos and scanned pages from a student's submitted files, as images.
PDF pages that contain pictures are rendered whole (so screenshots keep their captions); images embedded in Word files and uploaded image files are returned directly. Duplicates are skipped.
Inputs: user_id (required), course_id (required), assignment_id (required), detail, +2 more.
list_assignmentsC
Assignments in a course, with how many submissions still need grading.
Inputs: course_id (required), only_needing_grading. Returns: result
list_grading_coursesB
Courses where you are a teacher/TA (or similar) and have permission to grade.
Inputs: include_concluded. Returns: result
list_stagedB
Grades and comments staged locally but not yet posted to Canvas.
Inputs: course_id, assignment_id. Returns: result
list_submissionsC
Students' submissions for an assignment with status, lateness and current score.
Inputs: course_id (required), assignment_id (required), filter.
open_in_speedgraderB
Open SpeedGrader in the user's browser (optionally on a specific student).
Inputs: course_id (required), assignment_id (required), user_id. Returns: result
post_commentC
Post a feedback comment on a student's submission without changing the grade.
Inputs: text (required), user_id (required), course_id (required), assignment_id (required), +2 more.
post_staged_gradesA
Send staged grades/comments to Canvas (they appear in SpeedGrader). Without confirm=true, only previews.
Inputs: course_id (required), assignment_id (required), confirm, user_ids.
set_grading_guidelinesA
Save grading guidelines and a manual late-penalty scale for a course (stored only on this computer).
Inputs: course_id (required), guidelines, late_penalty_tiers.
stage_gradeA
Save a proposed grade/comment locally (nothing is sent to Canvas). Review with list_staged, send with post_staged_grades.
Inputs: user_id (required), course_id (required), rationale (required), assignment_id (required), +9 more.
whoamiC
The Canvas account and instance this server is connected to.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 17 tools
Most tools have clearly distinct purposes (listing vs. getting vs. staging vs. posting), and the stage/post/discard lifecycle is well separated. Minor potential confusion exists between get_submission, get_submission_images, and list_submissions, and between the two guideline tools, but descriptions disambiguate them.
Nearly all tools use a consistent snake_case verb_noun pattern (list_assignments, get_submission, stage_grade, post_staged_grades). The only real deviation is whoami, which breaks the verb_noun convention but is still readable and unambiguous.
17 tools is slightly heavy but justified by a genuine multi-stage grading workflow (courses, assignments, submissions, media, caching, staging, posting). Each tool maps to a distinct step with little redundancy.
The surface covers the full grading lifecycle: discover courses/assignments, read submissions and images, manage guidelines, stage/discard/post grades, comment, and open SpeedGrader. Minor gaps like rubric-score retrieval or bulk filtering exist but core workflows have no dead ends.
Maintenance
Related MCP Connectors
Grade essays, check resumes, and ask typed yes/no, choice and rubric questions, powered by Jev.
Manage your Canvas coursework with quick access to courses, assignments, and grades. Track upcomin…
Generate tailored quality criteria and scoring guides from your task descriptions. Refine objectiv…
Plagiarism checker and AI detector for essays, research papers, theses, articles and blog posts. Find copied text with links to each source, and see how likely each sentence is to be AI-written by tools like ChatGPT. An AI score is a likelihood, not proof. Sign in with OAuth. Works with a free Plagiarism Checker Plus account.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI assistants to perform code reviews by providing access to staged files, git diffs, and repository file content. It allows users to evaluate changes and context within any local git repository before committing or pushing.34 npmISC
- FlicenseNot gradedqualityDmaintenanceEnables to precheck landing pages and Figma frames for readiness to be cited in AI Overviews, providing audit scores, grades, and improvement actions.-
- AlicenseNot gradedqualityBmaintenanceEnables a browser-based AI assistant to read code, edit files, run tests, inspect failures, and keep task checkpoints on a local project.27 npmMIT
- FlicenseNot gradedqualityAmaintenanceEnables agents to analyze text strings or local files for formulaic AI writing patterns and receive numeric scores, band labels, contextual violations, and concrete advice.-