New · Dometrain Pro exclusive

Your coding agent, grounded in real courses.

The Dometrain MCP server plugs into Claude Code, Codex, GitHub Copilot, or OpenCode and gives your agent the entire video catalog as a knowledge source: it searches the lessons, reads the code shown on screen, and implements things the way the course teaches them, citing the exact moment so you can watch the source.

Create your API key See the one-line setup

Included with Dometrain Pro: mcp.dometrain.com, works with any MCP-capable agent.

how it works

Two minutes from key to grounded agent.

01 / KEY

Create an API key

Mint a dmt_live_… key on your dashboard’s MCP page. It’s shown exactly once, and you can hold up to five (one per machine or agent) and revoke any of them instantly.

02 / CONNECT

Add the server to your agent

One command or a few lines of config (snippets below). The key rides along as a Bearer token: no OAuth dance, nothing to install or run locally.

03 / BUILD

Ask like you always do

The server ships instructions that teach your agent when to reach for it: before implementing, designing, or debugging anything a course covers, it searches Dometrain first and cites the lesson it grounded on.

the tools

Six tools. The whole catalog.

Your agent gets a small, sharp toolset: search first, read deep, cite the source. Every result carries a ?t= deep link back to the lesson.

search_dometrain

Search every lesson

Ranked full-text search across the whole catalog. Each hit returns a snippet, the lesson and course, and a deep link to the exact second the topic is taught.

search_code

Search the course code

Searches the code taught in the videos, transcribed from the frames and grounded against the course source repos, and returns fenced snippets with language filters and timestamped links.

get_lesson

Read the full lesson

Pulls the complete lesson document: summary, key concepts, the cleaned narrative, and every code block placed in context. Everything your agent needs to apply the pattern.

get_course

Walk a course

The overview plus the full chapter and lesson tree of any course, so the agent can follow a topic through the curriculum instead of guessing at structure.

list_courses

Explore the catalog

Lists what Dometrain covers, filterable by topic, so the agent can check coverage before committing to an approach.

get_usage

Check the meter

Used, remaining, and the reset date for your monthly quota, so the agent can pace itself instead of running into the limit.

not just transcripts

Lessons rebuilt for agents, including the code on screen.

Raw subtitles make poor context. Every video lesson is pre-processed into an MCP-optimized document before your agent ever sees it.

transcript

Cleaned narrative

The spoken lecture becomes a structured document: a summary, the key concepts, and the explanation rewritten for reading, not the “um, as you can see here” of a raw caption file.

frames + repos

The real course code

The code an author types on screen never appears in subtitles, so we transcribe it from the video frames and cross-check it against the course’s actual source: the lesson downloads and the course GitHub repos. The accurate, complete version lands in the document as fenced, searchable blocks.

?t=seconds

Deep links to the moment

Every code block and search hit links to the exact second of the lesson. When your agent grounds a decision in a course, you’re one click from watching the author explain it.

Read-only by design. The server only serves course content. It never sees your codebase, runs nothing on your machine, and exercise solutions stay in the courses. Your agent sends short search queries and lesson ids; that’s the whole exchange.

setup

Pick your agent. Paste one snippet.

Streamable HTTP with a Bearer key: any MCP-capable client works. There’s also a Claude Code plugin that bundles the server with a grounding skill.

Run in your terminal (replace YOUR_KEY with your API key):

claude mcp add --scope user --transport http dometrain https://mcp.dometrain.com/mcp \
  --header "Authorization: Bearer YOUR_KEY"

Keys live in Dashboard → MCP. Create up to 5, revoke anytime. Full installation guide on GitHub.

access & limits

One plan. Honest limits.

The MCP server is included with Dometrain Pro: no separate tier, no per-seat pricing, no metered billing. Just a monthly allowance.

5,000tool calls / month

Per account, and all of your keys share the one pool. Only tools/call requests count; connecting and listing tools is always free.

30calls / minute burst

A light fair-use cap so a runaway agent loop can’t drain your month in one sitting. Normal agent sessions never touch it.

1stof each month, UTC

The allowance resets on the first of the month. Hitting the limit returns a clear message with the reset date, and a rejected call is never counted against you.

Track usage live from the meter on your dashboard’s MCP page or let your agent call get_usage; it’s even nudged automatically when it gets close to the limit.

Requires Dometrain Pro

An active Dometrain Pro subscription unlocks the server (trials and individual course purchases don’t include it). Pro also gets you the full course catalog, the in-course AI Agent’s biggest allowance, and everything else in Pro.

Get Dometrain Pro

questions

Frequently asked

Do I need Dometrain Pro?

Yes. The server checks for an active Dometrain Pro subscription on every request. Trials and individual course purchases don’t unlock it. If your subscription lapses, your keys keep existing but requests are rejected until you’re Pro again.

Which coding agents does it work with?

Anything that speaks MCP over streamable HTTP with custom headers. We document Claude Code, Codex, GitHub Copilot, and OpenCode, and there’s a Claude Code plugin on GitHub. If your tool of choice supports remote MCP servers with a Bearer token, it works.

What content does the agent get?

Every published video lesson in the catalog, pre-baked into an agent-friendly document: summary, key concepts, cleaned narrative, and the code, transcribed from the video frames and grounded against the lesson downloads and course GitHub repos, each with a deep link to the exact second. Hands-On exercises, quizzes, and their solutions are deliberately not included.

What counts against my 5,000 monthly calls?

Only actual tool calls (search_dometrain, get_lesson, and friends). Connecting, handshakes, and listing tools are free, and a call rejected for quota reasons isn’t counted. All of your keys draw from the same pool, and the meter resets on the 1st of each month (UTC).

Can it see my code?

No. The server is read-only course content: your agent sends short search queries and lesson ids and gets documents back. Your codebase never leaves your machine through this server, and there’s nothing to execute. It’s just knowledge.

What if a key leaks?

Revoke it on your dashboard’s MCP page; revocation is immediate. Keys are shown once at creation and stored hashed on our side, and you can keep separate keys per machine so revoking one doesn’t touch the others.

How fresh is the content?

Lesson documents are regenerated as courses are released and updated; the processing pipeline re-bakes anything whose source changed. New courses show up in search_dometrain shortly after they ship.

ready when you are

Stop letting your agent guess.

Give it the courses. One key, one snippet, and every implementation it writes can cite the lesson it came from.

Create your API key Get Dometrain Pro

included with pro · 5,000 calls / month · works with any mcp agent