MCPHub LabRegistryrohitg00/ai-engineering-from-scratch
rohitg00

rohitg00/ai engineering from scratch

Built by rohitg00 • 1,091 stars

What is rohitg00/ai engineering from scratch?

Learn it. Build it. Ship it for others.

How to use rohitg00/ai engineering from scratch?

1. Install a compatible MCP client (like Claude Desktop). 2. Open your configuration settings. 3. Add rohitg00/ai engineering from scratch using the following command: npx @modelcontextprotocol/rohitg00-ai-engineering-from-scratch 4. Restart the client and verify the new tools are active.
šŸ›”ļø Scoped (Restricted)
npx @modelcontextprotocol/rohitg00-ai-engineering-from-scratch --scope restricted
šŸ”“ Unrestricted Access
npx @modelcontextprotocol/rohitg00-ai-engineering-from-scratch

Key Features

Native MCP Protocol Support
Real-time Tool Activation & Execution
Verified High-performance Implementation
Secure Resource & Context Handling

Optimized Use Cases

Extending AI models with custom local capabilities
Automating system workflows via natural language
Connecting external data sources to LLM context windows

rohitg00/ai engineering from scratch FAQ

Q

Is rohitg00/ai engineering from scratch safe?

Yes, rohitg00/ai engineering from scratch follows the standardized Model Context Protocol security patterns and only executes tools with explicit user-granted permissions.

Q

Is rohitg00/ai engineering from scratch up to date?

rohitg00/ai engineering from scratch is currently active in the registry with 1,091 stars on GitHub, indicating its reliability and community support.

Q

Are there any limits for rohitg00/ai engineering from scratch?

Usage limits depend on the specific implementation of the MCP server and your system resources. Refer to the official documentation below for technical details.

Official Documentation

View on GitHub
<p align="center"> <img src="assets/banner.svg" alt="AI Engineering from Scratch" width="100%"> </p> <p align="center"> <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a> <a href="CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome"></a> <img src="https://img.shields.io/badge/Lessons-260+-D97757" alt="260+ Lessons"> <img src="https://img.shields.io/badge/Phases-20-191A23" alt="20 Phases"> <img src="https://img.shields.io/badge/Complete-68-3D8B6E" alt="68 Complete"> <img src="https://img.shields.io/github/stars/rohitg00/ai-engineering-from-scratch?style=social" alt="GitHub Stars"> </p> <p align="center"> <a href="#the-journey">Journey</a> &bull; <a href="#-ai-native-learning">AI-Native</a> &bull; <a href="#getting-started">Get Started</a> &bull; <a href="#course-output-the-toolkit">Toolkit</a> &bull; <a href="ROADMAP.md">Roadmap</a> &bull; <a href="CONTRIBUTING.md">Contribute</a> &bull; <a href="glossary/terms.md">Glossary</a> </p>

84% of students already use AI tools. Only 18% feel prepared to use them professionally. This course closes that gap.

260+ lessons. 20 phases. ~290 hours. From linear algebra to autonomous agent swarms. Python, TypeScript, Rust, Julia. Every lesson produces something reusable -- prompts, skills, agents, MCP servers.

You don't just learn AI. You learn AI with AI. Then you build real things. Then you ship tools others can use.

Traditional CoursesThis Course
ScopeOne slice (NLP or Vision or Agents)Everything: math, ML, DL, NLP, vision, speech, transformers, LLMs, agents, swarms
LanguagesPython onlyPython, TypeScript, Rust, Julia
Output"I learned something"A portfolio of tools, prompts, skills, and agents you can install
DepthSurface-level or theory-heavyBuild from scratch first, then use frameworks
FormatVideos you watchRunnable code + docs + web app + AI-powered quizzes
Learning stylePassive consumptionAI-native: use Claude Code skills to test yourself as you go

🧠 AI-Native Learning

This isn't a course you watch. It's a course you use with your AI coding agent.

Learn with AI, not just about AI

# Find where to start based on what you already know
/find-your-level

# Quiz yourself after completing a phase
/check-understanding 3

# Every lesson produces a reusable artifact
ls phases/03-deep-learning-core/05-loss-functions/outputs/
# prompt-loss-function-selector.md
# prompt-loss-debugger.md

Built-in Claude Code Skills

