CF

ChatGPT and LangChain: The Complete Developer's Masterclass

12h 18s
English
Paid

You've found the most advanced, most complete, and most intensive masterclass online for learning how to integrate LangChain and ChatGPT into production-ready applications!

Thousands of engineers have learned how to build amazing applications using ChatGPT, and you can too. This course uses a time-tested, battle-proven method to make sure you understand exactly how ChatGPT works, and is the perfect pathway to help you get a new job as a software engineer working on AI-enabled apps.

The difference between this course and all the others: you will go far beyond the basics of simple ChatGPT prompts, and understand how companies are integrating text generation into their apps today.

What will you build?

This course focuses on creating a series of different projects of increasing complexity. You'll start from the very basics, understanding how to access ChatGPT 4 programatically. From there, we will quickly increase in complexity, building more complex projects with many more features. By the end, you will make a fully-featured web app that implements a "Chat-with-a-PDF" feature. Note: no previous web development experience is required.

Here's a partial list of some of the topics you'll cover:

  • Understand how complex text-generation pipelines work
  • Write reusable code using chains provided by LangChain
  • Connect chains together in different ways to dramatically change your apps behavior with ease
  • Store, retrieve, and summarize chat messages using conversational memory
  • Implement semantic search for Retrieval-Augmented Generation using embeddings
  • Generate and store embeddings in vector databases like ChromaDB and Pinecone
  • Use retrievers to refine, reduce, and rank context documents, teaching ChatGPT new information
  • Create agents to automatically accomplish tasks for you using goals you define
  • Write tools and plugins to allow ChatGPT to access the outside world
  • Maintain a consistent focus on performance through distributed processing using Celery and Redis
  • Extend LangChain to implement server-to-browser text streaming
  • Improve ChatGPT's output quality through user-generated feedback mechanisms
  • Get visibility into how users interact with your text generation features by using tracing

There are a ton of courses that show how to use ChatGPT at a very basic level. This is one of the very few courses online that goes far beyond the basics to teach you advanced techniques that top companies are using today. I have a passion for teaching topics the right way - the way that you'll actually use technology in the real world. Sign up today and join me!


About the Authors

Stephen Grider

Stephen Grider thumbnail

Stephen Grider is one of the longest-running and most prolific instructors on Udemy, with a catalog covering essentially every major JavaScript framework, plus Docker, Kubernetes, AWS, and the broader full-stack development landscape. His teaching style is patient and project-oriented — most of his courses are structured around building a substantial application from scratch rather than working through disconnected tutorial examples.

The catalog covers React, Redux, Next.js, Vue, Angular, GraphQL, Node.js, Docker / Kubernetes, AWS infrastructure, React Native and Flutter for mobile, the algorithm / data-structure interview prep track, and the modern TypeScript / Bun / Rust adjacent material that working JavaScript developers increasingly encounter. Few independent instructors have maintained Stephen's breadth this consistently for this long.

