Instructor: Before we continue with the course,
I think it's important
to go through the course's objectives,
and my number one goal is that, by the end of this course,
you'll be competent to develop
your own LLM-powered application with LangChain.
And I like to categorize LLM applications into two types:
agents and RAG applications.
And I elaborately talk about this distinction
in this video here.
Anyways, this course is going to give you
an elaborate coverage of those two topics,
and you'll know exactly how to implement an agent
and how to implement a RAG application.
And it's not just about building those type of applications,
but rather understanding how they work under the hood.
During this course,
we'll dive into the LangChain source code,
and we'll understand exactly what LangChain is doing,
and there will be no magic.
We'll understand everything inside the process
of building those type of applications,
which will provide us with a solid foundation
for the LLM application development field.
And, as a bonus,
you'll also be proficient
within the LangChain ecosystem stack,
like using LangSmith for tracing,
or LangGraph for workflow engineering.
And don't worry if you don't understand
anything I'm saying right now,
I promise you you'll understand everything
by the end of this course.
We'll also cover prompt engineering-based practices,
prompt engineering techniques,
and really the history of prompting,
which is very interesting and is the foundation
for all of the Gen AI apps we're seeing right now.
And, as a software engineer
who used to write software for the enterprise,
I will be covering those production-ready topics
like testing, logging, monitoring, alerting, security,
and I like to continuously follow up on those topics
along the course to discuss some real-world scenarios.
All right, and I think it's also important to discuss
who is the target audience I was making this course for.
So, at the beginning,
this course was mainly for software engineers
and data scientists who want to get into Generative AI
and to build LLM applications.
So no prior knowledge in machine learning is needed,
and I teach everything you need to know in this course.
And I'll be honest with you,
when I started my Gen AI journey,
I had zero machine learning experience.
I always felt inconfident about my knowledge gap
in this field,
and it was always scary to dive into machine learning,
and I never really took this jump.
However, now, AI is a commodity,
and, in my opinion, LangChain was a huge accelerator
in this process.
Anyways, you don't need to know machine learning
in order to take this course.
You just need software experience.
So having said that, this course is very technical,
and I do assume that you have software experience,
so you know how to write code, to debug code,
and, overall, that you're comfortable around code,
so the sector of software engineers
or data scientists were the main ones.
However, I did have very surprising students
who took this course and enjoyed it.
I had lawyers who took this course,
and even doctors who actually enjoyed it.
So you should know that this was my target audience
when making this course.
However, this course is not for everyone.
Yes, I said that, not for everyone.
And this is why I do assume some concepts
which I'm not going to cover.
Those are the prerequisites,
and, without you knowing them,
then this course will be challenging for you.
So I do assume that you have some Python knowledge,
and you know how to run a Python program,
and to write Python functions, and classes,
and, general, you are proficient in Python.
Now, we're not going to do anything crazy with Python.
We're just going to use the LangChain library in Python,
and the entire source code is being managed in GitHub,
so I do assume some basic Git command
like git clone and git commit,
nothing fancy over here.
I do assume you're familiar with the concept
of a virtual environment in Python,
and how to set environment variables.
And, to be honest,
I think every standard Python course is going to cover
all of those topics.
And you will see me bootstrapping from zero
the entire project,
and you'll see me doing everything step by step.
However, I'm not going to explain everything
right from the basics.
So this is not a Python course,
it's a LangChain course.
And this is why I don't cover the basics.
So it'll give us the flexibility to dive deep
right into LangChain and to starting learning it in depth.
And it's also important to note
that this course has a 30-days money back guarantee.
So if you find this course is not for you,
feel free to ask for a refund.
You will get one without any questions asked.
And, if for some reason, 30 days have passed
and you still want a refund,
feel free to contact me directly,
and I will personally give you a refund
with no hard feelings.
All right, so that's pretty much it.
I hope I didn't scare you too much.
And with that being said,
let's go to the course.