Skip to main content
Glama

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 spec

Step-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 200

Step 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

⚠️ .env is gitignored — it will never be committed.

  1. Start the dashboard:

    source .venv/bin/activate
    frappe-lms-dashboard
  2. Open http://localhost:8080/login in your browser

  3. Fill in: Name (e.g. "Local LMS"), Frappe URL, Site, Username, Password

  4. Click "Connect" — the dashboard logs in to Frappe, generates API keys if possible, and stores them in SQLite

  5. 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 env block 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. Use which 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-dashboard

Open http://localhost:8080 in your browser.

Page

URL

Purpose

Dashboard

http://localhost:8080/

Overview: active connection, recent courses

Login

http://localhost:8080/login

Add a new Frappe connection

Connections

http://localhost:8080/connections

Manage multiple Frappe instances

Courses

http://localhost:8080/courses

Browse cached courses

Import

http://localhost:8080/courses/import

Import course from Frappe to cache

Logs

http://localhost:8080/logs

Audit trail of all operations

To disable the dashboard (MCP-only mode):

export FRAPPE_LMS_NO_DASHBOARD=1

To change the dashboard port:

export FRAPPE_LMS_DASHBOARD_PORT=9090

Authentication

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> header

  • Generated 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():

  1. Active SQLite connection with API key/secret → token auth

  2. Active SQLite connection with password → session auth (auto-login)

  3. Environment variables (FRAPPE_USERNAME/FRAPPE_PASSWORD) → session auth

  4. Error if no credentials found


Available Tools (39)

Courses

Tool

Description

list_courses

List courses (optionally published only)

get_course

Get course details + chapter/lesson outline

create_course

Create a new course

update_course

Update course fields

delete_course

Delete a course and all dependencies

publish_course

Toggle published status

Chapters

Tool

Description

create_chapter

Create a chapter in a course

get_chapter

Get chapter with its lessons

update_chapter

Rename a chapter

delete_chapter

Delete chapter + lessons

reorder_chapter

Move chapter to new position

Lessons

Tool

Description

create_lesson

Create a lesson with content

get_lesson

Get lesson content and metadata

update_lesson

Update lesson fields

delete_lesson

Delete a lesson

move_lesson

Move/reorder lesson between chapters

build_lesson_content

Build EditorJS JSON from a spec

add_paragraph_to_content

Append paragraph to content

Quizzes & Questions

Tool

Description

create_question

Create a reusable question

create_quiz

Create a quiz with questions

add_question_to_quiz

Add question to existing quiz

get_quiz

Get quiz with question details

list_quizzes

List all quizzes

delete_quiz

Delete a quiz

embed_quiz_in_lesson

Embed quiz in lesson content

Enrollments

Tool

Description

enroll_student

Enroll a student in a course

list_enrollments

List enrollments (filter by course/student)

unenroll_student

Remove an enrollment

Batches & Certificates

Tool

Description

create_batch

Create a batch (cohort)

list_batches

List batches

issue_certificate

Issue a certificate to a member

High-level

Tool

Description

create_full_course

Create an entire course from a JSON spec (auto-caches to SQLite)

Connections & Cache (SQLite)

Tool

Description

list_connections

List all saved Frappe connections (secrets masked)

switch_connection

Activate a different Frappe instance

list_cached_courses

List courses from SQLite cache (fast, no Frappe query)

get_cached_course

Get full cached course including spec JSON

reupload_course

Re-upload a cached course spec to a Frappe instance

import_course_from_frappe

Fetch a course from Frappe and cache it to SQLite

list_operation_logs

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_URL

http://localhost:8000

Frappe base URL

FRAPPE_SITE

lms.localhost

Frappe site name

FRAPPE_USERNAME

(none)

Login username/email

FRAPPE_PASSWORD

(none)

Login password

FRAPPE_API_KEY

(none)

API key for token auth (alternative to password)

FRAPPE_API_SECRET

(none)

API secret for token auth

FRAPPE_LMS_NO_DASHBOARD

(unset)

Set to 1 to disable the web dashboard

FRAPPE_LMS_DASHBOARD_PORT

8080

Port for the web dashboard

FRAPPE_LMS_DB_PATH

data/frappe_lms.db

SQLite database file path

FRAPPE_LMS_SESSION_SECRET

(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
pytest

Security Notes

  • Credentials live in .env (gitignored) or SQLite (in data/, 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.db contains 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 tools
add_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

    B3.3/5.0

    Scored across 39 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count3/5

    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.

    Completeness4/5

    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

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      MCP 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.
      337
      AGPL 3.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP 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