The CourseFlix listing under this source carries over 25 Stephen Grider courses spanning that range. Material is paid; Stephen Grider courses are typically sold individually on Udemy. Courses are aimed primarily at developers picking up a specific technology through working through a complete project.

Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 118 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 118 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: How to Get Help
All Course Lessons (118)
#Lesson TitleDurationAccess
1
How to Get Help Demo
01:15
2
What is LangChain?
03:58
3
How a Typical AI-Enabled App Works
10:00
4
Here It Is, This is Why We Use LangChain
05:29
5
Project Overview and Setup
03:21
6
Using LangChain the Simple Way
02:56
7
Introducing Chains
10:09
8
Adding a Chain
04:11
9
Parsing Command Line Arguments
02:30
10
Securing the API Key
04:45
11
Connecting Chains Together
02:57
12
Chains in Series with SequentialChain
07:01
13
App Overview
02:12
14
Receiving User Input
02:00
15
Chat vs Completion Style Models
10:10
16
Representing Messages with ChatPromptTemplates
06:02
17
Implementing a Chat Chain
04:38
18
Understanding Memory
09:26
19
Using ChatBufferMemory to Store Conversations
07:28
20
Saving and Extending Conversations
04:44
21
Summarizations Conversation Summary Memory
09:43
22
Project Overview
03:29
23
Project Setup
01:54
24
Loading Files with Document Loaders
06:15
25
Search Criteria
04:37
26
Introducing Embeddings
10:32
27
The Entire Embedding Flow
02:10
28
Chunking Text
07:16
29
Generating Embeddings
04:22
30
Introducing ChromaDB
10:02
31
Building a Retrieval Chain
10:33
32
What is a Retriever?
05:21
33
[Optional] Understanding Refine, MapReduce, and MapRerank
28:09
34
Removing Duplicate Documents
07:54
35
Creating a Custom Retriever
11:13
36
Custom Retriever in Action
06:02
37
Visualizing Embeddings
04:35
38
App Overview
04:14
39
Understanding Tools
08:13
40
Understanding ChatGPT Functions
10:55
41
Defining a Tool
06:36
42
Defining an Agent and AgentExecutor
05:52
43
Understanding Agents and AgentExecutors
09:14
44
Shortcomings in ChatGPT's Assumptions
04:45
45
Recovering from Errors in Tools
04:28
46
Adding Table Context
09:29
47
Adding a Table Description Tool
05:21
48
Being Direct with System Messages
02:52
49
Adding Better Descriptions for Tool Arguments
06:59
50
Tools with Multiple Arguments
07:13
51
Memory vs Agent Scratchpad
09:25
52
Preserving Messages with Agent Executor
02:38
53
Understanding Callbacks
04:47
54
Implementing a Basic Callback Handler
05:04
55
More Handler Implementaion
11:23
56
App Overview
02:27
57
Taking a Look at Mockups
03:24
58
Boilerplate Setup
04:44
59
How This App is Designed
06:10
60
Outlining the First Feature
04:29
61
Loading and Splitting From a PDF
03:41
62
Testing the PDF Upload
02:17
63
Introducing Pinecone
06:31
64
Initializing the Pinecone Client
05:54
65
Adding Documents to the Vector Store
03:52
66
Why is Processing Taking Forever?
06:11
67
Introducing Background Jobs
07:45
68
Redis Setup
01:56
69
Adding in the Worker
04:09
70
Queuing Up Jobs
04:04
71
Updating Document Metadata
07:08
72
Understanding the Apps Requirements
07:59
73
Persistent Message Storage
12:09
74
Introducing the Conversational Retrieval Chain
10:36
75
Building the Retriever
04:57
76
Custom History Objects
04:44
77
Building a Custom SQL History
08:53
78
Testing the Chain
04:59
79
Streaming Text Generation
03:58
80
Creating a Working Playground
05:12
81
Experimenting with a Streaming Language Model
09:11
82
Chains Don't Want to Stream
06:53
83
Receiving Chunks with a Callback
04:34
84
Extending a LLM Chain
08:50
85
Adding a Queue for Communication
07:28
86
The Chain Really Wants to Wait
04:14
87
Solving the Slow Chain
02:45
88
It Works!
02:41
89
Ending the Loop
04:59
90
Isolating the Queue and Handler
03:37
91
Using a Mixin Approach
04:47
92
Integrating the Streaming Code
06:59
93
Testing the Streaming Setup
07:07
94
Here's the Issue
04:38
95
Isolating the Handler
07:50
96
Streaming Complete!
10:34
97
Random Component Parts
04:17
98
Component Part Flow
05:19
99
Partial KWArg Application
06:14
100
Building Component Maps
04:35
101
Randomly Picking a Component
08:02
102
Generalizing Component Picking
10:09
103
Collecting User Feedback
05:16
104
Redis Connection Setup
06:52
105
Storing Votes in Redis
07:35
106
Weighted Randomness
03:03
107
Extracting Scores
06:31
108
Calculating the Average Score
07:33
109
Selecting Components By Score
04:38
110
Adding Score Observability
02:45
111
Building the Score Aggregate
03:50
112
Adding Another Form of Memory
02:37
113
Window Memory Implementation
06:10
114
Text Generation Tracing
04:32
115
Langfuse Signup
03:28
116
Adding in Tracing
06:50
117
Understanding the Trace
05:27
118
Automatic Trace Creation
10:32
Unlock unlimited learning

Get instant access to all 117 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites are needed for this course?
To enroll in this course, you should have a foundational understanding of software development and basic programming skills. Familiarity with APIs and command-line interfaces will be beneficial, as the course involves parsing command line arguments and securing API keys. Some experience with AI concepts can also be helpful, but the course covers introductory topics such as what LangChain is and how an AI-enabled app works.
What projects will I build during the course?
Throughout the course, you will build a series of projects that demonstrate how to integrate LangChain and ChatGPT into applications. Key projects include implementing a chat chain, building a retrieval chain with ChromaDB, and creating custom retrievers. You will also work on practical exercises like visualizing embeddings and handling errors in tools, providing a comprehensive understanding of AI-enabled app development.
Who is the target audience for this course?
This course is designed for software engineers and developers interested in integrating AI capabilities into their applications, particularly those seeking to work with ChatGPT and LangChain. It is suitable for individuals looking to transition into roles focused on AI-enabled applications or those aiming to enhance their existing skills with advanced AI integration techniques.
How does the course compare in depth to other AI courses?
This course goes beyond basic AI concepts and focuses on the practical integration of text generation technologies into real-world applications. Unlike courses that only cover simple ChatGPT prompts, this course delves into advanced topics such as custom retrievers, embeddings, and agent executors. With 118 lessons, it offers a detailed exploration of LangChain and ChatGPT's use in production environments, making it more advanced than introductory AI courses.
What specific tools or platforms will I learn to use?
The course provides hands-on experience with specific tools such as LangChain, ChromaDB, and ChatGPT. You will learn to use LangChain for creating chains and connecting them, ChromaDB for building retrieval chains, and ChatGPT for implementing chat models. Additionally, the course covers tools for visualizing embeddings and managing API keys, equipping you with the skills to build AI-enabled applications effectively.
What topics are not covered in this course?
The course does not cover introductory programming or AI concepts in depth, assuming participants already have basic programming skills. It also does not delve into unrelated AI technologies outside the scope of LangChain and ChatGPT, focusing instead on these specific tools and their integration into applications. Topics like deep learning fundamentals or alternative AI frameworks are not part of the curriculum.
What time commitment is required to complete the course?
The course includes 118 lessons, and while the total runtime is listed as 00:00:00, students should anticipate dedicating significant time to fully grasp the material. Given the advanced nature of the content, plan to spend several weeks working through lessons, projects, and exercises to ensure a thorough understanding of LangChain and ChatGPT integration.