dataflowr
OfficialFetches course materials including notebooks, slides, quizzes, and website content from the dataflowr/notebooks, dataflowr/slides, dataflowr/quiz, and dataflowr/website GitHub repositories.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@dataflowr list modules with GPU requirements"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
dataflowr — CLI, API & MCP server for the Deep Learning DIY course
The Deep Learning DIY course teaches PyTorch from scratch — tensors, autodiff, CNNs, RNNs, Transformers, VAEs, and diffusion models — through hands-on notebooks. Course resources:
dataflowr/notebooks — all practical notebooks (PyTorch fundamentals → diffusion models)
dataflowr/gpu_llm_flash-attention — implement FlashAttention-2 from scratch using Triton
dataflowr/llm_controlled-generation — structured generation, meta-generation, and self-correction for LLMs
dataflowr/llm_efficiency - KV Cache and LoRA for minGPT
dataflowr/transcripts — 318 concept notes extracted from lecture transcripts, with timestamped quotes and cross-references
This package exposes the course as a CLI, REST API, and MCP server so AI agents can navigate and teach it.

Quick start with Claude Code
Option 1 — Hosted server (no install needed): add a .mcp.json file at the root of your project pointing to the shared instance:
{
"mcpServers": {
"dataflowr": {
"type": "http",
"url": "https://dataflowr.paris.inria.fr/mcp"
}
}
}Option 2 — Local server: run it yourself with uv (downloads on first use):
{
"mcpServers": {
"dataflowr": {
"type": "stdio",
"command": "uv",
"args": ["run", "--with", "dataflowr[mcp]", "python", "-m", "dataflowr.mcp_server"]
}
}
}Claude Code picks this up automatically when you open the folder.
To pre-approve all dataflowr tools (no per-call prompts), also add .claude/settings.json:
{
"permissions": {
"allow": ["mcp__dataflowr"]
}
}For a global allow (all projects), add the same to ~/.claude/settings.json.
Related MCP server: just-study
Install
# with uv (recommended)
uv pip install dataflowr # CLI only
uv pip install dataflowr[api] # CLI + REST API
uv pip install dataflowr[mcp] # CLI + MCP server
uv pip install dataflowr[all] # everything
# with pip
pip install dataflowr
pip install dataflowr[mcp]Or from source:
git clone https://github.com/dataflowr/dataflowr-tools
cd dataflowr-tools
uv pip install -e ".[all]"CLI
# Course overview
dataflowr info
# List all modules
dataflowr modules list
# Filter by session, tag, or GPU requirement
dataflowr modules list --session 7
dataflowr modules list --tag attention
dataflowr modules list --gpu
# Full module details (with notebook links)
dataflowr module 12
# Fetch notebook content from GitHub
dataflowr notebook 12 # practical (default)
dataflowr notebook 12 --kind intro
dataflowr notebook 12 --no-code # markdown only
# Fetch course website page text (raw markdown from dataflowr/website)
dataflowr page 12
# Fetch lecture slides (from dataflowr/slides)
dataflowr slides 12
# Fetch quiz questions (from dataflowr/quiz)
dataflowr quiz 2a
dataflowr quiz 3
# Browse transcript knowledge base (318 concept notes from lectures)
dataflowr transcripts search "backprop"
dataflowr transcripts get "training loop"
# Compare catalog against website + slides repos
dataflowr sync
# Search by keyword
dataflowr search "attention transformer"
dataflowr search "generative"
# Sessions
dataflowr sessions list
dataflowr sessions get 7
# Homeworks
dataflowr homeworks list
dataflowr homeworks get 1
# JSON output (pipe-friendly)
dataflowr modules list --json | jq '.[] | select(.session == 9)'
dataflowr module 18b --jsonREST API
uvicorn dataflowr.api:app --reload
# → http://localhost:8000
# → http://localhost:8000/docs (Swagger UI)Endpoints:
Method | Path | Description |
GET |
| Course overview |
GET |
| List all modules ( |
GET |
| Get module by ID |
GET |
| Get notebooks for a module ( |
GET |
| Fetch notebook cells from GitHub ( |
GET |
| Fetch lecture slide content from dataflowr/slides |
GET |
| Fetch quiz questions from dataflowr/quiz |
GET |
| Fetch module source markdown from dataflowr/website |
GET |
| Compare catalog against website + slides repos |
GET |
| List all sessions |
GET |
| Get session with modules |
GET |
| List all homeworks |
GET |
| Get homework by ID |
GET |
| Search modules |
GET |
| Search transcript concept notes |
GET |
| Get a transcript concept note |
Examples:
curl http://localhost:8000/modules/12
curl http://localhost:8000/sessions/7
curl http://localhost:8000/search?q=diffusion
curl "http://localhost:8000/modules?session=9&gpu=true"
curl "http://localhost:8000/modules?tag=attention"
curl "http://localhost:8000/modules/12/notebooks/practical/content?include_code=false"
curl http://localhost:8000/modules/12/page
curl http://localhost:8000/modules/2a/quiz
curl http://localhost:8000/modules/3/quiz
curl "http://localhost:8000/transcripts/search?q=backprop"
curl http://localhost:8000/transcripts/training%20loopMCP Server (for AI agents)
Makes the course natively available to Claude, Cursor, VS Code, and other MCP-compatible agents. Built on the official MCP Python SDK (FastMCP).
Stdio transport (local — Claude Desktop, Cursor, VS Code, Claude Code)
python -m dataflowr.mcp_serverHTTP transport (remote / shared deployments)
python -m dataflowr.mcp_server --http
# → POST http://localhost:8001/mcp (or $PORT if set)Client configuration
Claude Code (VSCode extension or CLI)
Add a .mcp.json file at the root of your project (homework repo, notebook folder, etc.):
{
"mcpServers": {
"dataflowr": {
"type": "stdio",
"command": "uv",
"args": ["run", "--with", "dataflowr[mcp]", "python", "-m", "dataflowr.mcp_server"]
}
}
}Claude Code picks this up automatically when you open the folder. No global install needed — uv downloads dataflowr[mcp] on first use.
To pre-approve all dataflowr tools (no per-call prompts), also add .claude/settings.json:
{
"permissions": {
"allow": ["mcp__dataflowr"]
}
}Or register globally (available in every project):
claude mcp add --scope user dataflowr -- uv run --with dataflowr[mcp] python -m dataflowr.mcp_serverClaude Desktop
Edit ~/.claude/claude_desktop_config.json (macOS/Linux) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"dataflowr": {
"command": "python",
"args": ["-m", "dataflowr.mcp_server"]
}
}
}With uv (no global install needed):
{
"mcpServers": {
"dataflowr": {
"command": "uv",
"args": ["run", "--with", "dataflowr[mcp]", "python", "-m", "dataflowr.mcp_server"]
}
}
}Cursor
Edit .cursor/mcp.json at the root of your project (or ~/.cursor/mcp.json globally):
{
"mcpServers": {
"dataflowr": {
"command": "python",
"args": ["-m", "dataflowr.mcp_server"]
}
}
}VS Code
Edit .vscode/mcp.json at the root of your project:
{
"servers": {
"dataflowr": {
"type": "stdio",
"command": "python",
"args": ["-m", "dataflowr.mcp_server"]
}
}
}Remote / HTTP (self-hosted)
If running your own instance with --http, point clients at the URL:
{
"mcpServers": {
"dataflowr": {
"type": "http",
"url": "http://localhost:8001/mcp"
}
}
}Recommended workflow
1. search_modules "attention" → find relevant modules by keyword
2. get_module "12" → full details, notebook links, prerequisites
3. get_page_content "12" → read the lecture notes
4. get_notebook_content "12" → work through the exercises
5. get_quiz_content "12" → self-test your understanding
6. search_transcripts "attention" → find concept notes from lecture transcripts
7. get_transcript_note "training loop" → read timestamped quotes and cross-referencesFor a personalised study plan, use the learning_path prompt with a target module.
Tools exposed to the agent
Tool | Description |
| List modules, filterable by session / tag / GPU |
| Full details for a module |
| Keyword search across titles, descriptions, and tags |
| List all sessions |
| Session + all module content |
| GitHub/Colab links for a notebook |
| All homeworks |
| Full details for a homework |
| Fetch lecture slides from dataflowr/slides |
| Fetch quiz questions from dataflowr/quiz |
| Validate a student's quiz answer |
| Fetch actual notebook cells from GitHub |
| Fetch only exercise prompts + skeleton code |
| Fetch module source markdown from dataflowr/website |
| Full course structure as context |
| Prerequisite modules for a given module |
| What to study after completing a module |
| Compare catalog against website + slides repos |
| Fuzzy search 318 concept notes from lecture transcripts |
| Fetch full content of a transcript concept note |
Prompts exposed to the agent
Prompt | Arguments | Description |
|
| Tutoring session — Socratic explanation of a module |
|
| Interactive quiz, one question at a time |
|
| Guided debugging help for a practical notebook |
|
| Personalised prerequisite chain to a target module |
Example questions
Once connected, an agent can answer questions like:
"What should I study before tackling diffusion models?"
"Give me the Colab link for the microGPT notebook."
"Which session covers attention mechanisms?"
"What are all the generative modeling modules?"
"Show me the Flash Attention homework tasks."
"Quiz me on Module 3 — loss functions."
"I'm stuck on the backprop exercise in Module 2b. Help me debug it."
"Build me a learning path to Module 18b (diffusion models) starting from scratch."
"What does the professor say about the training loop? Show me the transcript quotes."
Python API
from dataflowr import COURSE
# Get a module
module = COURSE.get_module("12")
print(module.title) # "Attention and Transformers"
print(module.description)
print(module.notebooks)
# Search
results = COURSE.search("attention")
# Get a session
modules = COURSE.get_session_modules(7)
# Navigate the full catalog
for module in COURSE.modules.values():
if module.requires_gpu:
print(f"Module {module.id}: {module.title}")Design principles
Content only, no execution. The package exposes the course structure and links. Running notebooks stays in the student's hands.
Agent-friendly. All outputs are text-first. The MCP server renders markdown so agents can use it directly in responses.
No external dependencies for core. The catalog, models, and CLI work with only
pydantic,typer, andrich. The API needsfastapi; the MCP server needsmcp.Single source of truth.
catalog.pyis the only place that needs updating when the course evolves.
Available Tools
18 toolscheck_quiz_answerA
Check whether a student's answer to a quiz question is correct.
Returns: correct (bool), the right answer with its text, and an explanation. Call get_quiz_content first to see the questions and choices, then use this tool to validate the student's response. question_number and answer_number are 1-based.
Inputs: module_id (required), answer_number (required), question_number (required). Returns: result
get_course_overviewA
Get a complete overview of the dataflowr course: all sessions, modules, and their relationships.
Use this to understand the full structure or to give a student a learning path.
Inputs: no named parameters. Returns: result
get_homeworkA
Get full details for a specific homework, including description, website URL, and notebook links.
Inputs: hw_id (required). Returns: result
get_moduleA
Get full details for a specific module.
Includes description, notebooks with GitHub and Colab links, tags, and prerequisites. Use this when a student asks about a specific topic or module. Module IDs: '12' (Attention/Transformers), '2a' (PyTorch tensors), '18b' (diffusion), etc.
Inputs: module_id (required). Returns: result
get_notebook_contentA
Fetch the actual content of a course notebook from GitHub.
Returns markdown explanations and (optionally) code cells. Use this when a student wants to understand what a notebook covers, needs help with an exercise, or asks about specific code. kind: 'intro' | 'practical' | 'solution' | 'bonus' | 'homework' (default: practical) include_code: set False for explanations only (default: True)
Inputs: module_id (required), kind, include_code. Returns: result
get_notebook_exercisesA
Fetch only the exercise cells from a module's notebook.
Returns the exercise prompt (markdown) and the skeleton code the student must fill in. Skips all expository text, imports, and solution code. Prefer this over get_notebook_content when helping a student with an exercise — it gives the task without spoiling surrounding context. kind: 'intro' | 'practical' | 'solution' | 'bonus' | 'homework' (default: practical)
Inputs: module_id (required), kind. Returns: result
get_notebook_urlB
Get the GitHub and Colab URL for a specific notebook.
Use this when a student wants to open or run a specific exercise. kind: 'intro' | 'practical' | 'solution' | 'bonus' | 'homework' (default: practical)
Inputs: module_id (required), kind. Returns: result
get_page_contentA
Fetch the text content of the course website page for a module.
Returns the lecture notes, explanations, and learning objectives as plain text. Use this for conceptual questions about a topic.
Inputs: module_id (required). Returns: result
get_prerequisitesA
Get the prerequisite modules for a given module, with full details for each.
Use this when a student asks 'what should I know before studying X?' or seems to be missing background knowledge.
Inputs: module_id (required). Returns: result
get_quiz_contentA
Fetch the quiz questions for a module from the dataflowr/quiz GitHub repo.
Returns multiple-choice questions with choices, correct answers, and explanations. Use this when a student wants to self-test their understanding of a module. Modules with quizzes: '2a' (tensors), '2b' (autograd), '3' (loss functions).
Inputs: module_id (required). Returns: result
get_sessionA
Get full details for a session, including all its modules, notebooks, and key takeaways.
Use this when a student wants to understand what a session covers.
Inputs: session_number (required). Returns: result
get_slide_contentA
Fetch the lecture slide content for a module from the dataflowr/slides GitHub repo.
Returns the slide text (Remark.js markdown, cleaned). Use this when a student wants to review lecture slides or study the theory for a module.
Inputs: module_id (required). Returns: result
list_homeworksA
List all graded homeworks with descriptions and notebook links.
Inputs: no named parameters. Returns: result
list_modulesA
List all modules in the dataflowr Deep Learning DIY course.
Can be filtered by session number, tag, or GPU requirement. Returns module IDs, titles, descriptions, and tags.
Inputs: tag, session, gpu_only. Returns: result
list_sessionsA
List all course sessions with their titles and module IDs.
Sessions group modules into ~2-3 hour teaching blocks.
Inputs: no named parameters. Returns: result
search_modulesA
Search modules by keyword across titles, descriptions, and tags.
Use this to find relevant modules for a student's question or topic. E.g. query='attention' finds the Transformer module; 'generative' finds GANs, autoencoders, flows, diffusion.
Inputs: query (required). Returns: result
suggest_nextA
Suggest what to study after completing a given module.
Returns: (1) modules that directly list this one as a prerequisite, (2) the next modules in the same session, and (3) the start of the next session. Use this when a student finishes a module and asks 'what should I do next?'
Inputs: module_id (required). Returns: result
sync_catalogA
Compare the local catalog against the dataflowr/website, /slides, and /quiz GitHub repos.
Lists modules/slides present in the repos but missing from the catalog, and catalog entries that have no corresponding source file.
Inputs: no named parameters. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Each tool has a clearly distinct purpose: overview, listing, detailed retrieval, search, navigation, quiz checking, and admin. Even similar tools like get_notebook_content, get_notebook_exercises, and get_notebook_url are differentiated by description.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., get_course_overview, list_modules, search_modules). No mixed naming conventions are present.
18 tools is slightly above the typical 3-15 range, but each tool earns its place given the comprehensive course coverage (modules, sessions, homework, quizzes, notebooks, slides, search, suggestions, catalog sync).
The tool set covers the full lifecycle of content access and navigation for a course: listing, retrieval, search, prerequisites, quiz checking, and catalog maintenance. Missing functionality (e.g., progress tracking) is outside the server's stated scope.
Maintenance
Related MCP Connectors
Open-source AI courses taught by your AI tutor in conversation, with progress saved by MCP tools.
Your AI agent builds interactive block-based courses over MCP; take them at learnwithagents.app.
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
Read-only MCP tools for AI agent discovery, structured resources, and NIULAI information.
Related MCP Servers
- AlicenseAqualityCmaintenanceAn agent-native teaching OS that gives AI assistants a persistent classroom with courses, lessons, flashcards, and graded exercises via MCP tools.503AGPL 3.0
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to create and manage personalized 30-day study courses, including web research with source validation, daily lessons, quizzes, and progress tracking through 12 MCP tools.1MIT
- AlicenseAqualityDmaintenanceEnables AI agents to access DeepLearning.AI Short Courses, including browsing catalogs, retrieving syllabi, timestamped transcripts, Jupyter labs, and searching course content via MCP.71MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to browse your own university courses by downloading files, slides, announcements, deadlines, grades and lecture transcripts to your machine, then answering questions and searching across them through MCP tools. It logs in with your own account and refreshes only what changed.MIT