Applied Agentic AI Pipelines with LangChain Course

Lesson 1 • Core Components of Agent Architecture

Breaks down the four pillars: memory, tools, planning, and action execution. Shows how each pillar maps to LangChain abstractions introduced later.

Lesson 2 • Agentic Pipeline Mental Model

Introduces the end-to-end pipeline view: input, orchestration, tool calls, and output. Prepares students to map LangChain components onto this skeleton.

Lesson 3 • LLMs as Reasoning Engines

Explains how large language models supply reasoning capacity inside agents. Covers token limits, context windows, and prompt sensitivity as engineering constraints.

Lesson 1 • Chains, Prompts, and Output Parsers

Introduces PromptTemplate, LLMChain, and output parsers as the atomic building blocks. Demonstrates composing them into a minimal working chain.

Lesson 2 • LangChain Ecosystem Overview

Maps the LangChain library family: core, community, and integrations packages. Clarifies which package to import for each use case.

Lesson 3 • Callbacks and Observability Hooks

Explains LangChain's callback system for logging, tracing, and monitoring chain execution. Connects to LangSmith tracing introduced in supplementary chapters.

Lesson 4 • Environment Setup and Configuration

Walks through Python environment creation, dependency installation, and API key management. Establishes a reproducible local dev setup for all subsequent chapters.

Lesson 1 • Document Loading and Splitting

Covers LangChain document loaders for PDFs, web pages, and databases, plus text splitters. Proper chunking directly affects retrieval quality downstream.

Lesson 2 • Building the RAG Chain

Assembles retriever, prompt, and LLM into a complete RAG chain using LCEL. Demonstrates source citation and context injection patterns.

Lesson 3 • Evaluating and Optimising RAG

Applies faithfulness, relevance, and groundedness metrics to measure RAG quality. Covers chunk tuning, re-ranking, and hybrid search as optimisation levers.

Lesson 4 • Retriever Patterns and Configurations

Introduces retriever abstractions: similarity, MMR, and self-query retrievers. Shows how retriever choice shapes answer relevance and diversity.

Lesson 1 • Built-in and Community Tools

Surveys LangChain's built-in tools: search, calculator, and shell, plus community integrations. Demonstrates loading and configuring ready-made tools quickly.

Lesson 2 • LLM Function Calling Integration

Connects LLM-native function calling APIs to LangChain's tool-binding interface. Shows how the model selects and invokes tools via structured JSON output.

Lesson 3 • Tool Abstraction in LangChain

Defines the Tool and StructuredTool classes and their required fields. Explains how agents discover and select tools at runtime.

Lesson 4 • Building Custom Tools

Guides students through wrapping any Python function as a LangChain tool with proper schemas. Custom tools extend agent capability to proprietary APIs and data.

Lesson 1 • Memory Integration in Agents

Adds conversational and entity memory to agents for multi-turn task continuity. Covers buffer, summary, and vector-backed memory strategies.

Lesson 2 • Configuring and Running Agents

Demonstrates AgentExecutor configuration: max iterations, early stopping, and verbose mode. Connects executor settings to reliability and cost control.

Lesson 3 • Agent Taxonomy in LangChain

Surveys zero-shot ReAct, structured chat, OpenAI functions, and plan-and-execute agents. Clarifies when each type outperforms the others.

Lesson 4 • Agent Prompt Engineering

Teaches system prompt design patterns that improve agent reliability and reduce hallucination. Covers persona, constraint, and output format instructions.

Lesson 1 • Conditional Edges and Dynamic Routing

Uses conditional edge functions to route graph execution based on state values. Enables branching, retry loops, and human-in-the-loop checkpoints.

Lesson 2 • Supervisor and Worker Agent Patterns

Implements a supervisor node that routes tasks to specialised worker agents. Covers delegation logic, result aggregation, and loop prevention.

Lesson 3 • Building Single-Agent Graphs

Converts a ReAct agent into a LangGraph node with tool-call edges. Establishes the graph-building pattern before adding multiple agents.

Lesson 4 • LangGraph Architecture and Concepts

Introduces StateGraph, nodes, edges, and the shared state object as LangGraph primitives. Contrasts graph-based orchestration with linear chain execution.

Lesson 1 • LangServe for API Deployment

Uses LangServe to expose chains and agents as FastAPI endpoints with auto-generated schemas. Covers route configuration, input validation, and playground UI.

Lesson 2 • Health Checks and Graceful Shutdown

Implements liveness and readiness probes and graceful shutdown handlers for agent services. Ensures zero-downtime deployments and clean resource release.

Lesson 3 • Secrets and Configuration Management

Secures API keys and model configs using environment-based and vault-based secret management. Prevents credential leakage in containerised deployments.

Lesson 4 • Containerisation with Docker

Packages the LangChain application into a Docker image with proper dependency pinning. Ensures environment parity between development and production.

Lesson 1 • Structured Logging and Metrics

Emits structured JSON logs and custom metrics from agent pipelines to observability platforms. Enables dashboards, alerts, and SLA tracking in production.

Lesson 2 • Continuous Improvement Workflows

Establishes feedback loops: collecting user signals, rerunning evaluations, and updating prompts or retrievers. Operationalises ongoing pipeline quality management.

Lesson 3 • Tracing with LangSmith

Connects LangSmith to capture full execution traces of chains and agents. Traces expose token usage, latency, and tool call sequences for debugging.

Lesson 4 • Automated Pipeline Evaluation

Runs LangSmith evaluation datasets and custom evaluators to score pipeline outputs automatically. Catches regressions before they reach production users.