coob MCP Server

Learn how to connect AI agents to your coob workspace.

Connect your AI tools to coob using the Model Context Protocol (MCP), an open standard that lets AI assistants interact with your courses, steps, plugins, assignments, and bots.

coob MCP server

Base URL: https://editor.coob.app/mcp

The coob Editor hosts a Streamable HTTP MCP server that gives AI tools secure, authenticated access to your coob account. It works with Claude Code, Cursor, VS Code, ChatGPT, and other MCP-compatible clients.

What is coob MCP?

coob MCP is our hosted server that lets AI assistants read and write your coob data over MCP. Your client (e.g. Cursor) talks to the Editor MCP endpoint; the server validates your token and proxies requests to the coob API on your behalf.

flowchart LR
  subgraph Client["AI client"]
    Cursor["Cursor / Claude Code / etc."]
  end
  subgraph coob["coob"]
    MCP["MCP Server\neditor.coob.app/mcp"]
    API["coob API\napi.coob.app"]
  end
  Cursor -->|"JSON-RPC + SSE"| MCP
  MCP -->|"Bearer token"| API

Why use coob MCP?

Simple setup — Add the server URL; authentication is done automatically via OAuth when you first use a coob tool.
Full account access — AI can list and create courses, steps, components, plugins, manage assignments, and publish courses with Telegram bots.
Built for AI — Tools and resources are designed for LLM workflows (e.g. component templates, step types, assignment URLs).

What can you do with coob MCP?

Create and edit courses — Add courses, steps, and components; reorder steps and components.
Work with plugins — List plugins, get component templates, create custom plugins and attach them to courses.
Manage assignments — List assignments, open them in the editor via editor_assignment_url, approve or reject with feedback.
Publish courses — Attach Telegram bots and publish courses so students can access them via the bot.
Call the API — Use the coob_api_request tool for advanced /v1 and /v2 calls when needed.

Architecture

High-level flow: the AI client connects to the Coob MCP server; the server keeps a session per token and forwards tool calls to the Coob API.

sequenceDiagram
  participant Client as AI Client
  participant MCP as Coob MCP Server
  participant API as Coob API

  Client->>MCP: POST /mcp (initialize + Bearer token)
  MCP->>API: GET /v1/users/current
  API-->>MCP: user
  MCP-->>Client: session established (MCP-Session-Id)

  loop Tool calls
    Client->>MCP: POST /mcp (JSON-RPC: tools/call)
    MCP->>API: Request with Bearer token
    API-->>MCP: Response
    MCP-->>Client: Tool result
  end

  Client->>MCP: GET /mcp (SSE) or POST (further RPC)
  Note over Client,MCP: Same session ID for all requests

Session and transport

Sessions are created on the first request that includes an initialize JSON-RPC message and a valid Bearer token. After that, the client uses the same MCP-Session-Id for all requests (Streamable HTTP or SSE).

stateDiagram-v2
  [*] --> NoSession: No MCP-Session-Id
  NoSession --> SessionCreated: POST /mcp with initialize + token
  SessionCreated --> SessionCreated: POST/GET with MCP-Session-Id
  SessionCreated --> [*]: DELETE /mcp or transport close

Authentication flow (OAuth)

For clients that support OAuth (e.g. "Connect to Coob" button), the flow uses the standard authorization code grant with PKCE.

sequenceDiagram
  participant User
  participant Client as AI Client
  participant MCP as Coob MCP Server
  participant Editor as Coob Editor (login)

  Client->>MCP: GET /.well-known/oauth-authorization-server
  MCP-->>Client: authorization_endpoint, token_endpoint

  Client->>User: Open authorization URL
  User->>Editor: Login / allow (get access token)
  Editor->>MCP: Redirect with ?code=... (or user pastes token)
  MCP->>MCP: Store code or complete with token

  Client->>MCP: POST /mcp/auth/token (code + code_verifier)
  MCP-->>Client: access_token
  Client->>MCP: POST /mcp (initialize, Bearer token)
  MCP-->>Client: Session ready

Authentication

Coob MCP uses OAuth (authorization code + PKCE). When you add the server URL and use a Coob tool for the first time, your client opens the OAuth flow; after you sign in and allow access, the client receives a token and uses it for the session. You do not need to paste API keys or Bearer tokens in the configuration.

Token validation — The server validates the token against Coob and binds it to the MCP session.
Session binding — One token per session; changing the token for the same MCP-Session-Id is rejected.

For step-by-step setup per client (Cursor, Claude Code, VS Code, etc.), see Connecting to Coob MCP.

Tools overview

The server exposes tools for courses, steps, components, plugins, bots, assignments, and direct API access. Key groups:

Area	Examples
User	`coob_current_user`
Courses	`coob_list_courses`, `coob_get_course`, `coob_create_course`
Steps	`coob_list_course_steps`, `coob_create_step`, `coob_update_step`, `coob_reorder_steps`
Components	`coob_get_step_components`, `coob_create_component`, `coob_update_component`, `coob_delete_component`
Plugins	`coob_list_plugins`, `coob_list_plugin_component_templates`, `coob_get_plugin_component_template`, `coob_create_plugin`, `coob_add_plugin_to_course`
Bots & publish	`coob_list_bots`, `coob_list_available_bots`, `coob_create_bot`, `coob_publish_course`
Assignments	`coob_list_assignments`, `coob_get_assignment`, `coob_approve_assignment`, `coob_reject_assignment`
Advanced	`coob_api_request` (for `/v1` and `/v2` paths)

Resources (read-only) include:

coob://editor/mcp-guide — Full MCP and tool usage guide for LLMs.
coob://editor/tool-index — Machine-readable list of tools and hints.
coob://editor/component-template-guide — How to build input_data for components.
coob://editor/plugin-creation-guide — Custom plugin creation (state, edit, view, handler, $_bx API).

MCP Server