SkillWhat it does
/find-your-level10-question quiz that maps your knowledge to a starting phase and builds a personalized path with hour estimates
/check-understanding <phase>Per-phase quiz (8 questions) with feedback and specific lessons to review

Every Lesson Ships Something

Other courses end with "congratulations, you learned X." Our lessons end with a reusable tool:

  • Prompts -- paste into any AI assistant to get expert-level help on the topic
  • Skills -- install into Claude Code, Cursor, or any coding agent
  • Agents -- deploy as autonomous workers
  • MCP servers -- plug into any MCP-compatible AI app

277-term searchable glossary. Full lesson catalog. ~290 hours of content with per-lesson time estimates. Browse the website →


The Journey

<table> <tr><td>

Phase 0: Setup & Tooling 12 lessons

Get your environment ready for everything that follows.

#LessonTypeLang
01Dev EnvironmentBuildPython, Node, Rust
02Git & CollaborationLearn--
03GPU Setup & CloudBuildPython
04APIs & KeysBuildPython, TS
05Jupyter NotebooksBuildPython
06Python EnvironmentsBuildPython
07Docker for AIBuildPython
08Editor SetupBuild--
09Data ManagementBuildPython
10Terminal & ShellLearn--
11Linux for AILearn--
12Debugging & ProfilingBuildPython
</td></tr> </table> <details id="phase-1"> <summary><strong>Phase 1: Math Foundations</strong> <code>22 lessons</code> &nbsp; <em>The intuition behind every AI algorithm, through code.</em></summary>
#LessonTypeLang
01Linear Algebra IntuitionLearnPython, Julia
02Vectors, Matrices & OperationsBuildPython, Julia
03Matrix Transformations & EigenvaluesBuildPython, Julia
04Calculus for ML: Derivatives & GradientsLearnPython
05Chain Rule & Automatic DifferentiationBuildPython
06Probability & DistributionsLearnPython
07Bayes' Theorem & Statistical ThinkingBuildPython
08Optimization: Gradient Descent FamilyBuildPython
09Information Theory: Entropy, KL DivergenceLearnPython
10Dimensionality Reduction: PCA, t-SNE, UMAPBuildPython
11Singular Value DecompositionBuildPython, Julia
12Tensor OperationsBuildPython
13Numerical StabilityBuildPython
14Norms & DistancesBuildPython
15Statistics for MLBuildPython
16Sampling MethodsBuildPython
17Linear SystemsBuildPython
18Convex OptimizationBuildPython
19Complex Numbers for AILearnPython
20The Fourier TransformBuildPython
21Graph Theory for MLBuildPython
22Stochastic ProcessesLearnPython
</details> <details id="phase-2"> <summary><strong>Phase 2: ML Fundamentals</strong> <code>18 lessons</code> &nbsp; <em>Classical ML - still the backbone of most production AI.</em></summary>
#LessonTypeLang
01What Is Machine LearningLearnPython
02Linear Regression from ScratchBuildPython
03Logistic Regression & ClassificationBuildPython
04Decision Trees & Random ForestsBuildPython
05Support Vector MachinesBuildPython
06KNN & Distance MetricsBuildPython
07Unsupervised Learning: K-Means, DBSCANBuildPython
08Feature Engineering & SelectionBuildPython
09Model Evaluation: Metrics, Cross-ValidationBuildPython
10Bias, Variance & the Learning CurveLearnPython
11Ensemble Methods: Boosting, Bagging, StackingBuildPython
12Hyperparameter TuningBuildPython
13ML Pipelines & Experiment TrackingBuildPython
14Naive BayesBuildPython
15Time Series FundamentalsBuildPython
16Anomaly DetectionBuildPython
17Handling Imbalanced DataBuildPython
18Feature SelectionBuildPython
</details> <details id="phase-3"> <summary><strong>Phase 3: Deep Learning Core</strong> <code>13 lessons</code> &nbsp; <em>Neural networks from first principles. No frameworks until you build one.</em></summary>
#LessonTypeLang
01The Perceptron: Where It All StartedBuildPython
02Multi-Layer Networks & Forward PassBuildPython
03Backpropagation from ScratchBuildPython
04Activation Functions: ReLU, Sigmoid, GELU & WhyBuildPython
05Loss Functions: MSE, Cross-Entropy, ContrastiveBuildPython
06Optimizers: SGD, Momentum, Adam, AdamWBuildPython
07Regularization: Dropout, Weight Decay, BatchNormBuildPython
08Weight Initialization & Training StabilityBuildPython
09Learning Rate Schedules & WarmupBuildPython
10Build Your Own Mini FrameworkBuildPython
11Introduction to PyTorchBuildPython
12Introduction to JAXBuildPython
13Debugging Neural NetworksLearnPython
</details> <details id="phase-4"> <summary><strong>Phase 4: Computer Vision</strong> <code>16 lessons</code> &nbsp; <em>From pixels to understanding - image, video, and 3D.</em></summary>
#LessonTypeLang
01Image Fundamentals: Pixels, Channels, Color SpacesLearnPython
02Convolutions from ScratchBuildPython
03CNNs: LeNet to ResNetBuildPython
04Image ClassificationBuildPython
05Transfer Learning & Fine-TuningBuildPython
06Object Detection -YOLO from ScratchBuildPython
07Semantic Segmentation -U-NetBuildPython
08Instance Segmentation -Mask R-CNNBuildPython
09Image Generation -GANsBuildPython
10Image Generation -Diffusion ModelsBuildPython
11Stable Diffusion -Architecture & Fine-TuningBuildPython
12Video Understanding -Temporal ModelingBuildPython
133D Vision: Point Clouds, NeRFsBuildPython
14Vision Transformers (ViT)BuildPython
15Real-Time Vision: Edge DeploymentBuildPython, Rust
16Build a Complete Vision PipelineBuildPython
</details> <details id="phase-5"> <summary><strong>Phase 5: NLP: Foundations to Advanced</strong> <code>18 lessons</code> &nbsp; <em>Language is the interface to intelligence.</em></summary>
#LessonTypeLang
01Text Processing: Tokenization, Stemming, LemmatizationBuildPython
02Bag of Words, TF-IDF & Text RepresentationBuildPython
03Word Embeddings: Word2Vec from ScratchBuildPython
04GloVe, FastText & Subword EmbeddingsBuildPython
05Sentiment AnalysisBuildPython
06Named Entity Recognition (NER)BuildPython
07POS Tagging & Syntactic ParsingBuildPython
08Text Classification -CNNs & RNNs for TextBuildPython
09Sequence-to-Sequence ModelsBuildPython
10Attention Mechanism -The BreakthroughBuildPython
11Machine TranslationBuildPython
12Text SummarizationBuildPython
13Question Answering SystemsBuildPython
14Information Retrieval & SearchBuildPython
15Topic Modeling: LDA, BERTopicBuildPython
16Text GenerationBuildPython
17Chatbots: Rule-Based to NeuralBuildPython
18Multilingual NLPBuildPython
</details> <details id="phase-6"> <summary><strong>Phase 6: Speech & Audio</strong> <code>12 lessons</code> &nbsp; <em>Hear, understand, speak.</em></summary>
#LessonTypeLang
01Audio Fundamentals: Waveforms, Sampling, FFTLearnPython
02Spectrograms, Mel Scale & Audio FeaturesBuildPython
03Audio ClassificationBuildPython
04Speech Recognition (ASR)BuildPython
05Whisper: Architecture & Fine-TuningBuildPython
06Speaker Recognition & VerificationBuildPython
07Text-to-Speech (TTS)BuildPython
08Voice Cloning & Voice ConversionBuildPython
09Music GenerationBuildPython
10Audio-Language ModelsBuildPython
11Real-Time Audio ProcessingBuildPython, Rust
12Build a Voice Assistant PipelineBuildPython
</details> <details id="phase-7"> <summary><strong>Phase 7: Transformers Deep Dive</strong> <code>14 lessons</code> &nbsp; <em>The architecture that changed everything.</em></summary>
#LessonTypeLang
01Why Transformers: The Problems with RNNsLearn--
02Self-Attention from ScratchBuildPython
03Multi-Head AttentionBuildPython
04Positional Encoding: Sinusoidal, RoPE, ALiBiBuildPython
05The Full Transformer: Encoder + DecoderBuildPython
06BERT -Masked Language ModelingBuildPython
07GPT -Causal Language ModelingBuildPython
08T5, BART -Encoder-Decoder ModelsBuildPython
09Vision Transformers (ViT)BuildPython
10Audio Transformers -Whisper ArchitectureBuildPython
11Mixture of Experts (MoE)BuildPython
12KV Cache, Flash Attention & Inference OptimizationBuildPython, Rust
13Scaling LawsLearnPython
14Build a Transformer from ScratchBuildPython
</details> <details id="phase-8"> <summary><strong>Phase 8: Generative AI</strong> <code>14 lessons</code> &nbsp; <em>Create images, video, audio, 3D, and more.</em></summary>
#LessonTypeLang
01Generative Models: Taxonomy & HistoryLearn--
02Autoencoders & VAEBuildPython
03GANs: Generator vs DiscriminatorBuildPython
04Conditional GANs & Pix2PixBuildPython
05StyleGANBuildPython
06Diffusion Models -DDPM from ScratchBuildPython
07Latent Diffusion & Stable DiffusionBuildPython
08ControlNet, LoRA & ConditioningBuildPython
09Inpainting, Outpainting & EditingBuildPython
10Video GenerationBuildPython
11Audio GenerationBuildPython
123D GenerationBuildPython
13Flow Matching & Rectified FlowsBuildPython
14Evaluation: FID, CLIP ScoreBuildPython
</details> <details id="phase-9"> <summary><strong>Phase 9: Reinforcement Learning</strong> <code>12 lessons</code> &nbsp; <em>The foundation of RLHF and game-playing AI.</em></summary>
#LessonTypeLang
01MDPs, States, Actions & RewardsLearnPython
02Dynamic ProgrammingBuildPython
03Monte Carlo MethodsBuildPython
04Q-Learning, SARSABuildPython
05Deep Q-Networks (DQN)BuildPython
06Policy Gradients -REINFORCEBuildPython
07Actor-Critic -A2C, A3CBuildPython
08PPOBuildPython
09Reward Modeling & RLHFBuildPython
10Multi-Agent RLBuildPython
11Sim-to-Real TransferBuildPython
12RL for GamesBuildPython
</details> <details id="phase-10"> <summary><strong>Phase 10: LLMs from Scratch</strong> <code>14 lessons</code> &nbsp; <em>Build, train, and understand large language models.</em></summary>
#LessonTypeLang
01Tokenizers: BPE, WordPiece, SentencePieceBuildPython
02Building a Tokenizer from ScratchBuildPython
03Data Pipelines for Pre-TrainingBuildPython
04Pre-Training a Mini GPT (124M)BuildPython
05Distributed Training, FSDP, DeepSpeedBuildPython
06Instruction Tuning -SFTBuildPython
07RLHF -Reward Model + PPOBuildPython
08DPO -Direct Preference OptimizationBuildPython
09Constitutional AIBuildPython
10Evaluation -Benchmarks, EvalsBuildPython
11Quantization: INT8, GPTQ, AWQ, GGUFBuildPython, Rust
12Inference OptimizationBuildPython
13Building a Complete LLM PipelineBuildPython
14Open Models: Architecture WalkthroughsLearnPython
</details> <details id="phase-11"> <summary><strong>Phase 11: LLM Engineering</strong> <code>13 lessons</code> &nbsp; <em>Put LLMs to work in production.</em></summary>
#LessonTypeLang
01Prompt Engineering: Techniques & PatternsBuildPython
02Few-Shot, CoT, Tree-of-ThoughtBuildPython
03Structured OutputsBuildPython, TS
04Embeddings & Vector RepresentationsBuildPython
05Context EngineeringBuildPython, TS
06RAG -Retrieval-Augmented GenerationBuildPython, TS
07Advanced RAG -Chunking, RerankingBuildPython
08Fine-Tuning with LoRA & QLoRABuildPython
09Function Calling & Tool UseBuildPython, TS
10Evaluation & TestingBuildPython
11Caching, Rate Limiting & CostBuildPython, TS
12Guardrails & SafetyBuildPython
13Building a Production LLM AppBuildPython, TS
</details> <details id="phase-12"> <summary><strong>Phase 12: Multimodal AI</strong> <code>11 lessons</code> &nbsp; <em>See, hear, read, and reason across modalities.</em></summary>
#LessonTypeLang
01Multimodal RepresentationsLearn--
02CLIP: Vision + LanguageBuildPython
03Vision-Language ModelsBuildPython
04Audio-Language ModelsBuildPython
05Document UnderstandingBuildPython
06Video-Language ModelsBuildPython
07Multimodal RAGBuildPython, TS
08Multimodal AgentsBuildPython, TS
09Text-to-Image PipelinesBuildPython
10Text-to-Video PipelinesBuildPython
11Any-to-Any ModelsLearnPython
</details> <details id="phase-13"> <summary><strong>Phase 13: Tools & Protocols</strong> <code>10 lessons</code> &nbsp; <em>The interfaces between AI and the real world.</em></summary>
#LessonTypeLang
01Function Calling Deep DiveBuildPython, TS
02Tool Use PatternsBuildTS
03MCP: Model Context ProtocolLearn--
04Building MCP ServersBuildTS, Python
05Building MCP ClientsBuildTS, Python
06MCP Resources, Prompts & SamplingBuildTS
07Structured Output SchemasBuildTS, Python
08API Design for AIBuildTS
09Browser Automation & Web AgentsBuildTS
10Build a Complete Tool EcosystemBuildTS, Python
</details> <details id="phase-14"> <summary><strong>Phase 14: Agent Engineering</strong> <code>15 lessons</code> &nbsp; <em>Build agents from first principles.</em></summary>
#LessonTypeLang
01The Agent LoopBuildPython, TS
02Tool Dispatch & RegistrationBuildTS
03Planning: TodoWrite, DAGsBuildTS
04Memory: Short-Term, Long-Term, EpisodicBuildTS, Python
05Context Window ManagementBuildTS
06Context Compression & SummarizationBuildTS
07Subagents: DelegationBuildTS
08Skills & Knowledge LoadingBuildTS
09Permissions, Sandboxing & SafetyBuildTS, Rust
10File-Based Task SystemsBuildTS
11Background Task ExecutionBuildTS
12Error Recovery & Self-HealingBuildTS
13Hooks: PreToolUse, PostToolUseBuildTS
14Eval-Driven Agent DevelopmentBuildPython, TS
15Build a Complete AI AgentBuildTS
</details> <details id="phase-15"> <summary><strong>Phase 15: Autonomous Systems</strong> <code>11 lessons</code> &nbsp; <em>Agents that run without human intervention safely.</em></summary>
#LessonTypeLang
01What Makes a System AutonomousLearn--
02Autonomous LoopsBuildTS, Python
03Self-Healing AgentsBuildTS
04AutoResearch: Autonomous ResearchBuildTS, Python
05Eval-Driven LoopsBuildTS
06Human-in-the-LoopBuildTS
07Continuous AgentsBuildTS
08Cost-Aware Autonomous SystemsBuildTS
09Monitoring & ObservabilityBuildTS, Rust
10Safety BoundariesBuildTS
11Build an Autonomous Coding AgentBuildTS
</details> <details id="phase-16"> <summary><strong>Phase 16: Multi-Agent & Swarms</strong> <code>14 lessons</code> &nbsp; <em>Coordination, emergence, and collective intelligence.</em></summary>
#LessonTypeLang
01Why Multi-AgentLearn--
02Agent Teams: Roles & DelegationBuildTS
03Communication ProtocolsBuildTS
04Shared State & CoordinationBuildTS, Rust
05Message Passing & MailboxesBuildTS
06Task MarketsBuildTS
07Consensus AlgorithmsBuildTS, Rust
08Swarm IntelligenceBuildPython, TS
09Agent EconomiesBuildTS
10Worktree IsolationBuildTS
11Hierarchical SwarmsBuildTS
12Self-Organizing SystemsBuildTS, Rust
13DAG-Based OrchestrationBuildTS, Rust
14Build an Autonomous SwarmBuildTS, Rust
</details> <details id="phase-17"> <summary><strong>Phase 17: Infrastructure & Production</strong> <code>11 lessons</code> &nbsp; <em>Ship AI to the real world.</em></summary>
#LessonTypeLang
01Model ServingBuildPython
02Docker for AI WorkloadsBuildPython, Rust
03Kubernetes for AIBuildPython
04Edge Deployment: ONNX, WASMBuildPython, Rust
05ObservabilityBuildTS, Rust
06Cost OptimizationBuildTS
07CI/CD for MLBuildPython
08A/B Testing & Feature FlagsBuildPython, TS
09Data PipelinesBuildPython, Rust
10Security: Red Teaming, DefenseBuildPython, TS
11Build a Production AI PlatformBuildPython, TS, Rust
</details> <details id="phase-18"> <summary><strong>Phase 18: Ethics, Safety & Alignment</strong> <code>6 lessons</code> &nbsp; <em>Build AI that helps humanity. Not optional.</em></summary>
#LessonTypeLang
01AI Ethics: Bias, FairnessLearn--
02Alignment: What & WhyLearn--
03Red Teaming & Adversarial TestingBuildPython
04Responsible AI FrameworksLearn--
05Privacy: Differential Privacy, FLBuildPython
06Interpretability: SHAP, AttentionBuildPython
</details> <details id="phase-19"> <summary><strong>Phase 19: Capstone Projects</strong> <code>5 projects</code> &nbsp; <em>Prove everything you learned.</em></summary>
#ProjectCombinesLang
01Build a Mini GPT & Chat InterfacePhases 1, 3, 7, 10Python, TS
02Build a Multimodal RAG SystemPhases 5, 11, 12, 13Python, TS
03Build an Autonomous Research AgentPhases 14, 15, 6TS, Python
04Build a Multi-Agent Dev TeamPhases 14, 15, 16, 17TS, Rust
05Build a Production AI PlatformAll phasesPython, TS, Rust
</details>

