Canvas MCP Server
MCP server for Canvas LMS with up to 128 tools and 8 agent skills. Designed for Claude Desktop, Cursor, Codex, Windsurf, and 40+ other agents; setup and capabilities vary by client.
Quick Start
1. Install the MCP server (everything else, including the skills, needs it running):
- Claude Desktop: download
canvas-mcp.mcpbfrom the latest release and double-click it. It prompts for your Canvas URL and token; no terminal needed. Details. - Cursor, Zed, Windsurf, Continue, Claude Code and other clients:
pip installinto a virtualenv, add your token to.env, and point your client at thecanvas-mcp-serverbinary. Local Installation has the per-client config blocks.
2. Verify: canvas-mcp-server --test should report a successful Canvas connection. Then restart your client.
3. Optional: add the workflow skills. These teach your agent the multi-step recipes (weekly plan, morning check, bulk grading, peer review, course QC) on top of the tools:
npx skills add vishalsachdev/canvas-mcp
See Agent Skills for the list. If your agent is Claude Code, the same recipes are also available as slash commands.
For AI Agents
Canvas MCP provides up to 128 tools for interacting with Canvas LMS; the default profile registers fewer, and optional feature-gated tools can raise the total to 128. Tools are organized by user type:
Skills: canvas-course-qc (pre-semester audit), canvas-accessibility-auditor (WCAG-oriented review), canvas-course-builder (scaffold courses from specs/templates).
Decision tree: Simple query → MCP tools. Batch grading (10+) → bulk_grade_submissions. Complex bulk (30+) → execute_typescript.
Quick Reference
Course identifiers: Canvas ID (12345), course code (badm_350_120251_246794), or SIS ID
Cannot do: Create/delete courses, modify course settings, access other users' data
Rate limits: ~700 requests/10 min. Use max_concurrent=5 for bulk operations.
Full documentation: AGENTS.md | tools/TOOL_MANIFEST.json | tools/README.md
Overview
The Canvas MCP Server bridges the gap between AI assistants and Canvas Learning Management System, providing role-specific workflows for students, educators, learning designers, and developers. Built on the Model Context Protocol (MCP), it is designed for MCP-compatible clients; setup and supported capabilities vary by client.
Latest Release: v1.16.0
Released: October 2026 | Full Changelog | All Releases
A security release. It fixes three privately reported issues and closes the last gap left by the 1.13.0 prompt-injection advisory, and it adds course group creation. Breaking for local code execution: the local sandbox now needs Node.js 22.18 or later.
- Local code sandbox (GHSA-7pp5-29mw-9jq3): in local sandbox mode, the default without a container runtime,
execute_typescriptruns under Node's permission model. The code can read only the bundled code API, and Node refuses child processes, worker threads, native addons and file writes. Breaking: needs Node.js 22.18+, and TypeScript is type-stripped, so import types withimport typeand avoid enums and namespaces. Network blocking in local mode stays best-effort (#157). - Canvas token stays with Canvas (GHSA-7mj9-4mcg-hvhv): file downloads from separate storage hosts no longer carry the Canvas token, including after redirects, and an upload confirmation outside Canvas is refused.
- File contents are fenced (GHSA-hmr8-mvr2-mvw5):
read_course_filemarks returned file contents as untrusted Canvas data, and the CI registry test checks that payload. - Windows download permissions (GHSA-qf6c-jv93-38gv): on Windows, downloaded files inherit the destination folder's permissions. Every Windows download now says so. This is a documented limitation.
- Course group creation:
create_course_groupspreviews and confirms a new group set, groups and memberships from CSV, andresume_course_group_creationfinishes interrupted work (#526). - Submission text on request:
list_submissions(include_body=True)returns submitted text after amanage_gradescheck, anonymized, fenced and bounded (#523).
Thanks to @EQSTLab, @KKazuhaK and @bruchris for reporting.
v1.15.0 — A hardening release: HTTP callers are kept apart from each other (#480, #491), HTML is parsed in one bounded pass (#515), the release pipeline verifies what it publishes, and get_student_submission is new (#487).
v1.14.0 — A student-tools and correctness release, most of it contributed by @KKazuhaK. Read-only student tools for groups, grades and what-if scenarios, quizzes, calendar and a cross-course feed, plus Inbox messaging that is off unless the operator enables it (#465 to #476). Guarded body edits with read-back confirmation (#437), group and anonymous discussion reads (#433, #439; thanks @papatistos), complete full-content reads (#458) and shared course resolution (#457). Behavior change: assign_peer_review never posts a placeholder submission (#436). The suite runs on Windows in CI (#456).
v1.13.0 — A security release (GHSA-hmr8-mvr2-mvw5): tools that change anything exist only if the operator allows them. Breaking: HTTP servers are read-only unless ALLOWED_WRITE_TOOLS is set, send_conversation always previews first, get_conversation_details loses auto_mark_read, rubric grading stops when settings cannot be verified, and local file exports refuse HTTP callers. Also new: update_rubric for guarded edits of existing rubrics (#386) and update_syllabus, which previews before replacing existing content. Fixed: external-tool assignments such as Gradescope are no longer reported missing (#390, thanks @EastArctica), TypeScript pagination follows Link headers within a page budget (#403), and confirmation and grading workflows were hardened (#394 to #408). The execute_typescript sandbox now runs as a non-root user with a read-only root filesystem (#317, #339). Built on FastMCP 4 and MCP SDK 2 (#354).
v1.12.0 — A safety release: every delete tool asks first. Breaking: delete_announcement removed, dry_run removed from the announcement delete tools, confirmation_token required on all seven delete tools (#318), and Python 3.10 dropped (#315). Also new: delete_assignment_with_confirmation, ACCESSIBILITY_CHECKERS (#325), and the content migration tools (#309).
v1.11.0 — A protocol-correctness release. Breaking: send_peer_review_reminders is now send_peer_review_inbox_messages (#303); tool failures set MCP isError: true (#270); string-returning tools no longer duplicate their payload into structuredContent.result (#271); FastMCP floor 3.4.7 (#293). Thanks @jonespm
v1.10.0 — A community bug-fix release driven by live reporter testing — thanks @khagyard, @zqian, @jonespm, @bruchris, and @SHIL0018 (our second outside code contribution). Included a breaking search_canvas_tools response-shape change.
- Breaking:
search_canvas_toolsresponse shape v2 (#281). The tool now actually searches the ~99 registered MCP tools alongside the TypeScript code-API files (it previously searched only the latter, so "peer review" found nothing despite ~10 peer-review tools existing). Responses carryschema_version: 2with labeledmcp_tools/code_execution_apisections; the old flattoolskey is gone. Full-detail code-API content is now also capped at 2,000 characters (#287) - Students can find their peer reviews (#275):
get_my_peer_reviews_todogained a direct per-assignment lookup and a Planner-feed discovery path — the same data source Canvas's own student UI uses — validated against a real production payload from the reporter create_announcementfails safely on student tokens (#283): Canvas silently downgrades the create to a regular discussion topic; the tool now pre-checks course permissions and refuses before creating anything, auto-deletes the unintended topic if a downgrade still slips through, and steers AI clients away from posting the content via discussion tools as a fallback- Security: stricter URL validation (code-scanning fix), Docker base bumped to
python:3.14-slim, CI actions updated
v1.9.0 — Prompt-injection hardening (#239): Canvas-authored text arrives provenance-fenced as data-not-instructions; multi-recipient sends became two-step preview→confirm (breaking); write tools refuse fence markers; OSSF Scorecard published, CI actions SHA-pinned, .mcpb ships SLSA provenance; npm wizard retired (#249). Eleven adversarial review rounds pre-merge
v1.8.0 — Security-scan remediation: 11 of 12 findings fixed, three breaking (HTTPS-only Canvas URLs, stdio-only file transfer tools, no-overwrite downloads), a measured submissions authorization bypass closed centrally, CSV formula-injection protection, code execution fails closed, dependency floors raised (PR #251, #255)
v1.7.0 — Correctness release from instructor bug reports: writes no longer report success when Canvas quietly did less than asked (#219–#221), Planner-API upcoming assignments (#222), check_enrollment AMBIGUOUS answers (#199), wire-format fixes for pages/inbox (#207, #208), MCP-spec tool annotations (#204), CSV rubric format fix (#190), anonymization consolidated to the client layer (#179). Thanks @khagyard and @zqian
v1.6.0 — Tier 1 student write tools behind an explicit allowlist (#170), get_my_enrollments / get_my_profile (#171), three-tier anonymization (#166, #179), rubric association fixes (#180, #181), execute_typescript became opt-in (#178), ruff gating CI (@w3lld1, PR #186)
v1.5.0 — get_syllabus (#134), create_rubric_from_csv (#119), update_discussion_topic (#154), fastmcp 2.x migration (#145), dependency advisories cleared 33 → 0 with a gating CI scan (PR #156)
v1.4.0 — check_enrollment (PR #126), Claude Desktop Extension .mcpb, Entra ID authenticated institutional hosting (#115, PR #125), HTTP fails closed without auth gate (PR #123)
v1.3.0 — create_rubric (PR #100), read_course_file (@DomBarker99, PR #90), event-loop fix for user-scoped tools (PR #99), bulk-delete safety cap (PR #96), dependency pruning (PR #93)
v1.2.0 — Role-Based Tool Filtering (@Promithius-DR, PR #84), Accessibility Remediation (fix_accessibility_issues, scanner expanded 4→20 checks), Security Hardening (path traversal/symlink protections), Windows Support for execute_typescript (PR #85), CI consolidation (11→8 checks)
v1.1.0 — Hosted Server (mcp.illinihunt.org), Learning Designer tools + 3 skills, Agent Skills on skills.sh, File Management (@Metzpapa, PR #75), Token Optimization, Generic Distribution
v1.0.8 — Security Hardening (PII sanitization, audit logging, sandbox-by-default), Ruff linting, 235+ tests
v1.0.7 — Assignment Update Tool (update_assignment), complete CRUD, 9 tests
v1.0.6 — Module Management (7 tools), Page Settings (2 tools), 235+ tests
v1.0.5 — Claude Code Skills, GitHub Pages site
v1.0.4 — Code Execution API for token-efficient bulk operations, MCP 2.14 compliance
For Students 👨🎓
Get AI-powered assistance with:
- Tracking upcoming assignments and deadlines
- Monitoring your grades across all courses
- Managing peer review assignments
- Accessing course content and discussions
- Organizing your TODO list
For Educators 👨🏫
Enhance your teaching with:
- Assignment and grading management
- Student analytics and performance tracking
- Discussion and peer review facilitation
- Privacy controls designed to support FERPA-conscious workflows
- Bulk messaging and communication tools
For Learning Designers 🎨
AI-powered course design and quality assurance:
- Course scaffolding — Build entire course structures from specs, templates, or by cloning existing courses
- Quality audits — Pre-semester QC checks for structure, content, publishing, and completeness
- Accessibility review — 20-check WCAG-oriented scanner (headings, tables, scope, contrast, alt text, links, captions, DesignPLUS migration), prioritized reports, guided remediation, and verification
- Course structure analysis — Full module→items tree in a single call for rapid course review
3 dedicated skills (canvas-course-qc, canvas-accessibility-auditor, canvas-course-builder) plus the get_course_structure tool.
🤖 Agent Skills
Pre-built workflow recipes that teach AI agents how to use Canvas MCP tools effectively. Available for 40+ coding agents via skills.sh, or as Claude Code-specific slash commands.
Install via skills.sh (Any Agent)
Skills call the MCP tools, so install the server first; a skill without the server has nothing to run.
npx skills add vishalsachdev/canvas-mcp
This launches an interactive picker to install skills into your agent of choice (Claude Code, Cursor, Codex, OpenCode, Cline, Zed, and many more).
Install a specific skill:
npx skills add vishalsachdev/canvas-mcp -s canvas-week-plan
Claude Code Slash Commands
If you use Claude Code, the same workflows are also available as slash commands:
You: /canvas-morning-check CS 101
Claude: [Generates comprehensive course status report]
You: /canvas-week-plan
Claude: [Shows prioritized weekly assignment plan]
Claude Code skills are located in .claude/skills/ and can be customized for your workflow.
Want a custom skill? Submit a request describing your repetitive workflow!
🔒 Privacy & Data Protection
For Educators: FERPA-Conscious Data Handling
Canvas MCP provides optional privacy controls that can support an institution's FERPA obligations. Compliance still depends on your deployment, configuration, institutional policy, and AI provider:
- Response anonymization converts supported identity fields to consistent anonymous IDs (Student_xxxxxxxx)
- Email masking and supported PII-pattern filtering in discussion posts and submissions
- Local server deployment with configurable privacy controls (
ENABLE_DATA_ANONYMIZATION=true) - Privacy-conscious analytics: Ask "Which students need support?" while reducing the identity data returned to the AI client
- De-anonymization mapping tool for faculty to correlate anonymous IDs with real students locally
When ENABLE_DATA_ANONYMIZATION=true is enabled, supported identity fields are anonymized before tool results reach the AI client. Review the Educator Guide and your institution's requirements before using student data.
For Students: Data Scope & Privacy
- Canvas-scoped access: Student-specific tools use Canvas's "self" endpoints; shared course-content tools follow the permissions Canvas grants your account
- No shared-server credential storage: Local mode reads your Canvas token from your own
.env. In authenticated institutional HTTP deployments, each request supplies the user's Canvas token and the server does not store it. - No built-in product analytics: Canvas MCP does not add telemetry; Canvas and your AI client still apply their own logging and data policies
- Optional anonymization: Student tools are scoped to your own Canvas data, but your AI client's privacy policy still applies
Hosted Server (Retired)
The public hosted server (mcp.illinihunt.org) has been retired. A public MCP endpoint without an access gate isn't safe to operate — it would expose the built-in code-execution tool — so the supported path is local installation below.
The HTTP/streamable transport itself remains fully supported for self-hosting behind your own authentication (canvas-mcp-server --transport streamable-http). Running a shared, authenticated instance for your institution? See deploy/azure/ for a production-tested deployment specification (Azure App Service + Entra ID platform auth, per-user Canvas tokens) with sample workflow and config templates.
Prerequisites (Local Installation)
- Python 3.11+ - Required for modern features and type hints
- Canvas API Access - API token and institution URL
- MCP Client - An MCP-compatible client (Claude Desktop, Cursor, Zed, Windsurf, Continue, etc.); setup and capabilities vary by client
Supported MCP Clients
Canvas MCP is designed for MCP-compatible clients, including Claude Desktop, Codex, Cursor, Zed, Windsurf, Continue, Replit, and Copilot Studio. Setup details and supported capabilities vary by client.
Canvas MCP uses documented Canvas API patterns such as a User-Agent header and per_page pagination. It is intended for Canvas Cloud and compatible self-hosted instances.
Install as a Claude Desktop Extension (easiest)
If you use Claude Desktop, you can install Canvas MCP with one click — no terminal, no config-file editing:
- Download
canvas-mcp.mcpbfrom the latest release. - Double-click the file (or drag it into Claude Desktop → Settings → Extensions).
- When prompted, enter your Canvas API URL — this must include the
/api/v1path (e.g.https://canvas.youruniversity.edu/api/v1) — and your Canvas API token (Canvas → Account → Settings → New Access Token — some institutions issue these by request form instead, see below). The token is stored in your OS keychain.
The extension runs the server locally and calls Canvas with your own token, so requests use that token's Canvas permissions. Canvas and your AI client may retain their own activity records. The extension uses uv to select Python 3.13 and manage dependencies; uv downloads Python 3.13 on first launch if it is missing (internet access is required, and Python downloads must be allowed). You do not need to install Python separately or change your system's default Python. For other clients, or to run from source, use the manual setup below.
Windows troubleshooting: spawn uv ENOENT means Claude Desktop cannot find uv. Install uv, then fully quit and reopen Claude Desktop so it picks up the updated PATH. Older extension bundles can select Python 3.15 and fail while compiling cffi with a "Microsoft Visual C++ 14.0 or greater is required" error; explicitly select Python 3.13 with uv run --python 3.13 in a manual client configuration instead of installing a compiler. See issue #391. Existing released bundles do not acquire launcher changes until you install a release containing them.
Local Installation
1. Install Dependencies
# (Recommended) Use a dedicated virtualenv so the MCP binary is in a stable location
python3 -m venv .venv
. .venv/bin/activate
# Install the package editable
pip install -e .
2. Configure Environment
# Copy environment template
cp env.template .env
# Edit with your Canvas credentials
# Required: CANVAS_API_TOKEN, CANVAS_API_URL
Get your Canvas API token from: Canvas → Account → Settings → New Access Token
Some institutions gate token creation. Where self-service is disabled, the "New Access Token" button is missing or errors out, and tokens are issued through an IT request form instead. Check your institution's IT knowledge base before concluding that API access is unavailable to you.
University of Illinois Urbana-Champaign works this way for everyone — students and instructors alike. Request a token with the Canvas API Token Request form (NetID login required). Once it is approved:
- Go to Canvas → Account → Settings → Approved Integrations, find the new token, click Activate, and refresh the page.
- Retrieve the token value from the U of I Box link Technology Services sends you.
As of August 2026, all new Illinois tokens carry a 30-day expiration (an upstream Instructure requirement). Expiry is not monitored or announced, and expired tokens are removed without notice — request the replacement before the current one lapses. Full details: Answers KB 150325.
Students elsewhere: if you see "There is a limit to the number of access tokens you can create" or cannot find the token creation option, contact your institution's Canvas administrator or IT support department to request API access.
3. MCP Client Configuration
Canvas MCP is designed for MCP-compatible clients. Below are configuration examples for popular clients; exact setup and capabilities vary by client:
Configuration file location:
- macOS:
~/Library/Application Support/Claude/claude_desktop_config.json - Windows:
%APPDATA%\Claude\claude_desktop_config.json
Configuration:
{
"mcpServers": {
"canvas-api": {
"command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
}
}
}
Note: Use the absolute path to your virtualenv binary to avoid issues with shell-specific PATH entries (e.g., pyenv shims).
Codex can launch the server as a local stdio MCP server. Add this entry to ~/.codex/config.toml, replacing the example paths with absolute paths on your machine:
[mcp_servers.canvas-api]
command = "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
cwd = "/absolute/path/to/canvas-mcp"
Setting cwd to the repository lets the server find the .env file created above even when you start Codex elsewhere. Alternatively, register the command with the Codex CLI:
codex mcp add canvas-api -- /absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server
The CLI command does not set a persistent working directory. After running it, add the cwd line to the existing [mcp_servers.canvas-api] table in ~/.codex/config.toml; do not create a second table with the same name.
Run codex mcp list to verify the registration, then restart Codex. In the Codex TUI, /mcp shows the active server and its tools.
Configuration file location:
- macOS/Linux:
~/.cursor/mcp_config.json - Windows:
%USERPROFILE%\.cursor\mcp_config.json
Configuration:
{
"mcpServers": {
"canvas-api": {
"command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
}
}
}
Configuration: Add to Zed's settings.json (accessible via Settings menu)
{
"context_servers": {
"canvas-api": {
"command": {
"path": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server",
"args": []
}
}
}
}
Configuration file location:
- macOS:
~/Library/Application Support/Windsurf/mcp_config.json - Windows:
%APPDATA%\Windsurf\mcp_config.json
Configuration:
{
"mcpServers": {
"canvas-api": {
"command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
}
}
}
Configuration: Add to Continue's config.json (accessible via Continue settings)
{
"mcpServers": {
"canvas-api": {
"command": "/absolute/path/to/canvas-mcp/.venv/bin/canvas-mcp-server"
}
}
}
For other MCP-compatible clients, the general pattern is:
- Locate your client's MCP configuration file
- Add a server entry with:
- Server name:
canvas-api(or any name you prefer) - Command: Full path to
canvas-mcp-serverbinary - Optional args: Additional arguments if needed
- Server name:
Consult your client's MCP documentation for specific configuration format and file locations.
Windows users: Replace forward slashes with backslashes in paths (e.g.,
C:\Users\YourName\canvas-mcp\.venv\Scripts\canvas-mcp-server.exe)
Verification
Test your setup:
# Test Canvas API connection
canvas-mcp-server --test
# View configuration
canvas-mcp-server --config
# Start server (for manual testing)
canvas-mcp-server
Available Tools
The Canvas MCP Server provides a set of tools for interacting with the Canvas LMS API. These tools are organized into logical categories for better discoverability and maintainability.
Tool Categories
Student Tools (New!)
- Personal assignment tracking and deadline management
- Grade monitoring across all courses
- TODO list and peer review management
- Submission status tracking
Shared Tools (Both Students & Educators)
- Course Tools - List and manage courses, get detailed information, generate summaries with syllabus content
- Discussion & Announcement Tools - Manage discussions, announcements, and replies
- Page & Content Tools - Access pages, modules, and course content
Educator Tools
4. Assignment Tools - Handle assignments, submissions, and peer reviews with analytics
5. Rubric Tools - Create, safely update, and list rubrics; associate them with assignments; and grade submissions (including bulk_grade_submissions for efficient batch grading). update_rubric is a guarded full replacement: it preserves existing criterion/rating IDs, requires a preview and confirmation, and verifies the result. See rubric API behavior and grading caveats.
6. User & Enrollment Tools - Manage enrollments, users, and groups
7. Analytics Tools - View student analytics, assignment statistics, and progress tracking
8. Messaging Tools - Send messages and announcements to students
Developer Tools
9. Discovery Tools - Search registered MCP tools and code execution API operations with search_canvas_tools; list code execution modules with list_code_api_modules
10. Code Execution Tools - Execute TypeScript code with execute_typescript so bulk item processing can stay out of the model's context
📖 View Full Tool Documentation for detailed information about the available tools.
Code Execution API
For bulk operations (30+ items), Canvas MCP supports TypeScript code execution. Process bulk operations locally without loading every item into the model’s context.
Use search_canvas_tools to discover available operations, then execute_typescript to run them locally. The default sandbox applies time, memory, environment, and best-effort network controls, but it is not a complete security boundary; use stronger external isolation when untrusted code or strict egress control is required (see issue #157). Works on macOS, Linux, and Windows.
Bulk Grading Example
import { bulkGrade } from './canvas/grading/bulkGrade';
await bulkGrade({
courseIdentifier: "60366",
assignmentId: "123",
gradingFunction: (submission) => {
const notebook = submission.attachments?.find(f =>
f.filename.endsWith('.ipynb')
);
if (!notebook) return null;
return { points: 100, comment: "Great work!" };
}
});
Security Modes
See Bulk Grading Example for a detailed walkthrough.
Usage
MCP clients start the server automatically. Just ask naturally:
- "What's due this week?" / "Show my grades" / "What peer reviews do I need?"
- "Who hasn't submitted Assignment 3?" / "Send reminders to missing students"
Quick start guides: Student | Educator | Real-World Workflows | Troubleshooting
Documentation
- Tool Documentation — Reference for the available tools, including optional feature-gated tools
- Student Guide — Getting started as a student
- Educator Guide — FERPA considerations and educator workflows
- Bulk Grading Example — Batch grading walkthrough
- Development Guide — Architecture and contributing
Built on FastMCP with async httpx, pydantic validation, and python-dotenv configuration. Modern src/ layout with pyproject.toml, type hints across core paths, connection pooling, pagination, and rate limiting. An automated test suite and ruff + black support code quality.
Troubleshooting
If you encounter issues:
- Server Won't Start - Verify your Local Installation setup:
.envfile, virtual environment path, and dependencies - Authentication Errors - Check your Canvas API token validity and permissions
- Connection Issues - Verify Canvas API URL correctness and network access
- Debugging - Check your MCP client's console logs (e.g., Claude Desktop's developer console) or run server manually for error output
Security
Runtime security and privacy controls:
Optional anonymization for FERPA-conscious educator workflows: ENABLE_DATA_ANONYMIZATION=true. See Educator Guide for scope and configuration details.
Publishing
Published to PyPI, MCP Registry, and skills.sh (agent skills). Releases are automated via GitHub Actions — tag a version (git tag vX.Y.Z && git push origin vX.Y.Z) and CI handles the rest.
Related project: UIUC Course MCP
From Canvas MCP creator Vishal Sachdev, UIUC Course MCP brings public Illinois course search, descriptions and section schedules into your local AI assistant. It is read-only and requires no account or API key. Use it for course discovery, and Canvas MCP for supported workflows inside your Canvas courses. The servers have separate setups; no automatic account linking is built in.
Get started · Source and feature requests
Contributing
Contributions are welcome! Feel free to:
- Submit issues for bugs or feature requests
- Create pull requests with improvements
- Share your use cases and feedback
Contributors
Thanks to everyone who has contributed to Canvas MCP:
- @KKazuhaK — Student group, grade, quiz, calendar, feed and Inbox tools; Windows CI; course identifier resolver; complete full-content reads (#456 to #470)
- @bruchris — UTF-8 on every text read and write in the test suite (#445)
- @papatistos — Group-space discussions and anonymous discussion reads via GraphQL (#433, #439)
- @lindsay-cheng — Canvas
missingflag for overdue submissions (#423) - @EastArctica — External-tool assignments no longer reported missing (#390)
- @DomBarker99 —
read_course_filetool for remote MCP deployments (#90) - @Promithius-DR — Role-based tool filtering and tool annotations (#84)
- @Metzpapa — File download and listing tools (#75)
- @JCSnap — Student tool bug fixes (#72, #73)
License
This project is licensed under the MIT License - see the LICENSE file for details.
Created by Vishal Sachdev
