# Recommended Tools and Frameworks for AI Engineering from Scratch

> Master AI engineering from scratch with recommended Python, Node.js, and Rust tools and frameworks. Build production-grade AI solutions efficiently.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: best-practices
- Published: 2026-06-06

---

**The AI Engineering from Scratch curriculum requires Python 3.11+ with scientific computing libraries, Node.js 20+ for TypeScript lessons, and optionally Rust for tokenizer implementations, following a minimal-dependency philosophy while supporting production-grade AI development.**

The *AI Engineering from Scratch* repository by Rohit Ghumare provides a comprehensive, polyglot curriculum for building AI systems from first principles. Unlike framework-heavy tutorials, this project emphasizes understanding core mechanisms through practical implementations in multiple languages. Whether you are implementing neural networks or deploying Model-Context-Protocol (MCP) servers, using the correct tools and frameworks ensures you can execute every lesson from linear algebra foundations to production-ready agents.

## Core Programming Languages and Runtimes

The curriculum adopts a **polyglot approach** to reinforce AI concepts across different execution environments.

- **Python 3.11+** – The primary language for deep learning, data processing, and agent implementation. All Python lessons assume a modern CPython interpreter with virtual environment support.
- **Node.js 20+** – Required for TypeScript implementations of frameworks and streaming servers, particularly in the deep learning core and agent engineering phases.
- **Rust** – Used specifically for high-performance tokenizer implementations in the "LLMs from Scratch" phase, requiring the standard `rustc` compiler and Cargo toolchain.
- **Julia** – Referenced for numerical computing lessons where high-performance scientific computing is emphasized.

## Python Scientific Stack and Deep Learning Libraries

Located at the repository root, [`requirements.txt`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/requirements.txt) defines the minimal but complete Python dependency set. According to the source code, this includes:

- **Core scientific libraries**: `numpy`, `pandas`, `matplotlib` for data manipulation and visualization
- **Deep learning frameworks**: `torch` and `torchvision` for tensor operations and neural network training
- **NLP and LLM tooling**: `transformers`, `datasets`, `tokenizers`, and `accelerate` for working with pre-trained models and efficient training pipelines
- **Interactive development**: `jupyter` for notebook-based exploration throughout the curriculum

Install these dependencies using:

```bash
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

pip install -r requirements.txt

```

## Node.js and TypeScript Tooling

The TypeScript lessons, particularly in `phases/03-deep-learning-core/` and agent engineering modules, rely on modern Node.js patterns. The [`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js) script and lesson implementations use:

- **Hono** – Lightweight web framework for building API servers
- **Zod** – Schema validation for type-safe configuration and data handling
- **WS** – WebSocket library for real-time streaming implementations

Install lesson-specific dependencies by navigating to the code directory and running:

```bash
cd phases/03-deep-learning-core/10-mini-framework/code
npm install
npx ts-node main.ts

```

## Rust Toolchain for Low-Level Components

For lessons covering tokenization and low-level algorithms, the repository includes Rust implementations that compile to native code. The `phases/10-llms-from-scratch/01-tokenizers/code/` directory contains examples requiring:

```bash
cd phases/10-llms-from-scratch/01-tokenizers/code
rustc main.rs -O && ./main

```

This produces optimized binaries for understanding byte-pair encoding and vocabulary generation without Python overhead.

## Auxiliary Development Tools

Beyond core languages, the project recommends:

- **Docker** – Introduced in Phase 0 ("Docker for AI") for containerizing development environments and ensuring reproducible builds across operating systems
- **Jupyter Notebooks** – Integrated throughout for exploratory data analysis and visualization, installed via the `jupyter` package in [`requirements.txt`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/requirements.txt)

## Agent and Protocol Stack

The later phases implement reusable AI components using **pure Python** from the standard library plus optional dependencies. Key artifacts include:

- **Skills and Agents** – Modular components defined in lesson outputs and installed via [`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)
- **MCP (Model-Context-Protocol) Servers** – Lightweight protocol implementations for agent communication, located in `phases/14-agent-engineering/` outputs

These components require no additional frameworks beyond the Python packages listed in [`requirements.txt`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/requirements.txt), adhering to the project's minimal-dependency philosophy while enabling production deployment.

## Running Your First Lesson

To verify your environment across all supported languages:

```bash

# Clone the repository

git clone https://github.com/rohitg00/ai-engineering-from-scratch.git
cd ai-engineering-from-scratch

# Python: Linear algebra foundations

python phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py

# TypeScript: Mini-framework demonstration

cd phases/03-deep-learning-core/10-mini-framework/code
npm install && npx ts-node main.ts

# Rust: Tokenization basics

cd phases/10-llms-from-scratch/01-tokenizers/code
rustc main.rs -O && ./main

```

## Key Repository Files

Understanding the repository structure helps navigate the tool requirements:

- **[`README.md`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/README.md)** – Curriculum overview and phase structure
- **[`requirements.txt`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/requirements.txt)** – Canonical Python dependency list including `torch`, `transformers`, and `datasets`
- **[`site/build.js`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/site/build.js)** – Node.js script for static site generation using modern web tooling
- **[`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py)** – Installer for reusable lesson artifacts (agents, skills, MCP servers)
- **`phases/*/code/`** – Runnable implementations for each lesson across all supported languages
- **`phases/*/docs/en.md`** – Narrative documentation explaining concepts and learning objectives
- **`phases/*/outputs/`** – Generated artifacts including prompts, skills, and MCP server definitions

## Summary

- **Python 3.11+** with packages from [`requirements.txt`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/requirements.txt) (numpy, pandas, torch, transformers, etc.) forms the primary development environment
- **Node.js 20+** with npm packages (hono, zod, ws) enables TypeScript lessons and framework implementations
- **Rust toolchain** is required only for tokenizer and low-level performance-critical lessons
- **Docker** support in Phase 0 provides containerized workflows for reproducible AI development
- **MCP servers and agent skills** run on pure Python with minimal external dependencies, emphasizing production-ready simplicity

## Frequently Asked Questions

### Do I need to install all languages to use the project?

No. While the curriculum supports **Python**, **TypeScript**, **Rust**, and **Julia**, you can follow individual phases using only the language specified for that lesson. Python is the only required language for the majority of the AI/ML content; TypeScript and Rust are optional for specific implementation deep-dives.

### Can I use a different Python version than 3.11?

The project is tested against **Python 3.11+**, as specified in the repository requirements. Earlier versions may work for basic lessons but could cause compatibility issues with newer `torch` or `transformers` features used in the deep learning and LLM phases.

### What is the purpose of the [`install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/install_skills.py) script?

Located in [`scripts/install_skills.py`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/scripts/install_skills.py), this utility installs reusable artifacts generated by lessons—including **skills**, **agents**, and **MCP servers**—into your local environment. It enables you to compose and reuse AI components built throughout the curriculum without manual copy-pasting.

### Is Docker mandatory for running the lessons?

No. Docker is introduced in Phase 0 as an optional tool for containerizing development environments. You can run all Python, TypeScript, and Rust lessons directly on your host system provided you have the required language runtimes installed.