Course Output: The Toolkit

Other courses give you a certificate. This one gives you a toolkit.

Every lesson produces a reusable artifact -- a prompt, skill, agent, or MCP server that you can install and use immediately. By the end of the course you have:

outputs/
ā”œā”€ā”€ prompts/          Prompt templates for every AI task
ā”œā”€ā”€ skills/           SKILL.md files for AI coding agents
ā”œā”€ā”€ agents/           Agent definitions ready to deploy
└── mcp-servers/      MCP servers you built during the course

Install them with SkillKit. Plug them into Claude Code, Cursor, or any AI agent. These are real tools, not homework.


How Each Lesson Works

phases/XX-phase-name/NN-lesson-name/
ā”œā”€ā”€ code/           Runnable implementations (Python, TS, Rust, Julia)
ā”œā”€ā”€ docs/
│   └── en.md       Lesson documentation
└── outputs/        Prompts, skills, agents produced by this lesson

Every lesson follows 6 steps:

StepWhat happens
MottoOne-line core idea that sticks
ProblemA concrete scenario where not knowing this hurts
ConceptMermaid diagrams and intuition -- no code yet
Build ItImplement from scratch in pure Python. No frameworks.
Use ItSame thing with PyTorch, sklearn, or the real tool
Ship ItThe prompt, skill, or agent this lesson produces

