Complete Agentic AI Bootcamp With LangGraph and Langchain

Install Anaconda and VS Code to set up a Python data science IDE, manage environments with conda, set path variables, and launch code and Jupyter notebooks from a project folder.

Create and manage virtual environments with conda, specifying python 3.12, activating the venv, and installing packages from a requirements.txt file using pip.

Learn to set up a Python environment in VS Code, create a conda venv with Python 3.12, install ipykernel, and run Jupyter notebooks with kernel detection and code cells.

Explore Python syntax and semantics by examining how comments, case sensitivity, and indentation define code structure. Understand variable assignment, type inference, line continuation, and common syntax errors with practical examples.

Declare and assign variables in Python, master naming conventions and data types, and perform type checking and conversion through practical examples, including input and a simple calculator.

Explore the fundamentals of data types in Python, including integers, floats, strings, and booleans; learn type casting, common errors, and foundational operations.

Learn how to perform arithmetic, comparison, and logical operations in Python using operators like +, -, *, /, //, %, **, and ==, with practical examples and a simple calculator.

Explore control flow in Python by mastering conditional statements — if, elif, and else — including nested conditionals, real-world examples, common errors, and best practices.

Explore Python loops, including for and while loops, range-based iteration, and loop control statements like break, continue, and pass, with nested loops and practical examples to avoid common errors.

Explore Python lists by creating, accessing, and modifying items, then apply list methods such as append, insert, remove, and pop; master slicing, iteration, and list comprehension with nesting.

Explore real-world Python list use cases, from to-do lists and inventory management to student grades, employing append, remove, membership checks, and simple summaries.

Learn how to use Python sets to store unique items, test membership, and perform union, intersection, difference, and symmetric difference, with practical examples of creating, updating, and counting unique words.

Explore dictionaries in Python, learning how to create, access, modify, and iterate over dictionaries, including nested dictionaries and dictionary comprehension, with practical examples and common errors.

This lecture explains tuples in Python, covering creation, accessing elements, concatenation, repetition, and slicing; explains immutability, packing and unpacking, common methods count and index, and nested tuples.

Explore how functions organize code, enable reuse, and improve readability in Python. Define and call functions, learn syntax and parameters (default, positional, and keyword), use docstrings, and return values.

Explore practical Python function examples, from temperature conversion and password strength checking to shopping cart total cost, palindrome tests, recursion, file word frequency, and email validation.

Master Python lambda functions, small anonymous functions defined with lambda that takes multiple arguments but a single expression, used for quick operations and as arguments to map and filter.

Explore how the map function in Python applies a function to items in an iterable, returning a map object and transforming data with square, lambda, multiple iterables, and built-in functions.

Master the Python filter function to build an iterator that selects items from a list or dictionary based on a condition, using functions and lambda expressions.

Explore how to use Python modules and packages, import functions, install NumPy, and build custom packages with __init__.py to organize and reuse code.

Explore Python file operations, including reading and writing text and binary files, using with open, r, w, a, and w+ modes, and line-by-line reading.

Create and manage directories, list files, and join paths using the OS module, while checking existence, distinguishing files and directories, and resolving absolute and relative paths.

Master Python exception handling using try, except, else, and finally blocks to gracefully manage name error, zero division error, file not found error, value error, and type error.

Learn object oriented programming in Python by building classes and objects, using constructors and instance variables, and modeling real world actions like deposit and withdraw in a bank account.

Discover how Python implements inheritance in object-oriented programming, using single inheritance with a car and Tesla, and multiple inheritance with a dog from animal and pet, via init and super.

Explore polymorphism in object-oriented programming by using method overriding and interfaces, with abstract base classes and practical Python examples like shapes and animal classes.

Explore how encapsulation and abstraction in Python bundle data and methods into a single unit, using public, protected, and private variables, and getter and setter methods to access private data.

Explore abstraction in Python and OOP concepts by hiding complex implementation behind abstract classes and methods, using a vehicle example to show how derived classes implement start engine and drive.

Explore Python magic methods, or dunder methods, and learn how to define object behavior for built-in operations such as arithmetic and comparison, including customizing __init__, __str__, and __repr__.

Explore operator overloading in Python by overriding magic methods such as __add__, __sub__, __mul__, and __eq__ in a vector class, enabling custom arithmetic, comparisons, and readable output.

Create and raise custom exceptions in Python, using a generic error class and a date-of-birth exception, then validate input with try-except around an age check to enforce the 20-30 range.

Learn how iterators in Python enable efficient looping and memory management by accessing list elements lazily, using next and handling stop iteration.

Explore generators in Python, using yield to create memory-efficient iterators that lazily generate values, with examples like squaring numbers and reading large files, and compare iterators vs generators.

Explore decorators in Python, including function copy and closures, to modify function behavior and add functionality without changing original code.

Explore numpy, the fundamental Python library for scientific computing, to create and reshape arrays and matrices with vectorized operations, including arange, ones, and identity matrix.

Explore pandas data frames and series for data analysis, reading CSV files, and manipulating tabular data with creation from dictionaries, indexing, adding and dropping columns, and getting a statistical summary.

Learn data manipulation with pandas for exploratory data analysis, including reading csv files, handling missing values, describing data, and using grouping, aggregation, and merging.

Learn to read data from JSON, CSV, HTML, and Excel sources using pandas read_json, read_csv, read_html, and read_excel, and convert formats with to_json and orient options like index and records.

Learn to implement practical Python logging using the built-in module: configure basicConfig, manage levels (debug, info, warning, error, critical), format logs, and route output to app.log, with file-based examples.

Create multiple loggers for different modules and set their levels, such as module one with debug and module two with warnings. Log messages using module-specific loggers to achieve module-scoped output.

