Frappe LMS MCP Server
Integrates with Frappe LMS to allow AI agents to manage courses, chapters, lessons, quizzes, enrollments, batches, and certificates. Supports course creation, caching, and re-upload across multiple instances.
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., "@Frappe LMS MCP Server create a new course called 'Web Development Basics'"
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.
Frappe LMS MCP Server
An MCP (Model Context Protocol) server that lets AI agents manage a Frappe LMS instance — create courses, chapters, lessons, quizzes, enrollments, batches, and certificates.
Designed for instructors and admins who want to build comprehensive course content using AI.
Features
39 MCP tools for managing Frappe LMS (courses, chapters, lessons, quizzes, enrollments, batches, certificates)
Web dashboard (FastAPI + Jinja2) on port 8080 for browser-based login and course browsing
SQLite database for connection storage, course caching, and audit logging
Dual authentication — API key/secret (token auth) or password (session auth fallback)
Course memory — auto-cache course specs on creation for cross-instance re-upload
Multi-instance — store multiple Frappe connections, switch between them
Audit trail — all operations logged to SQLite
Related MCP server: Moodle MCP Server
Architecture
┌─────────────────────────────────────┐
│ MCP Server Process (Python) │
│ │
AI Agent ────────►│ FastMCP (stdio) FastAPI (:8080) │
(ZCode, Claude, │ │ │ │
Codex, etc.) │ ▼ ▼ │
│ tools.py ◄──── Web Dashboard │
│ │ (login UI, │
│ │ course browser) │
│ ▼ │
│ client.py ◄── API Key/Secret │
│ │ (from SQLite) │
│ ▼ │
│ SQLite (frappe_lms.db) │
│ - connections: api_key, password │
│ - courses: id, title, spec_json │
│ - operations: audit log │
└───────┬─────────────────────────────┘
│
▼
Frappe LMS (localhost:8000)Project Structure
lms-mcp-tools/
├── pyproject.toml # Package config, deps, entry points
├── README.md
├── .env.example # Template credentials (safe to commit)
├── .gitignore
├── src/frappe_lms_mcp/
│ ├── __init__.py
│ ├── client.py # FrappeClient — REST API wrapper (dual auth)
│ ├── content_blocks.py # EditorJS block builders
│ ├── db.py # SQLite schema + CRUD (connections, cache, logs)
│ ├── dashboard.py # FastAPI web dashboard (login, courses, logs)
│ ├── dashboard_cli.py # Standalone dashboard entry point
│ ├── tools.py # Tool implementations (business logic)
│ ├── server.py # FastMCP server — registers 39 tools + dual-start
│ └── templates/ # Jinja2 HTML templates (8 pages)
├── skill/
│ └── SKILL.md # Skill definition for AI agents
└── examples/
└── web-development-course.json # Example course specStep-by-Step Setup
Prerequisites
Python 3.10+ (tested on 3.11)
Frappe LMS running and reachable (e.g. via Docker on
http://localhost:8000)A Frappe user with Course Creator or Moderator role
Step 1 — Clone & Install
git clone https://github.com/anggun-indra/frape-lms-mcp-tools.git
cd frape-lms-mcp-tools
# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate
# Install the package (editable mode)
pip install -e .Step 2 — Start Frappe LMS
Make sure your Frappe LMS instance is running. If using Docker:
cd path/to/your/frappe-docker
docker compose up -d
# Wait for Frappe to be ready
curl http://localhost:8000 # should return HTTP 200Step 3 — Configure Credentials
Choose one method:
Method A — .env file (simplest)
cp .env.example .env
# Edit .env with your real credentials.env contents:
FRAPPE_URL=http://localhost:8000
FRAPPE_SITE=lms.localhost
FRAPPE_USERNAME=your_email@example.com
FRAPPE_PASSWORD=your_password⚠️
.envis gitignored — it will never be committed.
Method B — Web Dashboard (recommended — no password in config)
Start the dashboard:
source .venv/bin/activate frappe-lms-dashboardOpen
http://localhost:8080/loginin your browserFill in: Name (e.g. "Local LMS"), Frappe URL, Site, Username, Password
Click "Connect" — the dashboard logs in to Frappe, generates API keys if possible, and stores them in SQLite
The MCP server now uses these credentials automatically — no env vars needed
Method C — Shell environment variables
# ~/.zshrc or ~/.bashrc
export FRAPPE_URL="http://localhost:8000"
export FRAPPE_SITE="lms.localhost"
export FRAPPE_USERNAME="your_email@example.com"
export FRAPPE_PASSWORD="your_password"Step 4 — Verify the Installation
source .venv/bin/activate
# Verify the MCP server starts and lists all tools
python -c "
from frappe_lms_mcp.server import mcp
import asyncio
tools = asyncio.run(mcp.list_tools())
print(f'{len(tools)} tools registered')
"You should see: 39 tools registered
Step 5 — Register with Your AI Agent
The MCP server communicates over stdio (standard MCP transport). Every MCP-compatible agent can use it — the only difference is the config file location and key name.
ZCode
Config file: .zcode/config.json (workspace scope) or ~/.zcode/config.json (user scope)
{
"mcp": {
"servers": {
"frappe-lms": {
"command": "/absolute/path/to/frape-lms-mcp-tools/.venv/bin/frappe-lms-mcp",
"env": {
"FRAPPE_URL": "http://localhost:8000",
"FRAPPE_SITE": "lms.localhost",
"FRAPPE_USERNAME": "your_email@example.com",
"FRAPPE_PASSWORD": "your_password"
}
}
}
}
}If you configured credentials via the dashboard (Method B), you can omit the
envblock entirely — the server reads from SQLite.
Claude Desktop
Config file: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
"mcpServers": {
"frappe-lms": {
"command": "/absolute/path/to/frape-lms-mcp-tools/.venv/bin/frappe-lms-mcp",
"env": {
"FRAPPE_URL": "http://localhost:8000",
"FRAPPE_SITE": "lms.localhost",
"FRAPPE_USERNAME": "your_email@example.com",
"FRAPPE_PASSWORD": "your_password"
}
}
}
}After saving, restart Claude Desktop. The tools will appear as mcp__frappe-lms__<tool_name>.
OpenAI Codex (GPT Codex)
Config file: ~/.codex/config.toml or project-level codex.toml
[mcp_servers.frappe_lms]
command = "/absolute/path/to/frape-lms-mcp-tools/.venv/bin/frappe-lms-mcp"
env = { FRAPPE_URL = "http://localhost:8000", FRAPPE_SITE = "lms.localhost", FRAPPE_USERNAME = "your_email@example.com", FRAPPE_PASSWORD = "your_password" }Or if using Codex CLI with JSON config (~/.codex/config.json):
{
"mcpServers": {
"frappe_lms": {
"command": "/absolute/path/to/frape-lms-mcp-tools/.venv/bin/frappe-lms-mcp",
"env": {
"FRAPPE_URL": "http://localhost:8000",
"FRAPPE_SITE": "lms.localhost",
"FRAPPE_USERNAME": "your_email@example.com",
"FRAPPE_PASSWORD": "your_password"
}
}
}
}Claude Code (CLI)
Config file: ~/.claude/claude_config.json or .claude/config.json (project scope)
{
"mcpServers": {
"frappe-lms": {
"command": "/absolute/path/to/frape-lms-mcp-tools/.venv/bin/frappe-lms-mcp",
"env": {
"FRAPPE_URL": "http://localhost:8000",
"FRAPPE_SITE": "lms.localhost",
"FRAPPE_USERNAME": "your_email@example.com",
"FRAPPE_PASSWORD": "your_password"
}
}
}
}Generic MCP Client (any MCP-compatible tool)
The server uses the standard MCP stdio transport. Any tool that supports MCP can connect. The minimal config is:
Command: /absolute/path/to/frape-lms-mcp-tools/.venv/bin/frappe-lms-mcp
Transport: stdio
Environment variables (optional if using dashboard auth):
FRAPPE_URL=http://localhost:8000
FRAPPE_SITE=lms.localhost
FRAPPE_USERNAME=your_email@example.com
FRAPPE_PASSWORD=your_password💡 Tip: Replace
/absolute/path/to/with the actual path on your machine. Usewhich frappe-lms-mcp(inside the venv) to find it.
Step 6 — Use It!
Once registered, ask your AI agent to manage courses. Examples:
"Create a Python programming course with 3 chapters: Basics, Data Structures, and OOP. Each chapter should have 2 lessons with content and a quiz."
The agent will use create_full_course with a generated JSON spec. The course is automatically cached to SQLite for future re-upload.
"List all cached courses and re-upload course ID 1 to the active connection"
The agent uses list_cached_courses and reupload_course — no need to re-specify course details.
See examples/web-development-course.json for a complete course spec example.
Running the Dashboard
The dashboard runs automatically alongside the MCP server (in a background thread on port 8080). To run it standalone:
source .venv/bin/activate
frappe-lms-dashboardOpen http://localhost:8080 in your browser.
Page | URL | Purpose |
Dashboard |
| Overview: active connection, recent courses |
Login |
| Add a new Frappe connection |
Connections |
| Manage multiple Frappe instances |
Courses |
| Browse cached courses |
Import |
| Import course from Frappe to cache |
Logs |
| Audit trail of all operations |
To disable the dashboard (MCP-only mode):
export FRAPPE_LMS_NO_DASHBOARD=1To change the dashboard port:
export FRAPPE_LMS_DASHBOARD_PORT=9090Authentication
The server supports two authentication methods, tried in this order:
1. Token Auth (API Key/Secret) — preferred
No login needed — each request sends
Authorization: token <key>:<secret>headerGenerated via the dashboard login flow (requires System Manager role)
Stored in SQLite
2. Session Auth (Password) — fallback
Used when the user doesn't have System Manager role (can't generate API keys)
The server logs in with username/password and maintains a session cookie
Password stored in SQLite (encrypted at rest by Frappe, but stored plaintext locally)
Auth Priority in get_client():
Active SQLite connection with API key/secret → token auth
Active SQLite connection with password → session auth (auto-login)
Environment variables (
FRAPPE_USERNAME/FRAPPE_PASSWORD) → session authError if no credentials found
Available Tools (39)
Courses
Tool | Description |
| List courses (optionally published only) |
| Get course details + chapter/lesson outline |
| Create a new course |
| Update course fields |
| Delete a course and all dependencies |
| Toggle published status |
Chapters
Tool | Description |
| Create a chapter in a course |
| Get chapter with its lessons |
| Rename a chapter |
| Delete chapter + lessons |
| Move chapter to new position |
Lessons
Tool | Description |
| Create a lesson with content |
| Get lesson content and metadata |
| Update lesson fields |
| Delete a lesson |
| Move/reorder lesson between chapters |
| Build EditorJS JSON from a spec |
| Append paragraph to content |
Quizzes & Questions
Tool | Description |
| Create a reusable question |
| Create a quiz with questions |
| Add question to existing quiz |
| Get quiz with question details |
| List all quizzes |
| Delete a quiz |
| Embed quiz in lesson content |
Enrollments
Tool | Description |
| Enroll a student in a course |
| List enrollments (filter by course/student) |
| Remove an enrollment |
Batches & Certificates
Tool | Description |
| Create a batch (cohort) |
| List batches |
| Issue a certificate to a member |
High-level
Tool | Description |
| Create an entire course from a JSON spec (auto-caches to SQLite) |
Connections & Cache (SQLite)
Tool | Description |
| List all saved Frappe connections (secrets masked) |
| Activate a different Frappe instance |
| List courses from SQLite cache (fast, no Frappe query) |
| Get full cached course including spec JSON |
| Re-upload a cached course spec to a Frappe instance |
| Fetch a course from Frappe and cache it to SQLite |
| View audit trail of all operations |
Lesson Content Format
Lessons use EditorJS JSON for rich content. The build_lesson_content tool accepts a spec with these optional keys:
{
"paragraphs": ["Plain text paragraphs"],
"headers": [{"text": "Section Title", "level": 2}],
"lists": [{"items": ["item 1", "item 2"], "ordered": true}],
"images": [{"url": "/files/image.png", "caption": "A diagram"}],
"code": [{"code": "print('hello')", "language": "python"}],
"embeds": [{"service": "youtube", "source": "https://youtube.com/watch?v=..."}],
"quiz_refs": ["quiz-slug-name"],
"markdown": ["## Raw markdown section"]
}Environment Variables
Variable | Default | Description |
|
| Frappe base URL |
|
| Frappe site name |
| (none) | Login username/email |
| (none) | Login password |
| (none) | API key for token auth (alternative to password) |
| (none) | API secret for token auth |
| (unset) | Set to |
|
| Port for the web dashboard |
|
| SQLite database file path |
| (random) | Secret key for dashboard session cookies |
Development
# Install in dev mode
pip install -e ".[dev]"
# Run the server directly (with dashboard)
python -m frappe_lms_mcp.server
# Run dashboard only (no MCP)
frappe-lms-dashboard
# Run tests
pytestSecurity Notes
Credentials live in
.env(gitignored) or SQLite (indata/, also gitignored) — never committed..env.example(committed) contains only placeholder values — safe to share.The MCP server inherits the permissions of the configured Frappe user. For production, create a dedicated Frappe user with only the LMS roles needed (Course Creator, Moderator) rather than using Administrator.
The SQLite database at
data/frappe_lms.dbcontains API keys and passwords — it is gitignored. If you need to share the project, delete this file first.API key generation requires the System Manager role. Users without this role fall back to session auth (password stored in SQLite).
License
MIT
Available Tools
39 toolsadd_paragraph_to_contentA
Append a paragraph to an existing EditorJS content string.
Args: existing_content: Current EditorJS JSON string (can be empty). text: Paragraph text to append.
Returns: Updated EditorJS JSON string.
Inputs: text (required), existing_content (required). Returns: result
add_question_to_quizB
Add an existing question to a quiz.
Args: quiz: The quiz name (slug). question: The LMS Question name. marks: Marks for this question.
Inputs: quiz (required), question (required), marks. Returns: result
build_lesson_contentA
Build an EditorJS JSON content string for a lesson from a spec.
Args: content_spec: JSON string with optional keys: paragraphs, headers, lists, images, code, embeds, quiz_refs, markdown. Example: '{"paragraphs":["Hello world"],"headers":[{"text":"Intro","level":2}]}'
Returns: EditorJS JSON string ready for the content field of a Course Lesson.
Inputs: content_spec (required). Returns: result
create_batchA
Create an LMS Batch (cohort).
Args: title: Batch title. start_date: Start date (YYYY-MM-DD). end_date: End date (YYYY-MM-DD). start_time: Start time (HH:MM:SS). end_time: End time (HH:MM:SS). timezone: Timezone, e.g. "Asia/Jakarta". description: Short description. batch_details: Full HTML details. instructor: Instructor User email/ID. courses: JSON list of course names to include, e.g. '["course-1","course-2"]'. published: Whether the batch is published. allow_self_enrollment: Allow students to self-enroll. seat_count: Number of seats (0 = unlimited). medium: "Online" or "Offline". paid_batch: Whether this is a paid batch. amount: Price amount (required if paid_batch). currency: Currency code (required if paid_batch). category: Category name.
Inputs: title (required), end_date (required), end_time (required), timezone (required), +14 more. Returns: result
create_chapterA
Create a chapter in a course.
Args: course: The course name (slug). title: Chapter title.
Inputs: title (required), course (required). Returns: result
create_courseB
Create a new LMS Course. A URL slug is auto-generated from the title.
Args: title: Course title (required). short_introduction: One-line summary shown on course cards (required). description: Full HTML description. instructor: Email/User ID of the instructor. tags: Comma-separated tags, e.g. "Python, Web, Beginner". category: Category name (must exist in LMS Category doctype). image: Path to preview image. video_link: YouTube video ID or embed URL. published: Publish immediately. featured: Mark as featured. upcoming: Mark as upcoming. card_gradient: Card colour (Red/Blue/Green/Amber/Cyan/Orange/Pink/Purple/Teal/Violet/Yellow/Gray). disable_self_learning: Students can only learn via batches. paid_course: Whether this is a paid course. course_price: Price (required if paid_course). currency: Currency code (required if paid_course), e.g. "USD" or "IDR". enable_certification: Enable completion certificate. paid_certificate: Certificate requires payment.
Inputs: title (required), short_introduction (required), tags, image, +14 more. Returns: result
create_full_courseA
Create a complete course with chapters, lessons, and quizzes from a single JSON spec.
This is the primary tool for building comprehensive courses in one call.
Args: spec: JSON string with the full course definition. Structure: { "title": "...", "short_introduction": "...", "description": "...", "instructor": "email", "tags": "a,b", "category": "...", "published": false, "chapters": [ { "title": "Chapter 1", "lessons": [ { "title": "Lesson 1", "content": { "paragraphs": ["text..."], "headers": [{"text": "Section", "level": 2}], "lists": [{"items": ["a","b"], "ordered": false}], "code": [{"code": "print(1)", "language": "python"}], "embeds": [{"service": "youtube", "source": "url"}] } }, { "title": "Quiz Lesson", "content": {"paragraphs": ["Test your knowledge"]}, "quiz": { "title": "Quiz 1", "passing_percentage": 70, "questions": [ {"question": "text", "type": "Choices", "options": [{"text":"Yes","correct":false},{"text":"No","correct":true}]} ] } } ] } ] }
Returns: JSON with course name, chapter names, lesson names, and quiz names.
Inputs: spec (required). Returns: result
create_lessonA
Create a lesson in a chapter.
Args: chapter: The chapter name. title: Lesson title. content: EditorJS JSON string for the lesson body. Use build_lesson_content to construct it.
Inputs: title (required), chapter (required), content. Returns: result
create_questionA
Create a reusable LMS Question.
Args: question: The question text (HTML allowed). question_type: "Choices", "User Input", or "Open Ended". options: JSON list for Choices type: [{"text":"Yes","correct":false,"explanation":"..."},...]. possibilities: JSON list of strings for User Input type: ["answer1","answer2"].
Inputs: question (required), options, possibilities, question_type. Returns: result
create_quizA
Create an LMS Quiz with optional questions.
Args: title: Quiz title (slug auto-generated). passing_percentage: Minimum percentage to pass (0-100). questions: JSON list of [{"question":"","marks":5}]. max_attempts: Max attempts (0 = unlimited). show_answers: Show correct answers after submission. duration: Time limit in minutes (as string). shuffle_questions: Randomise question order. enable_negative_marking: Deduct marks for wrong answers. marks_to_cut: Marks to deduct per wrong answer.
Inputs: title (required), duration, questions, marks_to_cut, +5 more. Returns: result
delete_chapterB
Delete a chapter and all its lessons.
Args: chapter: The chapter name.
Inputs: chapter (required). Returns: result
delete_courseA
Delete a course and all its chapters, lessons, and enrollments.
Args: course: The course name (slug).
Inputs: course (required). Returns: result
delete_lessonC
Delete a lesson and remove it from the chapter.
Args: lesson: The lesson name. chapter: The chapter name.
Inputs: lesson (required), chapter (required). Returns: result
delete_quizB
Delete a quiz.
Args: quiz: The quiz name (slug).
Inputs: quiz (required). Returns: result
embed_quiz_in_lessonB
Embed a quiz into a lesson's content as an EditorJS quiz block.
Args: lesson: The lesson name. quiz: The quiz name (slug).
Inputs: quiz (required), lesson (required). Returns: result
enroll_studentA
Enroll a student in a course.
Args: course: The course name (slug). student: The User email/ID of the student. member_type: "Student", "Mentor", or "Staff".
Inputs: course (required), student (required), member_type. Returns: result
get_cached_courseA
Get full details of a cached course, including its JSON spec. The spec_json field contains the full create_full_course spec that can be re-uploaded to any Frappe instance. Args: course_id: The cache ID (from list_cached_courses).
Inputs: course_id (required). Returns: result
get_chapterB
Get a chapter with its lessons.
Args: chapter: The chapter name.
Inputs: chapter (required). Returns: result
get_courseA
Get full details of a course including its chapter/lesson outline.
Args: course: The course name (slug) or title.
Inputs: course (required). Returns: result
get_lessonC
Get a lesson with its content and metadata.
Args: lesson: The lesson name.
Inputs: lesson (required). Returns: result
get_quizA
Get a quiz, optionally with full question details.
Args: quiz: The quiz name (slug). with_questions: If True, fetch full question text and options.
Inputs: quiz (required), with_questions. Returns: result
import_course_from_frappeA
Import a course from the active Frappe connection into the local cache. Fetches the course outline and stores its metadata in SQLite for quick lookup. Args: course_slug: The Frappe course name (slug).
Inputs: course_slug (required). Returns: result
issue_certificateA
Manually issue a certificate to a member for a course.
Args: course: The course name (slug). member: The User email/ID. template: The Print Format name for the certificate template. issue_date: Issue date (YYYY-MM-DD). Empty = today. expiry_date: Expiry date (YYYY-MM-DD). Empty = no expiry.
Inputs: course (required), member (required), template (required), issue_date, +1 more. Returns: result
list_batchesC
List LMS batches.
Inputs: limit. Returns: result
list_cached_coursesA
List courses cached in the local SQLite database. These are courses previously created or imported. Use this to find a course by ID for re-upload without querying Frappe. Args: connection_name: Filter by connection name. Empty = all connections.
Inputs: connection_name. Returns: result
list_connectionsA
List all saved Frappe LMS connections from the local database. The active connection is shown first. API secrets are masked. Use this to see which Frappe instances are configured and which is active.
Inputs: no named parameters. Returns: result
list_coursesB
List LMS courses. Set published_only=True to see only published courses.
Inputs: limit, published_only. Returns: result
list_enrollmentsA
List enrollments, optionally filtered by course or student.
Args: course: Filter by course name (empty = all). student: Filter by student User email/ID (empty = all). limit: Maximum results.
Inputs: limit, course, student. Returns: result
list_operation_logsA
List recent operations from the audit log (most recent first). Shows create, delete, reupload, and import operations across all connections. Args: limit: Maximum number of entries to return.
Inputs: limit. Returns: result
list_quizzesC
List all quizzes.
Inputs: limit. Returns: result
move_lessonA
Move a lesson to a different chapter or reorder within the same chapter.
Args: lesson: The lesson name. source_chapter: Current chapter. target_chapter: Destination chapter (same as source to reorder). idx: New 0-based position.
Inputs: idx (required), lesson (required), source_chapter (required), target_chapter (required). Returns: result
publish_courseA
Toggle the published status of a course.
Args: course: The course name (slug). published: True to publish, False to unpublish.
Inputs: course (required), published. Returns: result
reorder_chapterA
Move a chapter to a new position in the course outline.
Args: course: The course name (slug). chapter: The chapter name. idx: New 0-based position.
Inputs: idx (required), course (required), chapter (required). Returns: result
reupload_courseA
Re-upload a cached course to a Frappe LMS instance. Uses the stored JSON spec to recreate the course on the specified (or active) connection. Useful for migrating courses between Frappe instances. Args: course_id: The cache ID of the course to re-upload. connection_name: Target connection name. Empty = active connection.
Inputs: course_id (required), connection_name. Returns: result
switch_connectionA
Switch the active Frappe LMS connection by name. After switching, all subsequent MCP tool calls use the new connection's credentials. Args: name: The connection name (label) to activate.
Inputs: name (required). Returns: result
unenroll_studentB
Remove a student's enrollment.
Args: enrollment: The enrollment name.
Inputs: enrollment (required). Returns: result
update_chapterA
Update a chapter title.
Args: chapter: The chapter name. title: New chapter title.
Inputs: title (required), chapter (required). Returns: result
update_courseA
Update fields on an existing course.
Args: course: The course name (slug). fields: JSON string of fields to update, e.g. '{"title":"New Title","published":true}'.
Inputs: course (required), fields (required). Returns: result
update_lessonA
Update a lesson's fields. Pass empty strings for fields you don't want to change.
Args: lesson: The lesson name. title: New lesson title (empty = no change). content: EditorJS JSON string (empty = no change). youtube: YouTube video URL (empty = no change). include_in_preview: Whether this lesson is visible in the course preview. instructor_notes: Markdown instructor notes (empty = no change).
Inputs: lesson (required), title, content, youtube, +2 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 39 tools
Most tools have clear, distinct purposes (courses, chapters, lessons, quizzes, enrollments, batches, connections). However, overlap exists between cached vs live course tools (list_cached_courses vs list_courses) and content-building utilities (build_lesson_content vs add_paragraph_to_content), which could cause minor confusion.
Tool names generally follow a verb_noun pattern (e.g., create_course, list_quizzes). There are some deviations like embed_quiz_in_lesson and reupload_course, and mix of 'get' vs 'list' for retrieval, but overall pattern is recognizable and predictable.
39 tools is high for an MCP server, covering many LMS operations plus caching and connection management. While the domain is broad, some tools like add_paragraph_to_content and list_operation_logs feel like utilities that could be integrated or removed, making the set slightly bloated.
The tool surface covers CRUD for courses, chapters, lessons, quizzes, enrollments, and batches. Missing are updates for quizzes and questions (e.g., no update_quiz or delete_question), which are minor gaps. Caching and import/export features add extra completeness for migration scenarios.
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
MCP server for agentverse documentation, generated by doc2mcp.
Related MCP Servers
- AlicenseBqualityDmaintenanceAn MCP server that enables LLMs to interact with Moodle platforms to manage courses, students, assignments, and quizzes through natural language commands.745MIT
- AlicenseBqualityDmaintenanceAn MCP server that enables LLMs to interact with the Moodle platform to manage courses, students, assignments, and quizzes.7MIT
- AlicenseNot gradedqualityAmaintenanceMCP server that enables LLMs to interact with ERPNext/Frappe sites for document CRUD, search, reports, workflows, and analytics, respecting user permissions and logging all actions.337AGPL 3.0
- AlicenseNot gradedqualityDmaintenanceMCP server that enables Claude, ChatGPT, and other LLMs to interact with ERPNext sites through natural language, supporting document CRUD, search, reports, workflows, and custom tools, while respecting user permissions and logging all calls.AGPL 3.0