Learn Generative AI

01 Python essentials The programming language nearly all AI tooling is written in and driven from. Core 02 HTTP, APIs & JSON The way programs talk to each other over the internet - and the way you will talk to every AI model. Core 03 Git, terminal & environments Version control for your code, the command line to run it, and isolated environments so projects don't collide. Core 04 The vocabulary: 15 terms you'll see everywhere A one-line dictionary of the words the whole field assumes you already know. Core

01 What is an LLM A large language model is a program trained on huge amounts of text to predict the next token - and that one trick, scaled up, produces reasoning, coding and conversation. Core Deep dive 02 Tokens & tokenization Models don't read words or letters - they read tokens, chunks of ~4 characters, and every cost, limit and quirk traces back to them. Core 03 Context window The maximum number of tokens a model can consider at once - its entire working memory, including your prompt, the history, and its answer. Core 04 Inside the model: attention, in 10 minutes The transformer architecture processes all tokens in parallel and uses 'attention' to let every token look at every other token and decide what matters. 05 Temperature & sampling The dials that control how the model picks the next token from its probability list - the difference between deterministic and creative output. Core 06 Closed vs open-weight vs self-hosted The three ways to get a model: rent a closed one via API, use an open-weight one someone hosts for you, or run open weights on your own machines. Core 07 Choosing the right model Picking a model is balancing four axes - quality, cost, latency, context size - for your specific task, not finding 'the best model'. Core 08 Cost & pricing mechanics You pay per million tokens, input and output priced separately - and architecture decisions, not usage volume, dominate the bill.

01 Chat & Messages APIs: roles and turns The standard request format for every LLM: a list of messages, each with a role (system / user / assistant), sent fresh on every call. Core Deep dive 02 System prompts The standing instructions that define the model's job, personality, rules and boundaries - set by you, invisible to the user. Core 03 Streaming responses Receiving the answer token-by-token as it's generated, instead of waiting for the whole thing - the difference between a live app and a frozen one. Core 04 Structured output (JSON mode) Forcing the model to answer in an exact machine-readable shape - usually JSON matching a schema - so code can consume it. Core 05 Tool use / function calling Letting the model request actions - search, calculate, query a database - by emitting structured calls to functions you define and execute. Core 06 Prompt caching Providers cache the unchanged prefix of your prompt so repeated calls reprocess it at ~10% of the price and much lower latency. 07 Errors, rate limits & retries Model APIs fail routinely - overloaded servers, rate limits, timeouts - and production code must expect, absorb and recover from all of it. Core

01 Zero-shot & few-shot prompting Zero-shot = just ask. Few-shot = show 2-5 worked examples in the prompt so the model imitates the pattern instead of guessing your intent. Core Deep dive 02 Chain of thought & reasoning models Getting the model to work through a problem step-by-step before answering - either by prompting it to, or by using models trained to reason internally. Core 03 Role, context & constraints The workhorse prompt structure: who the model is (role), what it needs to know (context), and the exact boundaries of an acceptable answer (constraints). Core 04 Prompt engineering vs context engineering Prompt engineering crafts the instructions; context engineering builds the systems that decide what information fills the model's window at runtime. 05 Testing & iterating on prompts Treating prompts as code: versioned, tested against a fixed set of cases, and changed one variable at a time. Core

01 What are embeddings An embedding turns text into a list of numbers (a vector) positioned so that similar meanings land close together in space. Core 02 Similarity metrics The math for 'how close are two vectors' - cosine similarity, dot product, Euclidean distance - and it matters less than you fear. 03 Embedding models Dedicated models (not chat LLMs) that produce embeddings - you choose by quality-per-dollar, dimension size, and language support. Core 04 The NLP pipeline, end to end The sequence of steps that turns raw text into something a model can actually use. Deep dive 05 Chunking strategies Splitting documents into right-sized pieces before embedding - the humble step that quietly decides retrieval quality more than any model choice. Core 06 Vector databases Databases purpose-built to store millions of embeddings and answer 'find the K nearest vectors to this one' in milliseconds. Core 07 Build: semantic search end-to-end The rite-of-passage build: ingest documents -> chunk -> embed -> index -> query - the complete retrieval pipeline that RAG will sit on. Core

01 What is RAG & why it exists RAG = retrieve relevant documents for the user's question, paste them into the prompt, and instruct the model to answer only from them. Core 02 The RAG pipeline, end to end Wiring ingestion and query-time retrieval into one system, where overall quality is the product of every stage's quality. Core Deep dive 03 Hybrid search & reranking Combine semantic search with old-school keyword search (hybrid), then have a smarter model re-order the candidates (reranking) - the two standard upgrades when plain RAG plateaus. 04 RAG vs fine-tuning RAG adds knowledge at question-time; fine-tuning adjusts behavior at training-time. The eternal interview question, settled by one distinction. Core 05 Evaluating & debugging RAG Scoring retrieval and generation separately - did we fetch the right chunks? did we answer faithfully from them? - because a single 'is it good?' hides which half is broken. Core Deep dive

01 What is an agent, really An agent is an LLM wrapped in a loop that can choose actions and use tools. Core Deep dive 02 Tools and function calling Tool calling lets a model request structured actions that your code executes. Core 03 Agent memory Memory is selected context from prior turns or external stores that helps an agent continue work.

01 LangChain core: messages, prompts and chains LangChain is a framework for composing LLM apps from Chat Model calls, Prompt Template objects, messages, parsers, tools and retrievers. Core Deep dive 02 Output parsers and structured responses An Output Parser turns model text into the shape your app expects: plain strings, JSON Output, validated objects or Structured Output. Core 03 Documents, loaders and text splitters A Document is text plus Metadata, usually created by a Document Loader and broken into Chunk objects by a Text Splitter. Core 04 Retrievers and RAG chains A Retriever turns a query into relevant Source Documents using embeddings, vector search and ranking strategies. Core 05 Agent executor, ReAct and toolkits An Agent Executor runs an Agent loop: Reasoning chooses an Action, a Tool runs, an Observation returns, and Decision Making selects the next step. Core 06 LangGraph state, nodes, edges and checkpoints LangGraph is a framework for stateful AI workflows built from Node functions connected by Edge rules over shared State. Core 07 Agentic AI goals, tasks and context Agentic AI is AI that works toward a Goal by breaking it into Tasks, choosing Actions, reading Observations and updating State inside an Environment. Core 08 Reflection and advanced reasoning patterns Advanced agents improve answers by using Reflection, Self-Correction, Self-Verification and structured reasoning patterns. 09 Agent memory types and updates Agent memory includes Working Memory for the current reasoning step, Short-Term Memory for the current task and Long-Term Memory across sessions. 10 Agent design patterns Agent design patterns describe how agents are arranged: Single-Agent Pattern, Multi-Agent Pattern, Planner-Executor Pattern, Supervisor Pattern, Router Pattern, Swarm Pattern, Hierarchical Agents and Blackboard Pattern. 11 Multi-agent routing and ops Multi-Agent systems coordinate specialized agents through a Router, Supervisor Agent, Worker Agent roles, fallback paths, guardrails and tracing. Core

01 AI app architecture A production AI app is a normal app with a model behind a protected backend. Core 02 Latency and cost engineering The craft of making AI responses faster and cheaper without ruining quality. Core 03 Prompt injection and AI security Prompt injection is malicious instruction text hidden inside data the model reads. Core 04 Deployment, privacy and responsible AI The checklist for shipping AI without losing secrets, data, money, or user trust. Core 05 Capstone production AI product One deployed project that combines retrieval, tools, evals, security, cost tracking, and documentation. Core