Implement multi-logger logging in a Python app using file and stream handlers to log arithmetic operations to app1.log with module-specific loggers and division by zero error messages.

Explore Pydantic, a fast, extensible Python data validation library using type hints, and see how it validates API responses and serializes data with FastAPI and LangGraph and Langchain.

Explore practical data validation with Pydantic by building base models, inheriting to create person and employee schemas, and handling optional fields, lists, and nested models.

Get started with LangChain and OpenAI by setting up key modules: prompt templates, models, and output parsers; build a sample app and monitor with Lang Smith via OpenAI API key.

Explore the essential LangChain components for building Rag apps, including data ingestion from diverse sources, chunking, embeddings, vector stores, and retrieval chains to power a prompt-driven AI assistant.

Explore data ingestion with LangChain document loaders, and implement practical steps to load data into documents. See text, pdf, xml, web pages, arXiv, and Wikipedia loaders in action.

Learn to convert documents into text chunks to fit context size limits using a recursive character text splitter in long chain, with chunk size, overlap, and document conversion.

Explore text splitting techniques with Langchain, comparing recursive character text splitter and character text splitter, focusing on separators and chunk size measured by characters.

Split content with the HTML header text splitter to use H1, H2, and H3 tags and metadata, enabling semantically grouped, context-rich chunks in LangChain workflows.

Use a depth-first recursive json splitter to split json data into chunks with configurable min and max sizes, preserving nested objects and enabling llm processing.

Explore OpenAI embeddings to convert text chunks into vectors using three approaches—OpenAI library, Olama, and Hugging Face—then store them in a chroma vector store and perform similarity search.

Explore Ollama embeddings to run open source models like llama and gamma locally, create document and query embeddings, and build a rag application with LangChain.

Explore embedding techniques with hugging face, including sentence transformer embeddings and open source models, and set up api key and environment variables to enable end-to-end generative AI applications using langchain-hugging-face.

Explore vector stores in LangChain using files, chroma db, and Astra db; learn to ingest, split, and embed with llama embeddings, then perform similarity search and retrieval.

Learn to use Chroma DB vector stores in LangChain, build a vector store from split text with llama embeddings, run similarity searches, and persist the database for retrieval.

Discover building blocks of Langchain, including prompt templates, chat prompt templates, and chains, while configuring environment variables and Lang Smith tracking for OpenAI integration.

Explore querying a vector store DB with similarity search to retrieve page content and context for questions. Build retrieval and document chain with LangChain and GPT-4 for context-aware answers.

Explore running open source large language models locally with Ollama, download and set up on your operating system, and build a generative AI app.

Create an end-to-end genai app using Ollama and open-source models within LangChain, Streamlit, and prompt templates, loading local llama two and gamma models without OpenAI keys.

Track genai app workflows with LangSmith while running a local gamma model via Allama, using Llama 3 and the string output parser, all with zero OpenAI cost.

Get started with open source models using Grok API and LangChain. Build a simple LM application by chaining components with the LangChain expression language, using prompts and output parsers.

Discover building an llm app with LangChain core, using system and human messages, prompt templates, and string output parsers to chain the model and prompts for English to French translation.

Deploy the langchain LM application as rest APIs with Lang serve and fast API. Create runnables and chains as endpoints using prompts, parsers, and uvicorn setups.

Design and implement an llm-powered chatbot using LangChain, enabling ongoing conversations that remember previous interactions through a message history system and session-specific context.

Learn to build a chatbot with LangChain using prompt templates and a message placeholder to structure user input, add a system message, and manage session history and chat history.

Learn to manage chat conversation history in LangChain by trimming messages, preserving system prompts, controlling max tokens, and applying memory strategies within chains.

Learn how LangChain uses vector stores and retrievers to fetch data for LLMs, create documents and embeddings, and implement retrieval augmented generation with chroma.

Differentiate AI agents from agentic AI, shifting from single task bots to a network of collaborating agents that learn and use perception, reasoning, action, and learning to make autonomous decisions.

Explore how agentic AI systems using LangGraph and Langchain automate software development workflows, from requirements gathering and sprint planning to testing, code review, and human feedback in the loop.

Explore Langchain updates v1, including syntax, creating agents, integrating models, calling tools, and structured outputs, plus middleware and guardrails, while learning to set up environments with the UV package manager.

Create and activate a virtual environment with the UV package manager, install Lang chain libraries via a requirements.txt file, and configure API keys for project readiness.

Learn to create autonomous agents using LangChain v1, define tools like a weather function, and invoke the agent to call tools and generate context-based outputs.

Learn how to integrate LLM models in LangChain with OpenAI, Google Gemini, and Grok, by loading API keys, initializing chat models, and invoking specific models like GPT-4.1 or Gemini 2.5.

Explore streaming and batch processing with Langchain to deliver real-time, parallel model outputs, using model dot stream and model dot batch with configurable concurrency.

Learn to create and bind tools in LangChain, define a weather tool with a decorator and docstring, and run a tool execution loop using model with tools.

Master LangChain message types—system, human, AI, and tool—and how their roles, content, and metadata drive conversation history, prompts, and tool calls.

Learn to generate structured output from llms using pydantic, enforcing a schema with field validation and nested structures for reliable, parseable responses.

Learn how to produce structured outputs for language models using type dict and annotated fields, comparing it with Pydantic, and building nested schemas without runtime validation.

Explore using data classes to enforce a structured output schema for LLMs, exemplified by a contact info model with name, email, and phone, and compare validation approaches.

Learn how LangChain middleware controls an agent with summarization to compress long conversations using triggers like message count, token size, or context fraction.

Explore human in the loop middleware, which interrupts tool calls for human approval - approve, edit, or reject - on high-stakes tasks like financial transactions.