The Build It / Use It split is the key. You understand what the framework does because you built it yourself first.


Getting Started

Option A: Just start reading

Pick any completed lesson from the website or the phase tables below.

Option B: Clone and run

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

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

Option C: Find your level (recommended)

If you already know some ML/DL, don't start from Phase 1. Use the built-in assessment:

# In Claude Code:
/find-your-level

This 10-question quiz maps your knowledge to a starting phase and builds a personalized path with hour estimates.

Prerequisites

  • You can write code (Python or any language)
  • You want to understand how AI actually works, not just call APIs

Who This Is For

You are...Start at...Time to complete
New to programming + AIPhase 0 (Setup)~290 hours
Know Python, new to MLPhase 1 (Math)~270 hours
Know ML, new to DLPhase 3 (Deep Learning)~200 hours
Know DL, want LLMs/agentsPhase 10 (LLMs from Scratch)~100 hours
Senior engineer, want agents onlyPhase 14 (Agent Engineering)~60 hours

Contributing

See CONTRIBUTING.md for how to add lessons, translations, and outputs.

Want to fork this for your team or school? See FORKING.md.

See ROADMAP.md for progress tracking (~290 hours, per-lesson time estimates).


<p align="center"> MIT License. Use it however you want. </p>

Global Ranking

8.5
Trust ScoreMCPHub Index

Based on codebase health & activity.

Manual Config

{ "mcpServers": { "rohitg00-ai-engineering-from-scratch": { "command": "npx", "args": ["rohitg00-ai-engineering-from-scratch"] } } }