AI Engineering in 8 Weeks: Intro & Production Environment Setup

This introductory module lays the foundation for becoming an industry-ready AI Engineer. Created by Pratyush Narayan (IIT graduate and SDE-2 at Akamai), this course cuts through the noise of overly mathematical research courses and shallow wrapper tutorials by taking a strictly reverse-engineered approach based on modern technical interview requirements.

1. Why Another AI Course? (The Landscape & Reverse-Engineering)

The current landscape of Artificial Intelligence education is heavily polarized into two unhelpful extremes:

The Reverse-Engineered Methodology

This course abandons both extremes. Instead of following an academic syllabus, the curriculum is reverse-engineered from real-world AI engineering interviews:

• Interview-Driven Curriculum: Every concept taught directly maps to questions asked in AI engineering interviews for freshers, working professionals, and engineers transitioning from service-based companies.
• Production Context: If industry interviews require candidates to understand heap data structures or vector indexing for Retrieval-Augmented Generation (RAG), the curriculum allocates dedicated modules specifically to master those exact requirements.
• Zero Cost & Pragmatic: Designed to be executed with $0 expenditure, requiring only a laptop, an internet connection, and a rough notebook.

2. Ideal Audience, Non-Goals, and Essential Prerequisites

Targeted Audience

• College Students: Beginners with zero prior exposure to AI or advanced Data Structures & Algorithms (DSA).
• Early Career Professionals (1–3 YOE): Software engineers seeking a domain switch to AI/ML engineering.
• Service-Based Engineers: Developers aiming to transition into AI product engineering or lead AI initiatives within their organizations.

Explicit Non-Goals

Note: This course is not an academic Machine Learning or PhD-level Deep Learning course. It will not cover raw calculus, backpropagation proof derivations, or training foundation models from scratch. If your goal is to publish AI research papers or build foundational model architectures (e.g., working at Anthropic on fundamental model architectures), this curriculum is not intended for you.

Course Prerequisites

• Hardware: Any basic laptop (even standard 4 GB / 8 GB RAM machines; high-end GPUs are not required).
• Python Basics: Understanding basic data structures (lists, tuples, dictionaries, variables).

3. The 8-Week AI Engineering Roadmap

The curriculum spans 8 weeks (40 to 45 episodes), progressing from fundamental concepts to full-stack autonomous AI systems deployed in production.

4. Local LLMs (Ollama) vs. Cloud Infrastructure (Groq & Qdrant)

Many beginner AI tutorials rely on running local LLMs via tools like Ollama. However, local execution introduces severe hardware bottlenecks for student environments.

The Ollama Problem on Standard Hardware

Running open-weight models locally requires substantial VRAM and system memory. On non-gaming, dual-core, or 4GB/8GB RAM laptops, local models suffer from high latency, thermal throttling, or outright execution crashes.

The Production-Grade Cloud Stack

To ensure 100% execution consistency across all student environments without requiring dedicated graphics cards (e.g., NVIDIA RTX series), this course utilizes cloud-hosted infrastructure for inference and storage.

5. Environment Setup: Core Runtime & Development Tools

The local environment setup relies on standard industry developer tooling configured specifically for Windows (with identical workflows for macOS/Linux).

1. Python Installation

1. Download the latest Python installer (3.12 or newer) from the official Python website.
2. Run the installer executable.

Critical Step: Ensure the "Add python.exe to PATH" checkbox is selected during installation. If PATH is not configured, terminal commands will fail to locate the interpreter.

Verify installation via PowerShell:

python --version

2. VS Code & Extension Setup

1. Download and install Visual Studio Code.
2. Open VS Code and navigate to the Extensions tab (Ctrl + Shift + X).
3. Search and install the following official extensions published by Microsoft:
   • Python: Core support for debugging and linting.
   • Pylance: High-performance language support and type checking.
   • Jupyter: Enables native interactive notebook support (.ipynb).

3. Git Version Control Setup

1. Download and install Git for Windows/Mac.
2. Complete the setup wizard using default configuration values.
3. Verify installation in PowerShell:

git --version

4. Set global Git credentials:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

5. Verify configuration:

git config --global --list

