The Curriculum for the AI Mentor Knowledge Graph
This is the full curriculum behind STEMVentor Mentor — the Modules, Projects, and Quizzes that make up the knowledge graph the AI Mentor is grounded in. Every answer it gives traces back to a node on a map like this one, not to generic web knowledge.
The same structure is a template for your own Learning Paths. Assemble a path from these building blocks and ground it in content from any source — your textbooks, your LMS, your own material — or use ours, the library shown here.
Choose a Learning Path from the list, then follow it down its column: Modules connect in sequence, fork where you choose an approach, and rejoin. Expand any block for what it covers.
Programming · Beginner · 2h 59m · 3 modules
What's inside a computing device and how the parts work together to take in, process, and return data.
How devices connect and communicate — from cables and switches up to TLS and certificates.
How the global network and the web are physically and logically put together.
Programming · Beginner · 4h 34m · 5 modules
Restate everyday problems as a finite sequence of steps a computer can carry out.
The building blocks shared by every language, before any specific syntax.
Related: Programming Languages — high-level vs low-level
Pick your first language
The same constructs you just learned, in Python's plain-English syntax.
A Python program that plays multiple rounds against the player and tracks the score.
How languages differ — from the machine's own language up to the ones people write in.
A JavaScript program that plays multiple rounds between two simulated players.
Bundle a code editor, debugger, and compiler into one tool, with autocomplete and Git on top.
Pick an online IDE and use it to write and run a simple program — the path is complete.
Programming · Intermediate · 4h 47m · 8 modules
The three languages every browser understands, and the MEAN/MERN and LAMP stacks built on them.
Small builds that put HTML, CSS, and JavaScript together into a working page.
How apps moved to the web and phone, and the native / cross-platform / PWA tradeoffs.
How application work is split across tiers, and then across many machines.
How programs request data and functionality from each other through APIs and microservices.
Tables, keys, and relationships, and the SQL commands that query and change them.
Flexible, nested documents, and how they compare to relational tables.
Protecting stored data with encryption, and protecting passwords with one-way hashing.
Why analytics workloads move off the live database, and what they produce.
Physical Computing · Beginner · 6h 23m · 7 modules
The charge, current, voltage, and resistance behind every circuit.
Components that control the flow of charge itself — not just convert it to another form.
The popular boards, the add-on modules that extend them, and how to read a pinout.
Supplying clean DC power, sharing a ground, and why a disconnected pin does not read 0V.
Choose a toolchain
The setup()/loop() sketch structure and the Arduino IDE compile-and-upload workflow.
Install the IDE, then write, upload, and test sketches on a Nano and an ESP32.
boot.py / main.py, the Thonny IDE, and the built-in library categories.
Follow the official guide to set up MicroPython and run a first program on a Pico.
Build low-code, flow-based programs by wiring nodes together in a browser editor.
Physical Computing · Intermediate · 14h 27m · 9 modules · 35 projects
Where physical computing shows up — homes, wearables, factories, healthcare.
Choosing components, drawing breadboard/schematic/PCB diagrams, and wiring it up cleanly.
How a sensor turns a physical property into a signal, and the accuracy/range/resolution that define its quality.
Wire each sensor to a board and read its data onto the serial monitor.
Sensors that need calibration, filtering, or fusion before their raw output is usable.
Read richer sensors and display their values on an LCD or stream them over the network.
Turning a microcontroller's low-power signal into real-world motion and switching.
Drive a relay, a motor via a driver, and a servo — all from serial input.
Capturing direct human input — switches, potentiometers, keypads, joysticks.
Read each input device and print its state or use it to drive an output.
Showing processed data to a human — LEDs, buzzers, LCDs, OLEDs.
Mix colours, sound a buzzer, and scroll text across a display.
The three protocols boards use to exchange data over a physical connection.
Exchange data between two boards over a UART link.
Three wireless protocols for board-to-board links without a wire.
Set up each wireless link and pass data across it between two boards.
IoT · Advanced · 13h 13m · 8 modules · 82 activities
Where IoT scales up — across a city, and across an industrial factory floor.
The conceptual hardware-and-software roles every IoT solution is assembled from.
The constraints — attack surface, data trust, bandwidth, battery, interoperability — that make IoT hard at scale.
Getting a device onto a network — wired, wireless, or cellular.
Asynchronous messaging, MQTT for constrained devices, and the Matter smart-home standard.
Pick a smart-home build (by hardware on hand)
One Ek R4 wiring every sensor, controller, display, and radio into a single full circuit.
Nano and Pico circuits feed Node-RED over serial and out to an MQTT broker — no WiFi hardware needed.
Two Nanos and a Pico bridged by an ESP32 gateway straight to MQTT over WiFi and to the app over BLE.
Running AI directly on a device instead of calling a hosted model over the network.
The machine-learning workflow behind a tiny on-device classifier, end to end.
Train one 5-word model, then deploy it two ways — the two-chip Arduino UNO Q and a single-process Raspberry Pi 5.
The Android app that reads sensor data and sends control signals over MQTT and BLE.
Drones · Beginner · 5h 36m · 7 modules
The physics that generates lift and gets an aircraft off the ground.
Roll, pitch, and yaw, and why the exact centre-of-gravity position affects stability.
The main sections of an airframe and what each one does structurally.
The NAVAIDs, charts, and reference frames pilots use to find their way.
The classic six instruments, the glass cockpit, and the FMS that manages the flight plan.
A full flight, from route planning through the flare and rollout.
Multirotor vs fixed-wing, PID stabilization, and the sensors and links that make a drone autonomous.
A Nano captures GPS, IMU, and pressure data and sends it over LoRa to an ESP32 and a Processing instrument panel.
AI · Intermediate · 2h 43m · 5 modules
What actually counts as 'artificial intelligence,' and the genuinely different capabilities the term covers.
Where AI/ML is already quietly running inside products you use every day.
Ready-made AI you call as a cloud API instead of building and training a model from scratch.
Models that create new content rather than just recognise or analyse existing data.
When a model is given the ability to act — calling tools and taking multi-step actions toward a goal.
AI · Advanced · 10h 39m · 8 modules
What a token is, what happens at training vs inference, and the knobs that shape a response.
The shape of a request and response, how roles structure a conversation, and how calls fail.
Turning text into vectors so it can be searched by meaning instead of exact words.
What a graph of relationships captures that meaning-based search alone doesn't.
Grounding an LLM's answers in real, specific content instead of letting it guess.
Designing distinct, deliberate workflows instead of routing every request through one prompt.
What turns a single question-and-answer exchange into an actual conversation.
Measuring whether answers are actually correct, and building in guardrails to catch bad ones.
Build the real AI Mentor end to end — FastAPI, an LLM service, ingestion, pgvector retrieval, the knowledge graph, prompt assembly, and the chat API. It's the system behind this very page.
Blockchain · Advanced · 2h 17m · 5 modules
What blockchain drops the trusted middleman to achieve, and what that trade-off costs.
Transactions, hash-linked blocks, mining, and how a network agrees without a central authority.
The situations where multiple participants who would rather not trust one authority come out ahead.
The real costs — speed, scale, compute, and energy — slowing adoption.
The cryptographic primitives every blockchain guarantee rests on.
Blockchain · Advanced · 2h 15m · 18 activities
A gamified share-trading simulation on Solana — the roles, the matching rules, and the on-chain data model.
The deployed program — every instruction, account context, and data structure from the design lesson.
A Node/Express layer split into Solana-facing endpoints that sign transactions and MongoDB-facing reads and writes.
Two user roles, a trader's three-card dashboard, and why connecting a wallet is not the same as authenticating.
Deploy with Solana Playground, wire up Atlas and Phantom, then run trades between two traders end to end.
Capstone · Advanced · 1h 34m · 13 activities
A supply-chain DApp that ties together programming, physical computing, IoT, AI, and blockchain — scoped from problem to reference architecture.
Sensors at three microcontroller locations, and the JSON message shape all of them publish to the cloud.
One AI service: a raw number-plate photo becomes a registration number the smart contract can check.
Mainnet vs testnet, the Layer-1/Layer-2 options weighed, and the order-fulfilment contract modeled with structs and mappings.
An API Gateway and Lambda microservices route every reading; a four-panel dashboard follows an order from wallet connect to settlement.