# notetaker-mcp

An MCP server that lets Claude fetch transcripts from your enrolled
[learn.deeplearning.ai](https://learn.deeplearning.ai) short courses so it can
summarize them and hand the notes off to another tool (Notion, Obsidian, a
file — via a second MCP server or a follow-up Claude action).

**Status:** working v1. Personal use, unofficial, not affiliated with
DeepLearning.AI.

## Tools it exposes

| Tool                    | What it does |
| ---                     | --- |
| `list_enrolled_courses` | Every course you're enrolled in; specializations flattened into their child courses. |
| `list_lessons`          | Lessons for one course, grouped by module in playback order. |
| `get_lesson_transcript` | Full transcript for one video lesson (`plain` or `timestamped` format). |
| `get_lesson_frame`      | Screenshot a single video frame at a chosen timestamp (`low`/360p by default, `high`/full HD optional). Optional `save_path` writes JPEG to disk. Requires ffmpeg. |
| `get_lesson_slides`     | Auto-detect scene changes and return one still per slide. Optional `save_dir` writes JPEGs to disk with absolute paths in the response. `min_gap_seconds` dedupes near-duplicates. `include_images=false` returns just timestamps + paths for building a chapter index cheaply. Requires ffmpeg. |

Claude does the summarizing. A separate MCP (e.g. the official Notion MCP)
does the note-saving. This server intentionally does one thing: get transcript
data out of deeplearning.ai.

## How auth works

1. **One-time**: `notetaker-mcp login` opens your real installed Chrome
   (isolated profile, no shared cookies) at
   `learn.deeplearning.ai/login`. You sign in with Google (or whatever you
   use). Playwright saves the browser session (cookies + localStorage) to
   `~/.notetaker-mcp/session.json` with 0600 perms via atomic replace.
2. **Every call after that**: the server loads that session and hits the same
   internal tRPC endpoints the deeplearning.ai frontend uses. Silent, no
   browser window.
3. **When the session expires** (typically weeks): tools raise a clear
   `Session expired. Run: notetaker-mcp login` error. Re-run the login
   command; the persistent Chrome profile means Google won't re-challenge you.

No password ever touches disk — only the session cookies.

## Requirements

- macOS or Linux (Windows probably fine, untested).
- Python 3.10+ (uv will fetch its own if you don't have one).
- Google Chrome installed. Google's OAuth flow refuses Playwright's bundled
  Chromium, so we drive the real Chrome instead.
- [`uv`](https://docs.astral.sh/uv/): `brew install uv`.
- **ffmpeg** — needed for `get_lesson_frame` and `get_lesson_slides` only.
  Install with `brew install ffmpeg`. The transcript tools work without it.

## Install

```bash
git clone https://github.com/sibtihaj/notetaker-mcp.git
cd notetaker-mcp
uv sync
uv run playwright install chromium
```

The Chromium install is only used as a fallback if Chrome isn't found.

## Sign in

```bash
uv run notetaker-mcp login
```

A Chrome window opens. Sign in, wait for your dashboard to load, then press
Enter in the terminal. You should see `Saved session (N deeplearning.ai
cookies)` where N is around 20.

If Google somehow still blocks you, wipe the profile and try again:

```bash
uv run notetaker-mcp reset-profile
uv run notetaker-mcp login
```

## Wire it into Claude Code

From an interactive Claude Code terminal session:

```bash
claude mcp add notetaker -- uv --directory /Users/syedhaque/Desktop/personal-notetaker-MCP run notetaker-mcp serve
```

Adjust the absolute path if you cloned somewhere else. Confirm it's registered:

```bash
claude mcp list
```

Then in Claude:

> List my enrolled deeplearning.ai courses.
>
> Show me the lessons for Agentic AI.
>
> Get the transcript for the "Welcome!" lesson and summarize it as 5 bullet
> takeaways. Save the summary as a new page in my Notion "Course Notes" DB.

The last step uses whichever Notion MCP you have installed. This server has no
dependency on Notion — it only produces transcripts.

## Running the server directly

Rarely useful outside Claude Code, but handy for debugging:

```bash
uv run notetaker-mcp serve
```

Speaks MCP JSON-RPC over stdio. Send it an `initialize` message + `tools/list`
to smoke test.

## Reverse-engineering notes

If deeplearning.ai changes their API and something breaks, the endpoint
reference and the probe scripts used to discover them are in
[`docs/api-notes.md`](docs/api-notes.md) and [`scripts/`](scripts/). Re-run
`uv run python scripts/probe.py <course-url>` against your session to see
what endpoints are actually being called now.

## Caveats

- **Unofficial scraper.** If deeplearning.ai reworks their platform, tools will
  break until updated. Fine for personal use; do not distribute or run at scale.
- **Short courses only** (`learn.deeplearning.ai`). Coursera-hosted
  specializations are a different backend and are not supported.
- **Session file is sensitive.** It's equivalent to your logged-in cookies.
  Protect it the same way.

## License

MIT