What you'll learn

• Large Language Model (LLM)A large language model is a deep learning system based on the transformer architecture trained on enormous collections of text that generates coherent, contextually appropriate language.
• Context WindowThe maximum number of tokens a model can process at once, encompassing the system prompt, conversation history, input data, and generated response.
• PromptingThe practice of crafting input text to an LLM in order to guide it toward a desired output without changing the model's parameters.
• HallucinationThe tendency of a language model to produce text that sounds confident and coherent but is factually wrong, fabricated, or entirely made up.
• LLM AgentsA system in which a language model acts as an autonomous reasoning engine that can plan, take actions, observe results, and iterate over multiple steps to complete goals.
• Prompt EngineeringPrompt engineering is the systematic practice of designing, testing, and iterating on prompts to reliably produce high-quality outputs from a language model.
• Retrieval-Augmented Generation (RAG)A technique that retrieves relevant documents from an external information store at inference time and inserts them into the model's context, allowing the model to answer questions by reading and synthesizing provided passages rather than relying on memorized facts.
• Cost and Latency ManagementThe practices and tradeoffs involved in controlling API expenses and response time when deploying LLMs in production systems.
• TokenizationThe process that converts human-readable text into numerical representations by breaking it into subword pieces that are smaller than words but larger than individual characters.
• Fine-TuningThe process of continuing training on a pre-trained LLM with a smaller, task-specific dataset to adjust its behavior in a targeted way.
• LLM EvaluationThe discipline of systematically measuring the quality, accuracy, and reliability of a language model's outputs for a specific task.
• Tool Use / Function CallingThe ability of an LLM to request the execution of external functions or APIs as part of generating a response by emitting structured tool calls instead of relying only on its training data.
• Safety and Content ModerationThe collection of techniques used to prevent language models from producing harmful, offensive, factually dangerous, or policy-violating outputs when deployed in real applications.
• Prompt TemplatesA prompt template is a reusable prompt structure containing static text combined with named placeholders that are filled in dynamically at runtime.
• LLM API IntegrationThe practice of sending prompts programmatically to a language model provider's web service and parsing structured responses in your application code.
• Few-Shot PromptingA technique where you include a small number of worked input-output examples directly in the prompt to steer the model toward a specific format, style, or reasoning pattern without retraining.
• ReAct PatternAn agent design pattern in which a language model alternates between Thought steps (reasoning about the situation) and Action steps (calling a tool), receiving Observations after each action until the task completes.
• Chain-of-Thought PromptingA technique that guides a language model to explicitly write out its reasoning steps before producing a final answer, improving performance on multi-step problems.
• EmbeddingsA numerical representation that converts text into a vector of real numbers such that semantically similar texts produce vectors that point in similar directions.
• System PromptA special instruction given to an LLM before the user's message that sets the context, constraints, persona, or behavioral guidelines for the entire conversation.
• Instruction Fine-TuningA supervised fine-tuning process that trains a pretrained model on instruction-response pairs to recognize and follow explicit directions.
• Structured Output GenerationA set of techniques that constrain an LLM to produce machine-readable results in predictable formats like JSON objects or specific schemas rather than free-form text.
• GroundingA set of techniques that anchor an LLM's responses to verified, external, or explicitly provided factual information to reduce hallucination.
• Multi-Step Task PlanningMulti-step task planning is an agent's ability to decompose a complex, high-level goal into an ordered sequence of concrete subtasks that achieve that goal when executed correctly.
• Prompting vs. Fine-Tuning TradeoffsA comparison of two approaches to shaping model behavior: prompting (which adapts the input), which is instant and reversible but token-costly at inference, and fine-tuning (which updates weights), which requires upfront GPU time and labeled data but may reduce token costs later.
• Fine-Tuning Dataset PreparationThe process of creating and structuring high-quality training examples with instructions, responses, and optional context that will determine the effectiveness of a fine-tuned model.
• Agent MemoryMechanisms that enable an agent to retain and recall information across multiple steps or sessions so it can maintain context, avoid repetition, and work toward goals coherently.
• Vector DatabaseA specialized database optimized for storing and searching high-dimensional embedding vectors by semantic similarity rather than exact matching.
• Temperature and SamplingParameters that control the probability distribution over token choices, allowing you to trade off between predictable, focused output and more creative, varied responses.
• Code Generation and ExecutionThe capability for an LLM to write code in response to descriptions and then run that code to inspect results and inform subsequent actions.
• Web Browsing ToolA capability that enables an LLM-based agent to fetch and read live internet content to access information beyond its training data cutoff.
• LLM Output ParsingLLM output parsing is the process of taking the free-form text that a language model returns and converting it into a structured representation that downstream code can operate on reliably.
• Zero-Shot PromptingThe practice of asking a language model to perform a task based solely on a plain-language instruction, without providing worked examples.