Tech Professor / Docs
Open app

MCP server

Let your coding agent turn the change it just shipped into a tour and a quiz, so you and your team still have to earn the understanding.

What it does

The Tech Professor MCP server lets an AI client save, read, and update your artifacts (quizzes, walkthroughs, flashcards, playgrounds, exams, syllabi, and showcases) through the hosted API. Your client authors the content; the server persists it to your library. The agent helps you teach and test understanding; it does not replace it. Prefer the hosted HTTP endpoint below; it is the full tool surface. The local npx @techprofessor/mcp package may lag on newer course/folder tools and is mainly useful for filesystem push_artifacts.

Unlike the in-app generation wizard, the MCP server does not run any AI. That means no provider key is needed and there is no serverless time limit, so it handles large sources and playgrounds comfortably.

The tools

The flow is the same for every artifact type: get the schema, author the artifact in your client, push it, then read it back and edit in place. Tools group into authoring, library organization, and courses:

Authoring

  • get_artifact_schema: return the exact package shape (with an example) for a type so an authored artifact validates on the first upload. Every example includes audience and level.
  • push_artifact: create one artifact you authored, or full-replace an existing one. Always set audience (technical | non-technical) and level (easy | intermediate | advanced | mixed): ask if unspecified; if the user skips, use technical + mixed. Returns a web_link. Pass session_id (from list_artifacts) to rewrite a known artifact in place, including empty UI/generate tours. source_ref upserts only prior ingest/MCP packages that own that key.
  • push_artifacts: bulk-create from JSON files in a directory or single file (defaults to .techprof). Available on the local npx package only.
  • list_artifacts: list your artifacts (owner-scoped). Filter with type, team_id, repo_id, q (title substring), or source_ref; optional limit (default 50).
  • get_artifact: fetch one artifact in full, including every item with its id.
  • update_artifact: edit title, description, audience, level, and/or specific items by id.

Repos & spaces

  • list_repos: discover repos you own or share via team membership (repo_id for attach / course association).
  • list_teams: team spaces and their team_id (target for pushes).
  • list_folders · create_folder · rename_folder · move_artifact: organize artifacts within a repo. Nest folders with parent_id; pass folder_id: null to move_artifact to unfile an artifact.

Courses

  • list_courses · create_course · get_course: discover, create, and inspect courses (containers of existing artifacts, not an artifact type themselves).
  • update_course: change title, description, and/or status (active | archived).
  • add_course_item: add an existing artifact by session_id (optional section, note, sort_order). Does not create content; push the piece first.
  • remove_course_item: remove a step by its course item_id (from get_course, not the session id).
  • reorder_course_items: pass ordered_item_ids as the full permutation of item ids from get_course.

Everything is owner-scoped (you only ever see or edit artifacts you own), and the read tools are free to call while your client figures out what to push.

For agent skills (Cursor, Claude Code, Codex) that call these tools during planning, see the Skills installer guide.

Before you start

You need exactly one thing: a personal API token so the server can act as you. No provider key is required.

Where to find your API token

Tokens are created in the app under Settings → Developer & MCP (AI provider keys live in a different Settings section and are not used by the MCP server). To create one:

  1. Open the app and sign in.
  2. Click your profile menu (bottom of the sidebar) and choose Settings.
  3. Open the Developer & MCP section. (Direct link: /app/settings?section=developer.)
  4. Under New token, type a name (e.g. my-laptop) and click Create.
  5. The token appears once, looking like tp_pat_…. Copy it immediately; only a hash is stored, so it cannot be shown again.
The Developer & MCP section also shows a ready-made claude mcp add-json command and HTTP config block. Once you have a token, copy that instead of assembling it by hand.

Creating a token needs a Write seat. Read-only seats can still list and revoke existing tokens. Revoke any token from the same section if it is exposed.

Configure your client

The easiest path is the hosted HTTP MCP at https://tech-professor.com/api/mcp: no local Node install, no npx. Authenticate with your tp_pat_… token in an Authorization: Bearer header (same pattern as GitHub Copilot's remote MCP).

Claude Code (recommended)

One command, identical in shape to adding any other remote MCP:

claude mcp add-json techprofessor '{"type":"http","url":"https://tech-professor.com/api/mcp","headers":{"Authorization":"Bearer tp_pat_xxx"}}'

Or with the transport flag:

claude mcp add --transport http techprofessor https://tech-professor.com/api/mcp \
  --header "Authorization: Bearer tp_pat_xxx"

Add -s user to register it for every project; omit it to add only the current one.

Cursor

Add this entry to .cursor/mcp.json (or use MCP: Add Server… → HTTP):

{
  "mcpServers": {
    "techprofessor": {
      "type": "http",
      "url": "https://tech-professor.com/api/mcp",
      "headers": {
        "Authorization": "Bearer tp_pat_xxx"
      }
    }
  }
}

Claude Desktop

Paste the same HTTP JSON block as Cursor into claude_desktop_config.json (the headers.Authorization field is required; a URL-only Custom Connector has nowhere to put the Bearer token).

{
  "mcpServers": {
    "techprofessor": {
      "type": "http",
      "url": "https://tech-professor.com/api/mcp",
      "headers": {
        "Authorization": "Bearer tp_pat_xxx"
      }
    }
  }
}

Local stdio package (optional)

Prefer HTTP for day-to-day use. The published @techprofessor/mcp package is still useful when you need filesystem push_artifacts (bulk upload from a directory):

claude mcp add techprofessor -s user \
  -e TECHPROF_API_TOKEN=tp_pat_xxx \
  -- npx -y @techprofessor/mcp
claude mcp add-json techprofessor '{"type":"stdio","command":"npx","args":["-y","@techprofessor/mcp"],"env":{"TECHPROF_API_TOKEN":"tp_pat_xxx"}}'

TECHPROF_BASE_URL defaults to https://tech-professor.com; set it only for a custom deployment.

Treat the token like a password. A tp_pat_… token acts as you on every /api/* route that accepts a signed-in user, so keep it out of shared configs and version control. Revoke it from Settings → Developer & MCP if it is exposed.

The authoring flow

Because the server does not generate, your client drives the whole loop:

  1. Get the schema. get_artifact_schema({ type }) returns the exact package shape for quiz, tour, flashcards, playground, exam, syllabus, or showcase.
  2. Author it. Your model writes the package JSON (one artifact per package), including audience and level.
  3. Push it. push_artifact({ artifact, repo_id?, team_id?, session_id? }) saves it and returns a web_link. Use repo_id (from list_repos) to attach it to a repo, or team_id (from list_teams) to save it to a team space. To rewrite an existing artifact, pass its session_id from list_artifacts.
  4. Read & edit. list_artifacts → find a session_id, get_artifact → fetch every item with its id, update_artifact → change the title/description and/or specific items by id (patch only; empty Tour groups need push_artifact with session_id).
  5. Organize (optional). create_folder / move_artifact for repo folders; create_course then add_course_item to sequence finished pieces.

session_id is the canonical artifact id for full replace. source_ref upserts only packages previously created via ingest/MCP that own that key, not UI/generate-created sessions (those keep source_ref on the session only).