English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 137 lectures (12h 11m) | 4.46 GB
Intensive masterclass on ChatGPT, LangChain, and Python. Make production-ready apps focused on real-world AI integration
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.
ChatGPT is being used across industries to enhance applications with text generation. But with this new feature comes many challenges:
- Building complex text generation pipelines that incorporate outside information
- Creating reusable configuration components that can be reassembled in different ways
- Applying user feedback (like upvotes/downvotes) to enhance ChatGPT’s output
- Wiring in observability and tracing to see how users are interacting with your AI
- Generate text performantly using distributed processing
This course will walk you through production-ready, repeatable techniques for addressing each of these challenges and many more.
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.
What you’ll learn
- Integrate ChatGPT into production-style apps with LangChain
- Use LangChain components to build complex text generation pipelines
- Enhance ChatGPT’s output by automatically integrating user feedback
- Teach ChatGPT new facts through Retrieval Augmented Generation
- Extend LangChain to implement server-to-browser text streaming
- Use OpenAI Plugins to add new capabilities to ChatGPT, such as database access and code execution
- Understand every line of code we write so you can use these exact same techniques on your own projects
- Build your own chat-with-a-PDF web application, complete with document upload and authentication
- See how users interact with your chat features using observability and tracing
Table of Contents
Lets Start Dive In Here
1 How to Get Help
2 What is LangChain
3 How a Typical AIEnabled App Works
4 Here It Is This is Why We Use LangChain
5 Course Resources
6 Join Our Community
ChatGPT and LangChain Integration
7 Important Python and Pipenv Environment Setup Information
8 Project Overview and Setup
9 Creating an OpenAI API Key
10 Using LangChain the Simple Way
11 Introducing Chains
12 Adding a Chain
13 Parsing Command Line Arguments
14 Securing the API Key
15 Connecting Chains Together
16 Chains in Series with SequentialChain
Deep Dive into Interactions with Memory Management
17 Important Pipenv Environment Setup Information
18 App Overview
19 Receiving User Input
20 Chat vs Completion Style Models
21 Representing Messages with ChatPromptTemplates
22 Implementing a Chat Chain
23 Understanding Memory
24 Using ChatBufferMemory to Store Conversations
25 Saving and Extending Conversations
26 Summarizations Conversation Summary Memory
Adding Context with Embedding Techniques
27 Project Overview
28 Facts File Download
29 Important Pipenv Environment Setup Information
30 Project Setup
31 Loading Files with Document Loaders
32 Search Criteria
33 Introducing Embeddings
34 The Entire Embedding Flow
35 Chunking Text
36 Generating Embeddings
Custom Document Retrievers
37 Introducing ChromaDB
38 Building a Retrieval Chain
39 What is a Retriever
40 Optional Understanding Refine MapReduce and MapRerank
41 Removing Duplicate Documents
42 Creating a Custom Retriever
43 Custom Retriever in Action
44 Understanding Embeddings Download
45 Visualizing Embeddings
Empower ChatGPT with Tools and Agents
46 Important Pipenv Environment Setup Information
47 App Overview
48 Understanding Tools
49 Understanding ChatGPT Functions
50 SQLite Database Download
51 Defining a Tool
52 Defining an Agent and AgentExecutor
53 Understanding Agents and AgentExecutors
54 Shortcomings in ChatGPTs Assumptions
55 Recovering from Errors in Tools
56 Adding Table Context
57 Adding a Table Description Tool
58 Being Direct with System Messages
59 Adding Better Descriptions for Tool Arguments
60 Tools with Multiple Arguments
61 Memory vs Agent Scratchpad
62 Preserving Messages with Agent Executor
63 Understanding Callbacks
64 Implementing a Basic Callback Handler
65 More Handler Implementaion
Pinecone as a Vector Database
66 App Overview
67 Taking a Look at Mockups
68 Boilerplate Download
69 Boilerplate Setup
70 How This App is Designed
71 Outlining the First Feature
72 Loading and Splitting From a PDF
73 Sample PDF
74 Running File Upload Server Locally
75 Testing the PDF Upload
76 Pinecone Dashboard and Serverless Indexes
77 Introducing Pinecone
78 Pinecone Client Update
79 Initializing the Pinecone Client
80 Adding Documents to the Vector Store
Distributed Text Generation with Celery
81 Why is Processing Taking Forever
82 Introducing Background Jobs
83 Redis Setup
84 Redis MacOS Setup
85 Redis Ubuntu and Windows Subsystem for Linux Setup
86 Redis Windows Setup Without WSL
87 Adding in the Worker
88 Queuing Up Jobs
89 Updating Document Metadata
Custom Message Histories
90 Understanding the Apps Requirements
91 Persistent Message Storage
92 Introducing the Conversational Retrieval Chain
93 Building the Retriever
94 Custom History Objects
95 Building a Custom SQL History
96 Testing the Chain
Streaming Text Generation
97 Streaming Text Generation
98 Creating a Working Playground
99 Experimenting with a Streaming Language Model
100 Chains Dont Want to Stream
101 Receiving Chunks with a Callback
102 Extending a LLM Chain
103 Adding a Queue for Communication
104 The Chain Really Wants to Wait
105 Solving the Slow Chain
106 It Works
107 Ending the Loop
Extending LangChain
108 Isolating the Queue and Handler
109 Using a Mixin Approach
110 Integrating the Streaming Code
111 Testing the Streaming Setup
112 Heres the Issue
113 Isolating the Handler
114 Streaming Complete
SelfImproving Text Generation
115 Random Component Parts
116 Component Part Flow
117 Partial KWArg Application
118 Building Component Maps
119 Randomly Picking a Component
120 Generalizing Component Picking
121 Collecting User Feedback
122 Redis Connection Setup
123 Storing Votes in Redis
124 Weighted Randomness
125 Extracting Scores
126 Calculating the Average Score
127 Selecting Components By Score
Implementing Tracing and Observability
128 Adding Score Observability
129 Building the Score Aggregate
130 Adding Another Form of Memory
131 Window Memory Implementation
132 Text Generation Tracing
133 Langfuse Signup
134 Adding in Tracing
135 Understanding the Trace
136 Automatic Trace Creation
Bonus
137 Bonus
Resolve the captcha to access the links!