The 40-hour Agentic AI Engineering program assumes working Python — but "working Python" covers a lot of ground. This module starts from the language basics and carries you all the way to the exact patterns your first agent call will use: typed data, async API calls, and tool-calling schemas. Whether you're properly new to Python or just rusty, start at Block A and work forward; if you're already fluent, skip ahead using the checklist below. Before Weekend 1, not instead of it.
Variables, data types, control flow, strings, and the core collections — no prior Python assumed.
Functions, classes, error handling, decorators & context managers — how real Python projects are structured.
Virtual envs & dependency management, type hints, dataclasses, Pydantic models, JSON.
async/await, asyncio, calling REST APIs, parsing responses — the shape every agent tool call takes.
Tool-calling schemas, structured output, logging & a first look at testing — the bridge into Session 01.
New to Python, or checked 2 or fewer? Start at Block A and work straight through. Checked most of these? Skim Blocks A–C and spend your time on D and E — that's where the agentic-specific patterns live.
Work through the blocks in order, at your own pace, any time before Weekend 1. Blocks A–C build general Python fluency; D and E are where the language starts looking like the code you'll write in the main program.
Start here if Python is new to you, or it's been years. No frameworks, no APIs — just how the language itself stores data and expresses logic, so everything after this block has somewhere to land.
Topics: Variables & dynamic typing · core data types (int, float, str, bool, None) · operators & expressions · control flow (if/elif/else, for, while) · strings & f-strings · lists, tuples, dicts & sets · list/dict/set comprehensions · basic input & output
Agent code is organized as small, composable functions and classes — tools, nodes, handlers. This block is where you get fluent writing code that other code (and other developers) can call.
Topics: Functions — positional/keyword args, defaults, *args/**kwargs · lambdas & first-class functions · scope & closures · classes — attributes, methods, inheritance, dunder methods · modules, packages & imports · exceptions — try/except/finally, raising & custom exceptions · decorators · context managers (with)
Every agent framework leans on structured, validated data — tool schemas, retrieved documents, model responses. This is where Python stops being "just scripts" and starts looking like production code.
Topics: Virtual environments & dependency management (venv, uv, pip) · project structure & imports · type hints, from basics to generics · dataclasses vs. Pydantic models · reading, validating & serializing JSON · environment variables & config (.env)
Every call to an LLM, a tool, or a retriever is an HTTP request under the hood — usually an async one. This block is the exact mechanics your first agent call will use.
Topics: Sync vs. async execution · async / await & the event loop · asyncio.gather for concurrent calls · calling REST APIs with httpx / requests · timeouts, retries & basic error handling · streaming responses
The bridge block. Everything above, combined into the exact shape of a real agent call — so Session 01 of the main program feels like a continuation, not a cold start.
Topics: Anatomy of an LLM / chat-completion API call (messages, roles, parameters) · describing a Python function as a function/tool-calling schema · parsing structured/JSON output from a model response · basic logging for debugging a multi-step call · a first look at automated testing (pytest) for checking agent behavior
→ Once Block E's mini lab feels comfortable, you're ready for Session 01 — Agentic Architecture & Microsoft Foundry of the main 40-hour program, where this same async/API/schema pattern becomes your first LangChain agent call.