6. Fast Package Management: Transitioning to UV

Traditional Python development uses pip for package resolution, which can be slow and inefficient when handling complex AI dependency trees. This course standardizes on UV, an extremely fast Python package installer written in Rust.

Installing UV

Run the installation command in PowerShell:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Close and reopen PowerShell, then verify installation:

uv --version

7. Provisioning Cloud AI Infrastructure (Groq & Qdrant)

1. Groq Cloud API Provisioning

Groq provides ultra-low latency LLM inference using proprietary Language Processing Units (LPUs).

1. Navigate to the Groq Console.
2. Authenticate using Google OAuth.
3. Navigate to API Keys -> Select Create API Key.
4. Enter a key descriptor (e.g., padho_with_pratyush).
5. Copy the generated key immediately and store it in a temporary text editor.

Warning: Groq API keys are shown only once upon generation. If lost, the key cannot be retrieved and a new key must be generated.

2. Qdrant Cloud Vector Database Setup

Qdrant is a high-performance vector database critical for storing embeddings during RAG implementation.

1. Navigate to Qdrant Cloud.
2. Register/Login using Google OAuth.
3. Select Clusters -> Click Create Free Cluster.
4. Provide a Cluster Name (e.g., padho_with_pratyush) and select the default cloud provider (AWS).
5. Click Create Free Cluster.
6. Securely record two items:
   • API Key
   • Cluster Endpoint URL (e.g., https://<cluster-id>.us-east-1-0.aws.cloud.qdrant.io:6333)

8. Secure Configuration & Secret Management (.env Setup)

Never hardcode secret keys directly inside source code. All credentials must be injected into the runtime environment via an encrypted or isolated environment configuration file (.env).

Workspace Initialization Walkthrough

Execute the following directory build-out in PowerShell:

# 1. Navigate to user home directory
cd C:\Users\<YourUsername>

# 2. Create main project root folder
mkdir padho_with_pratyush

# 3. Step into root directory
cd padho_with_pratyush

# 4. Create first weekly module directory
mkdir week1

# 5. Initialize .env file using Notepad
notepad .env

Structuring the .env File

In the opened Notepad window, populate your secret variables using exact key-value formatting (NO spaces, NO quotes, NO trailing commas):

GROQ_API_KEY=gsk_your_actual_groq_api_key_here
QDRANT_URL=https://your-cluster-endpoint.cloud.qdrant.io:6333
QDRANT_API_KEY=your_actual_qdrant_api_key_here

Save (Ctrl + S) and close Notepad.

Security Isolation Rule

Open the project inside Visual Studio Code:

code .

VS Code will launch displaying both the .env secret file and the week1 folder in the primary explorer panel.

9. Complete Setup Walkthrough & Verification Pipeline

Terminal Diagnostics

If any step during installation raises a path or environment error, use AI tools (ChatGPT or Claude) to quickly diagnose OS-specific path issues by providing the raw terminal error log.

To confirm that your workstation environment is fully configured for Episode 02 onwards, execute the system verification pipeline:

# 1. Verify Python Interpreter
python --version

# 2. Verify UV Package Manager
uv --version

# 3. Verify Git Core
git --version

# 4. Verify VS Code CLI
code --version

When all commands output valid semantic version strings without errors, the development workstation setup is officially complete.

Summary and Key Takeaways

• Interview-Oriented Focus: The course is explicitly reverse-engineered from real-world AI engineering interview requirements, bypassing unnecessary mathematical proofs and superficial clickbait projects.
• Pragmatic Scope: Designed for developers, college students, and switching professionals. Does not target academic PhD researchers or fundamental deep learning math.
• Low System Overhead: Replaces resource-heavy local LLMs (Ollama) with high-speed, free cloud infrastructure (Groq for LLM inference and Qdrant for Vector DB operations).
• Modern Tooling Stack: Adopts Rust-backed UV for package resolution alongside standard Python, Visual Studio Code, and Git.
• Strict Secret Hygiene: Enforces secure credential isolation using root-level .env configuration files to prevent API key leakage.
• Structured Learning Path: A structured 8-week path transitioning from basic LLM integration to autonomous agents, RAG pipelines, and full-stack production deployments.