Ramakm/ai-hands-on: a notebook curriculum from derivatives to RAG
A group of notebooks and other files which can help you learn AI from scratch.
At a glance
- What is it?
- The repository sequences math, PyTorch, neural networks, transformers, RAG and OCR into numbered folders, with per-folder dependency files for the last two stages. It is a study path, not a framework, and its value depends on whether you want to read code in order rather than call an API.
- Who is it for?
- Adopt it if you want a numbered notebook sequence that starts at derivatives and gradients and ends at a RAG pipeline, and you are willing to run `pip install -r requirements.txt` plus the separate `5.RAG/` and `6.OCR/` requirements files. Do not adopt it if you need a maintained library, versioned releases, or benchmark comparisons; the repository publishes no releases.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly Jupyter Notebook, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap this repository tries to fill between a math course and an LLM API call
Most people entering AI work meet the field from one of two ends. Either they take a course on linear algebra and probability and never connect it to running code, or they call a hosted model through an SDK and never see what sits underneath. The README states the repository is designed to help you learn AI from first principles, build real neural networks, and understand modern LLM systems end to end. The intended reader is someone who wants the middle layer: the tensor operations, the attention mechanism, the retrieval loop.
The scope is deliberately wide. The folder list runs from math functions, derivatives, vectors and gradients through PyTorch tensor manipulation, then neurons and layers built from scratch, then attention and a decoder-only transformer, then a RAG pipeline, then OCR. A separate section covers basic supervised, unsupervised and reinforcement learning models, naming linear regression, logistic regression, decision trees and naive Bayes. That is a curriculum, not a product. There is no package to import, no CLI, no service. You read and run notebooks.
The homepage points to a Substack, and the README recommends books that are not included, such as AI Engineering by Chip Huyen and Deep Learning by Goodfellow, Bengio and Courville. So the repository positions itself as one part of a study plan rather than the whole of it.
Folder order is the architecture: how the six stages depend on each other
The mechanism here is sequencing. The README's usage section gives an explicit order: work through `1.Math/`, `2.PyTorch/`, `3.Neural-Network(NN)/` and `4.Transformer/` in that sequence, then run `5.RAG/` and `6.OCR/` separately. The Learning Path file at `Start_here/learning_path.md` is described as the recommended step-by-step progression, which suggests the numbered folders are the coarse structure and that file holds the finer ordering.
Each stage builds on the previous one in a way that is visible from the topic list. Tensor creation, transposing and reshaping in `2.PyTorch/` are the operations you need before building layers in `3.Neural-Network(NN)/`. That folder covers normalization techniques including RMSNorm, activation functions, and optimizers named as Adam and Muon plus learning rate decay. RMSNorm and Muon are not the default choices in most introductory material, which tells you the author is tracking current practice rather than the 2019 syllabus.
`4.Transformer/` covers attention, self-attention, multi-head attention and a decoder-only architecture. Only after that does `5.RAG/` appear, which is the right dependency order: retrieval augmented generation is easier to reason about once you know what the model does with the retrieved context. The two final folders are flagged as run separately, which is a hint that they carry heavier dependencies and probably longer runtimes.
Getting the notebooks running, including the two folders with their own requirements
The install instruction in the README is a single command from the project root:
pip install -r requirements.txt
The README then adds that some subfolders, naming `5.RAG/` and `6.OCR/` as examples, include their own `requirements.txt` with additional dependencies. That is the practical detail most likely to trip someone up. A root install alone will not cover the RAG and OCR notebooks, so plan on a second and third install inside those directories.
The recommended workflow is to open Jupyter in the project root, either with `jupyter lab` or `jupyter notebook`, and then work through the numbered folders in order. The RAG section lists cloud LLM support for Atlas Cloud, MiniMax, OpenAI, or any OpenAI-compatible API, with `deepseek-ai/DeepSeek-V3-0324` named as the Atlas Cloud default. The README does not show the configuration keys or environment variable names for those providers, so before starting that folder you should read the notebooks themselves to find out what credentials and settings they expect.
There are no releases in the repository metadata, so there is no tagged version to pin. If you clone it, you are tracking the default branch.
Where the material stops being enough
The RAG folder is the clearest limitation. The README lists indexing, retrieval and chunking strategies along with integrations for embedding models and vector stores, but it does not name a specific vector store, embedding model or chunking default. Answer generation is delegated to a hosted provider. That means the RAG notebooks cannot be run offline without substituting a local model, and the quality of what you observe will depend on the provider you configure rather than on anything in the repository.
The second limitation is maintenance surface. Jupyter notebooks are hard to diff and hard to test. Nothing in the supplied material describes a CI workflow, a test suite, or a pinned environment beyond the requirements files. The last push date is 2026-09-01, so the project is active, but activity is not the same as reproducibility. A notebook that pins no versions can break when a library changes an API, and you will be the one debugging it.
Third, the repository is a teaching artifact, not a reference implementation. If your goal is to ship a retrieval system, the notebooks show the shape of a pipeline; they do not give you a maintained client with error handling, retries or evaluation harnesses. Treat the code as illustrative.
How this differs from a structured course or a framework tutorial
The closest comparison is a video course or a book with accompanying code, and the difference is in what you are handed. A course gives you a syllabus with assessments and a fixed environment. This repository gives you folders and a learning path file, and leaves environment setup to the requirements files. That is more work and more flexibility. You can jump straight to `4.Transformer/` if you already know PyTorch, though the README's recommended order argues against skipping.
The other comparison is a framework's own tutorials, for example the PyTorch documentation's introductory notebooks. Those are maintained by the library authors and updated with the library. This repository is maintained by one author plus contributors, and its coverage is broader: it includes the math groundwork and the RAG and OCR stages that a framework tutorial would not touch. The trade-off is that framework tutorials stay current with the library by contract, while a personal curriculum depends on the author finding time.
The RAG section also leans on hosted providers rather than local inference. A project built around a local model stack would let you run everything on one machine; this one expects network access and an API key for the final stage. That is a real difference in approach, not a detail.
Licence, upgrades and what you are actually maintaining
The repository is MIT licensed. In practice that means you can copy the notebooks into your own project, modify them and redistribute them, provided you keep the licence notice. It does not give you any warranty, and it does not cover the third party services the RAG notebooks call, whose own terms apply. This is a description of the licence text, not legal advice; if you plan to ship derived code commercially, read the MIT terms and the provider terms yourself.
Upgrade cost is the more interesting question. Because there are no releases, there is no upgrade path in the usual sense: you pull the default branch and reconcile whatever changed. The requirements files are the contract. If a notebook breaks after a library update, the fix is either pinning the version in the relevant requirements file or adapting the notebook. The README does not describe a supported Python version, so that is the first thing to establish locally.
The repository bundles no model weights and no datasets. The books it recommends are explicitly not included. So the maintenance burden is mostly your own environment plus whatever the author changes in the notebooks you depend on.
Who should work through this, and what to check before the first commit of time
Take it on if you are an engineer who has used Python and wants to see attention and retrieval implemented rather than described, and if you are comfortable debugging a notebook environment. The progression from derivatives to a decoder-only transformer to a RAG pipeline is coherent, and the inclusion of RMSNorm and Muon suggests the material is not frozen in an older era of the field.
Skip it if you need something to depend on in production, if you cannot run notebooks interactively, or if you need a pinned, reproducible environment out of the box. Skip it too if you only want the RAG stage: that folder is the least self-contained part, since it assumes a hosted provider and its own requirements file.
The concrete first step is to open `Start_here/learning_path.md` and read the recommended order before installing anything, then install the root requirements and confirm the `1.Math/` notebooks execute. Only after that should you decide whether the RAG and OCR folders are worth the extra dependency installs and the API credentials they imply.
Editorial conclusion
Adopt it if you want a numbered notebook sequence that starts at derivatives and gradients and ends at a RAG pipeline, and you are willing to run `pip install -r requirements.txt` plus the separate `5.RAG/` and `6.OCR/` requirements files. Do not adopt it if you need a maintained library, versioned releases, or benchmark comparisons; the repository publishes no releases. Before committing time, open `Start_here/learning_path.md`, confirm the notebooks in `3.Neural-Network(NN)/` and `4.Transformer/` run on your Python and PyTorch versions, and check whether the RAG notebooks require an Atlas Cloud, MiniMax or OpenAI key to execute end to end.
Community notes