10.5 Hour Generative AI & Agentic AI Guide: LangChain, LangGraph, RAG & Deep Agents

Hello all, my name is Krishna and welcome to my YouTube channel. So guys, super excited to bring this specific

video which is more than 10.5 hours and the best part about this video will be that from past four to 5 months

every important topics that has actually evolved in AI specifically in the field of generative AI and agentic AI have

covered almost everything. Just let me talk about the plan how we are going to cover. First of all, we are going to

understand about generative AI and agentic AI with Langchain. Then we are going to see a langraph complete

langraph crash course wherein we will focus on building agentic AI application. Then the third important

part will be the entire rag you know how you can go ahead and implement rag and this will not be only traditional rag

we'll also try to cover agentic rag and after that we'll try to cover vectorless rag. So everything will be like kind of

a oneshot video of every topic and then we will also try to understand what is the differences between traditional

vector rag versus um vectorless rag. Then we will also be understanding about deep agents, deep research agents. we

will see the practical implementation and finally it is related to AI security wherein we will be discussing about

guardrails and also we will be discussing about various LLM evaluation techniques. Uh again we will try to use

open-source libraries in that and finally we end this entire session with around 30 to 40 minutes of topic

understanding about LLM gateways and its implementation. So everything that is probably evolving from the past 6 months

we have covered all these things inside this particular video. This video will be somewhere around 10 and 1/2 hours and

I will be giving you entire time stamp and all. So you can go ahead and explore it out. Okay. And one thing I definitely

want I know you'll not be able to cover this in one just one single day. You'll definitely take a one month time but by

understanding by learning all these things trust me with respect to any interviews that you probably go you will

be able to answer right so here I have completely summarized this entire video attached one after the other please make

sure that you watch this video till the end and yes we will keep a like target of 5,000 please make sure that you do

that target and I will be trying to bring this kind of videos again and again so thank you let's go ahead and

enjoy this source. So guys, uh if you have been following my lang chain playlist, my langraph playlist, I've

uploaded tons and tons of videos. Uh I have made end to-end projects. I have taught each and everything specifically

uh on this particular frameworks. Now uh this particular video is just like a oneshot video uh on langchain itself

because recently lang has come up with its uh recent version that is version v1 and uh there are some various changes

specifically in terms of creating agents applying memories. Uh there is a new concepts that have uh recently been come

that is called as middleware. So considering all these things I thought why not make a oneshot video with all

the recent updates and uh you can watch this entire tutorial. It'll be a longer tutorial where I have included each and

everything. So uh go ahead enjoy this and make sure to hit like uh we'll keep a like target of thousand so that after

completing this particular video I'm also parallely recording the updates with respect to langraph and there is

one more new topic that is coming which is called as deep agents. So everything will be getting recorded as we go ahead.

So go ahead enjoy this particular crash course on langchen version B v1. Hello guys. So recently langchain has come up

with lot of updates in their specific documentation in the recent version and uh in this entire series of videos and

in this module we are going to see the various changes uh which langin has specifically come up with you know so

here inside the documentation if I just go ahead and click on docs. Okay. So here you'll be able to see there is lang

chain lang graph and deep python. So we will be covering all these things all these modules uh again in an updated way

so that we are always up to date with langen documentation. So first of all we will go ahead with langen documentation

over here. Now here with respect to this particular documentation uh there are a lot of changes uh specifically with

respect to syntaxes with respect to creating agents you know uh how to integrate with multiple different models

um how to go ahead and call a tool how to you know come up with a structured output along with that it also has lot

support of messages you know different types of messages like AI message human message uh tool message. Along with

that, we'll also be seeing something called a short-term memory. We'll be seeing how to perform streaming, you

know, and there is a new concept uh that has basically come up with respect to middleware like built-in middlewares,

custom middleware and uh we'll also be learning about guard drills and many more things. So in this entire series of

video we are first of all going to cover the entire lang chain uh recent framework whatever the updates are there

and uh you know and we are also going to use an amazing package which is called as UV package manager. Now everybody if

you have heard about UV package manager this is an extremely fast python package uh and project manager and it is

completely written in rust. So I'll give you an idea how you can actually go ahead and work with UV package manager

and this is the entire installation you know uh how to probably go ahead step by step I'll be showing you how to how you

can go ahead and create an environment um and along with this you can use any ID right there are also various ids that

are now available we have VS code we have cursor we also have Google anti-gravity nowadays I'm actually

specifically using Google anti-gravity also so uh all these things we will try to cover and uh our main aim is always

to stay up to date with respect to anything that is basically coming in lang chain. Okay. So uh from as we go

ahead now we will be covering this step by step and uh I will show you how step by step how to go ahead and create an

environment and we will just start with a specific uh new project itself. So here you'll be able to see that I have

already opened uh Google anti-gravity which I will show you in front of you right and I have created a folder which

is called as langin updated now we'll start from basics now Google anti-gravity also you can go ahead and

download it in order to download all you have to do is that just go ahead and search for Google anti-gravity

okay and then this ID this is like a aentic ID like how we have VS code how we have cursor right you can also

download for windows this it will be just be like a .exe file and then once you go ahead and install this uh you

will be able to start working on it. So this is the ID that we are going to specifically work on. The best part

about this ID is like cursor you know it provides access to agent and it also provides you completely for free. Uh I

think for some number of requests not for uh infinity requests right but uh yes with the help of agents you will be

able to write the code in a much more efficient way right so now as we go ahead uh we will be covering uh the

recent updated lang version and we'll try to see that how we can go ahead and create agents how we can go ahead and

work with tools each and everything. So let's go ahead and start that. So guys, now let's go ahead and start with first

of all creating a virtual environment and it is always a good practice that we start with creating a virtual

environment and uh for any kind of projects that we work with. So the first thing is that uh we will try to create a

virtual environment with the help of UV okay UV package manager. But before we go ahead you know uh we need to install

the UV package manager, right? So how to go ahead and install it? So if you just go ahead and search for UV package

manager. So this is the first link that you will be able to see it. Okay. So once you click it here you'll be able to

see in the installation you have options for Mac OS, Linux and you also have options for Windows right. So out of

both of these options you can go ahead and do it. So let's say that if you're using Mac OS or Linux you can use this

command. uh if you are using windows you can directly open a powershell and you can execute this command right so how to

open a powershell so first of all what I will do I'll copy this particular command and now I will go to my um you

know the id and here I will open my terminal the opening of the terminal is similar like vs code if you're using vs

code till now okay now here inside this powershell see you have powershell option you have command prompt option so

here inside this powershell only you can just go ahead and paste this command and just press enter. So once you press

enter the UV package manager you know will get automatically installed. Okay. So I've already done that installation

so I don't have to do it again but just to show it to you I have actually done it. Okay. Now I will remove this. I will

open my command prompt. Okay. or whatever like let's say that you're using Mac OS whether you're using u uh

Linux you know it is up to you whatever things you really want to use you can go ahead and use it okay so till then I'll

just go ahead and close this now here the first step is that how do I go ahead and create my virtual environment with

the help of UV package uh package manager so first of all what I will do I will initialize this entire folder as a

working repository now in order to initialize it you know we will go ahead and use one command which is called as

uv init okay so please make sure to remember this command so if you want to go ahead and just initialize a working

repository let's say this is my working repository so first of all I will initialize it with the help of uv so for

that I will just go ahead and write uv init pro uh command once I execute this so here you can see it has initialized

the project which is called as langchain updated so as soon as you initial initialize the working repository. Here

you get some of the basic information, right? So here you'll see pi project.2ml. This will give the

information like which versions we are specifically working with. So here we are working with python 3.13. So recent

updated Python package manager. Uh later on like let's say if python package is also getting updated, you know again

when you write uv in it, it will just take the recent python version. Okay. And it is always a good practice to work

with the region version. That's the reason you can actually go ahead and directly use this. Now along with that

you'll be seeing that a default main. py is basically there. Then you also have something called as python version file.

So here you can see that I'm getting 3.13. Okay. So all this information you can see over here in a very simple way.

Now the next thing what I will do is that I will just go ahead and write uv venv. Now see as soon as I write UV venv

and I put a slash. Okay. Now what this will do is that it will go ahead and create a virtual environment. So once

let me press enter. So here you can see that uh unrecognized subcomand venv slash. So by def by mistake I have put

this slash I should not have put that. So what I will do I will just write uv venv. Now in order to create a virtual

environment this is the most simplest command right. UV venv. As soon as I write uvnv and I press enter. So here

you can see that now it is using this python 3.13.2 and it has created a virtual environment

at this specific location. So venv is my virtual environment. Right now in order to activate it see if as

soon as you create a virtual environment you need to install the libraries inside that virtual environment. Right now in

order to install the specific libraries inside that virtual environment, I will first of all activate that virtual

environment. Now in order to activate it, the command is given over here. See it is written activate with VNV

script/activate. So if you go inside the script, there is something called as activate. I just

need to go ahead and call this particular uh or execute this particular command. So what I will do, I will copy

this over here. I will paste it over here and I will just execute it. Now as soon as I do that here you can see that

my my virtual environment right is activated which is called nothing but

lunction updated. So this virtual environment has got updated. Okay. Now the next step is that how do I go ahead

and start the installation of all the libraries. Okay. Now installation of the libraries is very important. Till now uh

you know uh whenever we install a virtual a libraries you know you also need to make sure to keep an updated

track of which version we are installing right u but now with the help of UV package manager this is becoming very

very easy now okay so let's say that I go ahead and first of all create a requirement txt file and please make

sure to create that particular file outside VNV folder so I will go ahead and write requirement txt now inside

this I will be using some of the libraries. Let's say one of the libraries that I'm using is Langchin.

Then I have Langchin community. Okay, Langchin community because I will be requiring this. Okay, then I also have

Langchin- OpenAI because I want to use this Langchin OpenAI. I also have to use Langchin Grock because I may also use

Grock models. Then I also have Python-Env, right? So I will also be using this.

Along with this I will also use langin/ google jenna my main aim over here is to install all these libraries is very

simple because I want to show you all the examples with different different libraries and all okay so these are my

default libraries and uh here you can see that it is also giving you some suggestions but don't go through that

suggestion go ahead and type each and everything in front of you okay now the time comes is that I have to go ahead

and install all these particular libraries inside in my virtual environment. Now here the best thing is

that see I have not given any specific version. We are going to work with the recent version of all these lang

libraries over here. Now what is the recent version that also we will go ahead and check it out. So here what I

will do I will write uv add minus r requirements txt. Right? So this is how you go ahead

and do the installation. See you can also go ahead and write uvp pip install minus r requirement.xt txt you you used

to install all the requirement.txt by writing pip install minus r requirement.txt but with the help of uv

you can just go ahead and write uv add minus r requirement.txt txt. Now once I execute this, so here you can see that

all my installation will start happening. Okay, it'll give you some warnings but it's okay. We can skip this

warnings. Now here you can see by default all the libraries has got installed. Now here you can also see all

the version of the specific libraries that has got installed. Now just by seeing this you'll not be able to

identify it. So what I will do I will go ahead and open this pipro.2ml. Now inside this you will be seeing that

okay langchin 1.1.0 has been installed and this is the recent version. Langchin community.4.1

is installed. Langchin Google geni 3.2.0 is installed and all the different libraries has been installed. Now

because of this you will be at least able to identify it because I will also pass you this pi project.2ml to ML file

to just get you understand that okay right now we are in the specific versions tomorrow any number of updates

that specifically comes you don't have to actually worry about it you know at least you know which is the base version

right but my suggestion will be always that try to work with the recent version of langin because there are many many

functionalities that will get deprecated some of the functionalities may may get moved to some other libraries and many

more things now this is where we have actually gone ahead and uh you know created or installed all our libraries.

Okay. Now the next thing is that I will also go ahead and create some keys. Okay. So I will be requiring three keys.

One is the Google API key. So I will go ahead and write Google API key. Okay. So I will go to Google AI studio API key.

And here you can see this is my dashboard. And there is an option which says create an API key. So I will go

ahead and select one of the project. So let's say this is my project and I'll say okay this is my set key that I

really want to go ahead and create or I'll go ahead and name it as lang chain updated and I will just go ahead and

create the key. Okay now you know how to create a keys right at least uh that I think you should be

familiar with. I will go ahead and copy the API key. Similarly I will go ahead with gro API key. So I will write gro

API key and here is my API keys. Okay. And I will just go ahead and click on create API key and I can go ahead and

create it. Right. Similarly with respect to open AI API. So I have created all these keys and what I will do I will

quickly go ahead and create one file which is called as env. And I will go ahead and install uh paste

this API keys over here. Right. So these are my API keys that I will be specifically using for my project. There

is also one more library that I want to install for my uh Jupyter notebook that is nothing but UV add IPI kernel. Okay,

IPI kernel. So IPI kernel you will be able to see that that is also installed. IPI kernel is just like a kernel

provided to the Jupyter notebook. Again let me repeat it guys. Whenever you want to add any independent libraries, you

use this command which is called as uv add. Okay. And then you give the library name. Okay. Library name. If you want to

directly install it from the requirement.txt, then you can just go ahead and write ue add minus r

requirement. TXT. Okay. Like it's just like you are doing the installation from requirement.txt.

So in this video what we have actually done is that in this section we have created a virtual environment. We have

created a requirement.txt file which has all the recent libraries and we have installed it by using this command uv

minus r requirement.txt. Otherwise you can also go ahead and individually you can go ahead and

install all the libraries by writing uv add the library name whatever library name that you want. Let's say you want

to go ahead and install langin. So here you can just go ahead and see that and here I have already installed it. So it

is showing me resolve this and that right now in the next step what we are going to do is that we will start

working on our lang uh updated documentation and we will start implementing agents. We'll show you how

you can go ahead and integrate different kind of models. So let's go ahead and start with that. So guys now we have

created a virtual environment. uh we have done the installation of all the libraries that we require in our virtual

environment. Uh with the help of UV package manager uh you can also see all those things updated in pi project.2ml

file and here you can see all these libraries we are going to specifically use it. Okay. Now uh you can also add

your any descriptions that you specifically want to add also. Now what we are going to do is that we will start

with the updated lang chain folder. Okay. So I've created a folder over here. So let me first of all delete this

and create a new folder. So I will write updated lang chain. Okay. And uh I will start

with the first file which is called as lang chain intro doip yb file. Okay. So, let me minimize this. I will go ahead

and select the kernel. I want Python environment VNV. Okay. And uh we'll write a markdown saying that this is the

lang chain version v1. Okay. I will just go ahead and write it. And I will just go ahead and execute it. Perfect. Now,

just to check everything is working fine or not. So I will also go ahead and open my code and I'll execute something.

Okay. So this is working. The Python code is also working like oneplus 1 is a kind of a numerical operation. Now uh my

env file is also been loaded. Everything is ready. So first of all as usual we'll go ahead and import OS. Then from env we

are going to import load_.env. And we will go ahead and initialize load_.env.

and we will initialize our open AI API key. So I will write OST environment and here you can see that I

will go ahead and write open AI API key. So uh one thing about uh Google anti-gravity is that it provides you a

lot of suggestion. Okay. So you will be seeing okay quickly when you're coding it you'll quickly see all the

suggestions that is coming up. Right. So OS.get and open AI API key. So I will go ahead and execute this. So perfect. Um

now the first thing that I'm just going to start okay um that is all about agents. Okay. Now first of all you need

to understand what exactly is agents. So what I will do I will just open my file over here. I will create a new file so

that I write something to you so that you get an understanding. Okay. See uh before uh you know when we started

working right when initially we got generative AI at that time generative AI is becoming very very much as a

important topic but nowadays everybody is specifically talking about a okay so everybody is talking about agents and

agents is altogether a very very handy topic okay very very important and handy topic altogether so initially if you go

ahead and see you know initially we were just talking about LLM models. So let's say that this is one of my LLM model.

Now the LLM model can be anything. It can be an open AI LLM model. It can be a generative AI LLM model. It can be uh

you know grock LLM model any open source LLM models. The main task of the LLM model was that uh whenever we give any

kind of input right input let's say if I go ahead and ask hey uh write me a paragraph about artificial intelligence

so LLM will take that particular input and then it will give you a specific output okay it'll give you a specific

output like okay if I'm asking write a paragraph 200 words paragraph on artificial intelligence it'll give me a

200 words paragraph as an output. Okay, this was a simple generative AI application. Okay, I used to say this as

a gen AI application. So gen AI application. Okay, application. Perfect.

But now as we move ahead you know so let's say that for this particular LLM model if I ask a question hey provide me

with the current AI news or today's current AI news. So let's say that I want to know the today's

AI news AI news. Okay. Now in this particular scenario

you know that LLM has a cutoff training training date. Okay. So we basically say that LLM is already trained from

previous data. It does not have the current information right recent information like let's say tomorrow's or

today's information it does not have right. So LLM has to be dependent on some thirdparty tool. Why it should be

dependent on third party tool? Because when I'm asking this specific question or tell me about the today's AI news,

LLM does not have that particular information, right? Because it is already trained with the previous data.

It is not trained with today's data and there is always a cut off training date, right? This is really really important

for you all to understand. So this is one of the problem of just using a plain LLM. Now that's the reason whenever we

say that if we need to answer if my LLM needs to answer this particular question it needs to be dependent on

some third party tool some tool okay whenever we say some tool that it can be a third party tool it can be any kind of

tool okay it can be a third party APIs it can be Google search it can be something else right and based on this

particular ular tool what should happen is that whenever we give an input saying that today's AI what are the today's AI

news the LLM should be able to make a decision okay I will not be able to answer this particular question so now

I'm dependent on some other tool which will be able to answer this particular question because this tool is currently

connected to the current data or current like today's news it is basically connected to right specifically AI news

and this will be able to give me the response and this response that you basically get from here it is basically

called as context right and then only the LLM will be able to generate the output right so in this particular

scenario where we have a LLM being dependent on some other tool and from where we are basically getting a context

as soon as we give an input the LLM is able to make a decision okay I'm not able to answer this I have to probably

dependent on the tool which tool will be able to answer this particular question and it will be able to give the context

and generate output so this is nothing but it is a basic agent. It is a basic agent. Okay, it is a basic agent. This

is the simple functionality of an agent. Okay, so uh that is what an agent is all about. So I hope till now you have got a

clear understanding what a basic agent looks like, right? So autonomously here you can see that it is able to make any

kind of a simple decision like when to route what kind of query and how to properly solve that particular task.

Okay. So uh whenever we talk with respect to an agent before creating a agent with the help of langin was little

bit tough you know so before we used to use an LLM model then we used to create a a tool separately then we had to

probably go ahead and do a linkage between this particular tool to the LLM we used to use a architecture which is

called as react architecture okay react architecture now with the help of this particular architecture we were building

this specific agent but now Creating this agent has become simpler with the recent langchain version that is

langchain uh version one. Okay. So now let me go ahead and show you that how we can quickly create an agent uh and how

easy it is basically to create an agent. So first of all in order to create an agent what we will be doing is that we

will just go ahead and define something called as from langchain. Okay. Langchain dot agents. We import

something called as create agent. Okay. Create agent. Now as soon as we write like this langun. Create

agent. Here we go ahead and define agent is equal to create agent. And inside this first of all we give our model

name. Now model name can be given through different ways. So directly if I'm importing the open AAI library I

will be giving the my model name. Let's say my model name is GPT5 which is the recent uh you know specific open AAI

model. And then I will go ahead and use tools. So right now I will keep this tools and empty because I don't have any

other tools created yet. Okay. And then apart from this tool we also provide some kind of system prompt. So here I

will go ahead and write my system prompt saying that hey you are an helpful assistant. Okay. And then we have also

kept verbose is equal to true. I will talk about what is verbose. Okay. It'll give you more information with respect

to the invocation. Now as soon as I go ahead and just run or write this. So here you can see it got an unexpected

keyword argument. I think verbose is not supported yet for this. So let me remove it. Okay. Now let me just go ahead and

uh execute this agent. Now you'll be able to see some kind of diagram over here. Okay. And that diagram will

definitely match this diagram that we have created. Okay. So this is how we basically go ahead and create a basic

agent. But right now you can just see that tools is right now empty. Okay. So what we have we have start, we have

model and we have end. So that basically means we just have this input lm and output.

still that tool connection is not there because we have not created any tool right so now what I will do I will just

go ahead and define one function so let's say this is my get weather function I will give my [snorts] city

over here which will be in the form of string and this will also return string okay and here I will just say return the

weather in this city is sunny that's it okay I can also provide some dock string to provide some more information related

to this particular function. It's like get the weather for a city. Okay. And now this same tool I can add it over

here. So that basically means if I ask what is the weather of Bangalore now the LM will be much more smarter enough to

know that which tool it needs to call. Right? So now what I have done is that we have created a function which is

called as which is called as get weather. Okay. So here what we have done is that we have created a function which

is called as get weather. And this get weather is added as a tool to this particular LLM. Okay. Now if I ask hey

what is the weather for this particular city? Now the LLM will make a decision. It will not have the current information

obviously right because it is already trained with the previous data. So it knows that it has to call this get

weather function or tool right and then it'll try to get the context. The context is nothing but whatever this

function is returning that is the context and finally it will be generating the output. Okay now see this

as soon as I created a function get weather and I updated inside this tools right now I have this tool that is

available. Now you see how this agent diagram will change. Now you can see that right. So now I have start the

model which is my LLM and this is basically connected to my tools. Now whenever I ask any question with respect

to weather this model will definitely go ahead and hit the tool get the response and it will display the output. Now in

order to run the agent it is very simple. I will go ahead and run the agent over here. And running the agent

is very simple. Well, I will write agent.invoke. Agent dot invoke. And let's say that I

will go ahead and you know just write what is the weather like in New York. I know this is not going to give me New

York weather because here I'm just returning a simple string. But just imagine that here we had some API calls

that was basically made in order to get the weather information. And uh here we can display that particular information.

So now if I go ahead and execute this clearly you will be able to see that I'm getting one error. Let's see uh expected

dictionary. Okay. So this is not the right format to give it. The simple reason is that we need to give it in the

form of a messages. So I will write messages colon.

Okay. And then I will give it in the form of a role. like role is like user because it is a user message human

message. We will talk more about these different types of messages as we go ahead but right now I just want to show

you how you can go ahead and run this particular agent. So role is equal to user and content we are writing what is

the weather like in New York. Now if I'm giving in this fun see the error is very simple over here that you have got

expected dictionary. So whenever we are using this inbuilt function called as create agent for creating the agent in

this particular scenario we have to give the input in the form of a dictionary wherein my dictionary key will be in the

form of a messages. Okay here if I'm writing messages and I'm executing this. So [clears throat]

here you can see I'm given the role is equal to user and content what is the weather like in New York. So if I go

ahead and execute it now you'll be able to clearly see the response. See guys, I'm showing you the error. I will not

cut that particular error part because I want to show you each and everything. Okay. So now what is the weather like in

New York? So first of all, this was the human message that has gone. You can also give it in the form of human

message. We'll discuss more about the messages as we go ahead. Then here you can see the AI message is making a tool

call. So somewhere here you'll be able to see that it has made a tool call. So let me just go ahead and see it. uh

somewhere here you can see that it has made a tool call and it also knows which tool to call right get weather because

it has this particular information. Now the question arises that how does LLM model knows that it has to make a get

weather tool call because when we define this particular function get weather we have also put a dock string right and

when we are assigning this tool to this particular agent this dock string it the LLM will understand which is the dock

string over here like get the weather for a city now it knows that it'll go ahead and call this particular function

right so it made a tool message so here you can see the weather in New York is sunny it has just taken this particular

uh city data and it is basically giving you the output like sunny right and then finally you can see the AI message it's

sunny in New York right so once you get the context from the tool the model will be displaying the output right so if you

want to also display the output over here you can just go ahead and write response is equal to agent this one and

then I will just go ahead and write response of messages messages

right so you can see messages and then you can just go ahead and take the last message dot contain and here you should

be getting the output right so when you write messages last one you'll be getting the last

output if you remember if you remove this also you'll be getting the entire conversation and all right let me also

show you one more way you can also directly go ahead and write like this agent do invoke and here you can

write in the form of messages and here you can just go ahead and Write something like this. What is the

what is the weather in New York? So let's see whether we'll be able to get the output

or not. Like this also you can directly write. You don't need to even specify that

whether it is an human message or not. It will automatically identify it. Okay. So now here you'll be able to see that

[clears throat] and there is a small spelling mistake and here also you can see that I'm

getting a output. Okay and this is really really good even though I made a spelling mistake it is being able to

give me the right output also. Okay so that's the most amazing part out there. So I hope you got a very basic idea of

how to create an agent. What was an agent? We basically say this as an autonomous agent because based on the

input the model is taking the decision which tools to call get the context and give you the output right so everything

is happening over here but as we go ahead we will be creating multiple tools so this is one of the tool like that we

can go ahead and create any number of tools as we like okay so this was just a basic way of creating an agent with a

recent version now which version we are talking with right so I'll write import lang chain

and import lang chain and I will just go ahead and print lang chain version

right so it is 1.1.0 So I hope uh in this video we have understood about agents

basic agents right uh agents are like you know autonomously it will be doing this specific task that is assigned to

it. So yeah in the next video now we will see how to integrate different different models we will talk about

different kind of messages each and everything and uh as we go ahead like in this series we will be discussing about

that. So let's go ahead and discuss the next thing that is model integration. So guys, now we are going to discuss about

model integration with your LLM application or with your generative AI application and uh we will see three

popular models that is open AAI, Google Germany and Grock you know in Grock you have various open source models Google

Germany whenever we talk about you know there are different geiny models and open AAI like you have GPD models you

know 4.5 whichever you want to specifically go ahead and use it okay now what we are going to do is that we I

will just go ahead and show you with the recent updated langen like what are the different ways of invoking a specific

model. Okay. So first [clears throat] of all I will go ahead and make a code cell you know and if you remember in our env

file we have all the three API keys loaded over here. Okay. So first thing is that what I will do I will just go

ahead and write import OS and then from env import load env right and I will go ahead and

initialize the load env so that we load all the models right and then we are going to set our environment variable

from the open AI API key. So open AI API key is equal to OS.get get env and here also we are going to use the openi API

key. Similarly, what you can actually do is that you can also load different different API keys like how you have

seen over here. Gro API key uh you have Google API key and all right so we will be using all these three models uh you

know and uh we'll try to see that how we can go ahead and call them okay so once I have initialized or once I have loaded

all the environment variables specifically with respect to openi API key Google API key and gro API key first

I will show you how you can load the openi model right so for this uh first of all I will go ahead and initialize

from langchen chat_models import init chat model. Okay. So, init chat model is one of the libraries that we

specifically use in order to initialize any kind of chat model itself. Okay. Then we go to the next statement. We

will use a variable called as models. So, let's say I will write model. And here I will write init chat model. And

you know by default you can directly provide your model name. Okay. Now since I want to show you with OpenAI. So first

of all I will go ahead and write GPT. Let's say I want to go ahead and try 4.1. Okay, 4.1. And here I will just go

ahead and write models. Okay, instead of writing models, I can also go ahead and write model. And now let's see uh what

error I get. Okay, unable to inform provider for model is equal to okay, GTP I have written. It should be GPT 4.1,

right? So I hope everybody knows different different models that are available in OpenAI. You have 4.1, you

can have 4.5. Okay. So I will be using 4.1. So here you can see that now once I execute this it gives me this

information that it is a chat openai model. Uh it has maximum output tokens all this information over here with

respect to the model. Now comes like how do I go ahead and invoke the model. So let's invoke the model over here. Now in

order to invoke the model uh with the help of init chat model or directly you can directly use this model.invoke

invoke and let's say that I give a message saying that hello hello how are you okay how are you now here you can

see that clearly I've given a simple message this is a human message itself and I will be able to get the response

now let's go ahead and display the response so this is a simple like I'm giving this specific input this input

goes to the model that is GPT 4.1 and it'll give us some kind of response okay now once I go ahead and see the response

You will be able to see that I get an AI message content. Hello, I am just a program but I'm here and ready to help

you. How can I assist you today? So this is the response from the LLM model that is GP 4.1. Okay, if I really want to

just directly see the content, I can also go ahead and write response.content.

Okay, once I do this, this is the output of the model that you will be able to see. So any kind of models [snorts] that

you have with respect to OpenAI let's say I want to go ahead and try GPT 4.5 you can go ahead and change this

whatever model you require or whatever model you really want to use from OpenAI you can change the model name and you

can actually get it over here. Now comes the next one like how do I call a Google Germany model right? So

here I'm going to talk about Google Germany model integration. So let's try this also. Okay. So for

Google Germany what I will do? I have already loaded the environment. So I will write from langchain from langchain

dot chat_models import init chat model. Okay. So, init chat

model and here I can use this. Okay. So, this is a markdown, right? So, I will delete this and let me execute it over

here. Lot of suggestions usually comes with uh Google uh this Google anti-gravity and I specifically use

this. I like it because for coding purpose it it becomes easy for me to quickly you know autocomplete all the

code. So uh now what I will do is that I will go ahead and just use this specific code. Now see this code. So I'm using

from langen.hat models import init chat model. Okay here we are loading the Google API key and then we are using

init chat model. But to specify this Google Germany model we just have to write google genai colon whatever model

name you are specifically using from Google Germany. Right? There may be different different models. So I will

use Google genai colon geminy 2.5 flashlight that will be model and I've just written model.invokes why do parrot

talk you know. So this is the question that I have given up from the human. I get the response and I will just go

ahead and display the response. So once I display the response now you should be able to see that the output that you're

getting will be from the Germany 2.5 flashlight. Okay. So I have already initialized I have already loaded the

Google API key for the first request. I think it is going to take some amount of time but after that uh if my API key is

absolutely working I'm actually going to get the response. So this is how you can use init chat model and integrate with

Google API key. So here you can see that I have got the answer. Parrots don't talk in the same way human dos with

understanding intent behind every word. Instead they are remarkable something like that. Right? So this is the output

from the Google geminy 2.5 flash. Now I also want to show you instead of using init chat model we can also use one more

way. Okay. And that is basically by using chat open AI. Chat open AI. Now in order to use chat openai what I will do

first of all I will go ahead and see in my requirement.txt okay requirement.txt txt do I have the

necessary library that I'm actually looking for okay now you may be thinking kish what kind of libraries that you

specifically require right so here we have already have lang chain open aai you know so langchain openai is

basically installed or not so first of all you have to probably go ahead and check that so if that is installed I

think you are good to go over here right now for chat openai if I really want to use what is the library that I need to

import right so here I will go ahead and write from langun Open AAI in importai. Then we will go ahead and initialize

chat open AI and here I'm just going to go ahead and give my model name. So model is equal to

and let's say I will just go ahead and use GPT4.1. Okay. So this is my model is equal to

and then if I go ahead and just write response is equal to model.invoke invoke let's say I go ahead and write

hello how are you? I should be able to get the same output like how we got it over here. Okay. So using init chat

model basically gives you an option of indirectly using this chat open. See here also when you see this specific

model it is nothing but chat open AI. So there is also one more way of basically calling this particular model. Now since

you have chat open AI and in the requirement.txt you have also installed langen Google geni. So here also you

have an option of something called as chat Google generative AI. Okay. So if I go ahead and paste it you can see from

langchain google genai import chat google generative AI I've used again Germany 2.5 flashlight to pirate stock.

If I go ahead and see the response uh you know this kind of suggestion will come. So don't get worried about it

because we are not going to use the suggestion over here. Okay. So here is my output from this specific uh Google

um means Google Germany integration. Now uh these are the ways you can either use in chat model you can use chat open AI

if you if you're specifically using open AAI models. If you want to go ahead and use uh Google Germany models then you

can use chat Google generative AI or within the init chat model you can go ahead and call the Google uh Google

models itself Germany models. Now the third one that I'm going to use is Grock model integration. Now similarly Grock

model integration will also be very very easy. Okay. So again two ways. One is by using init

chat model. So here you can see now uh I am imported init chat model. I have my environment variable set up for grock

API key. And then you can see I'm used init chat model with my gro. Now this time I'm writing grock over here. See

before I I wrote what over here Google genai and the model name of Google Germany but here this time we are

writing grock colon whatever model we want to specifically use from grock right you like quen is the recent model

that has been uploaded over this I used this and then we are using model invoke why do parrot talk I'm able to get the

response okay now you have init chat model so there should also be an option of chat gro okay so that will be my next

one to show you so Here you can see that I'm getting the output. Okay. So why do you parrots talk? Let me think about

this. I know parrots are mimicking human speech and all and all all the information is over here. Now one more

way that how we can basically call chatgro. So here you'll be able to see we can use lang grock. So again in the

requirement.txt you can see we have imported lang grock. So I've imported from lang grock import chat gro. I'm

calling the same model and I'm able to get the response. Okay. So here you will be able to see

that I'm able to see the output with respect to the same thing. Okay. So this is uh pretty much clear I guess with

respect to the model integration. I think uh we have done a pretty good job uh with respect to this and uh the all

the integrations specifically uh one two ways of simple integration or calling the loading the model is from init chat

model or let's say if you are using open AI then we use chat open AI if you're using Google geminy let's say inside the

init chat model you just write Google geni and then you basically write the model name whichever model name you so

this you can change I can also use uh geminy 2.5 flash. Let's say I want to go ahead and use this flash. So here also I

should be able to generate the content. It's like a very very easy approach of calling any kind of model specific to

the LLM providers. Okay. So here you can see all the outputs you are basically getting. Okay. So this was about model

integration. Now in my uh as we go ahead in this series, we will also be talking about the message structure, the

streaming structure and all. Okay. uh so probably in this series now we should also go ahead and understand the

streaming structure. So let's go ahead and discuss about that. So now we are going to discuss about this two

important topics which is called as streaming and batch. Okay. Now why streaming and batch is important. So

let's say that I go ahead and write model.invoke. You know how to invoke a specific model right? And let's say that

I say hey write me a 200 words paragraph on artificial intelligence. So let's say if I'm asking this question to my model

or to my LLM right and here you'll be seeing that we have to wait for the response to get generated and be

displayed over here right. So this usually happens in invoke right but it is always a good practice that we try to

stream the output as soon as is soon as it is generated from the LLM right so and that is where streaming can be very

very handful. So here you can see most model can stream the output content while it is being generated. Now in this

particular case we had to wait till the LLM completely generated the content and then finally it displayed the output.

But in the case of streaming, what we do is that we can also stream the output of the LLM model while it is being

generated. So by displaying the output progressively, streaming significantly improves user experience particularly

for long responses. So for this we have to use this function which is called as stream. Okay, this returns an iterator

that yields output chunk from the LLM and they also display it over here. So let's try to see that how this stream

will basically work right now in order to do or work with streaming we will be using this inbuilt function called as

model.stream stream. Okay. And let's say now I go ahead and ask, hey, write me a 200 words paragraph. Okay. On artificial

intelligence. So let's display this right now. Okay. Let's execute this. So here you can see that it is creating a

generator object. But our main aim is that this is of a stream type, right? We also need to display the output from the

stream. So what I will do? I will use a for loop. So I'll say for chunk in modelstream

and let's display sorry let's display the stream output. Okay so here I will go ahead and print and I'll just go

ahead and write chunk dot text. Now let's display this. Now here you can see that once we go ahead and execute this

it did not wait for the entire content to be generated. So what we have done is that as the content is being generated

from the LLM, the LLM is giving you the output. It is also getting displayed over here. Okay. In a much more better

way for you all to see, what I will do, I will use some special character to just you know to just show you the

content that is basically generated. So I will use this two parameter end is equal to that basically means I'm using

some kind of delimiter over here. as soon as any token is generated from the LLM and we also going to use flush is

equal to true. Okay. Now see the output I have written write me a 200 work paragraph and here you can see that we

are generating this particular text and this text is basically getting generated over here. Okay. Now let's try some more

uh some more good things inside this uh instead of just writing like this you know I will also go ahead and uh you

know just try to display something over here. So let's go ahead and do this and here you can see that I'm just writing

why do parrots have colorful feathers okay feathers. So now it is going to print the chunk.ext text and here you

can see that paragraph by paragraph as the content is basically getting generated it is also being displayed in

the output. So this is an example of stream and the main thing is that you can stream the output from the llm while

it is being generated right. So we don't have to wait till the entire text is generated. Now if I go ahead and ask the

same question over here. So let's say I go ahead and ask the same question and here instead of you know why [snorts] do

parrots have colorful feathers? If I just go ahead and use model.invoke. So here what I will do I'll remove all

these things. Okay, I will remove all these things and we will try to generate it by using model.invoke. Now see we

have to wait for the output. Okay, model.infoke it is giving me some syntax. No worries I will fix it. Now

see I'll wait for the output. I'm waiting waiting waiting and then finally the response gets generated. Right? Once

the entire response is output is created then only it'll get generated. But in this case of streaming as it is

generated we also able to see. Okay. Now, similarly, there is also one more concept which is called as batch. Okay.

Now, batch is a collection of independent requests to a model which can significantly improve performance

and reduce cost as the processing can be done parallel. Now, there may be scenario that you may have multiple

inputs. So, let's say I will go ahead and create some kind of response. See, I'm using model.batch batch function

inside this I have a list of inputs like my first question is why do parrots have colorful weathers I'm writing how do

airplane fly what is quantum computing now I have three different questions and I want to send all this question as an

input to the LLM model in a parallel way right I want the output parallelly right so that is what it is over here you can

see batch is a collection of independent requests to a model which can significantly improve performance and

reduce cost as the processing can be done parallel. So if I'm giving three inputs, this will go parallelly to the

model and generate the output. So let's go ahead and see the output. Now here you can see all these three questions

has gone together by using this model.batch and automatically you'll be able to see all the output all at once.

Okay, three responses it will generate and you are able to see the output all at once. Similarly, I can also set one

more parameter inside this which is basically called as max currency. Right? So there is a config parameter which you

can basically add along with this model.batch functionality which says that how many parallel calls you can

actually make. So here you can go ahead and set it max concurrency is equal to five and then probably go ahead and do

it right. So anyhow my questions are three if I'm giving 10 10 different questions all at a time. So it'll take

five five and then it'll probably send it to the LLM and generate the output. Right? So I hope you got a very clear

idea about streaming and batch and this is necessary because if you are working for any company developing chat bots

most of the time you are definitely going to use streaming but there may be scenarios that you also want to probably

go ahead and use batch functionality. So I hope you like this particular video. So I hope you have understood this. Now

let's go ahead towards the next section wherein we are going to understand about tools creation. So guys till now we have

already discussed about streaming and batch and along with this we also saw the model integration like how you can

go ahead and integrate different kind of LLMs with the help of two important functionality or two important

libraries. one is initate chat model and you can see that we have also used chat gro chat open AI and uh along with that

we also had chat Google generative AI right now it's time that uh we move towards one more step ahead and we talk

about how to go ahead and work with tools so if you remember we had discussed about a simple agent right in

an agent basically an LLM will be connected to a tool now this tool is just some kind of functionality It can

be a API request. It can be uh inbuilt tools. It can be news reporting tools. It can be Google search engine tool. It

can be any kind of independent functionality tool. Right now in this series of videos now we are going to

understand like how we are going to go ahead and create tools. Right. So first of all what I will do I will go ahead

and create a ipynb file. And here you can see tools definition is basically given. Model can request to call tools

that perform tasks such as fetching data from a database, searching the web or running code. Tools are pairing of a

schema including the name of the tool, argument and definition and function or core routine to execute. So here what we

are basically going to do is that first of all I will show you how you can basically create a tool right in a

simple way. So first of all as usual I will use one of my LLM model. The LLM model that we are going to use is Grock

Quen 332B. And here you can see that I'm also able to invoke the model. This we have already learned in the previous

section. Right? So inside this response you will be able to understand like what is the response that you're getting from

the LLM. [clears throat] But with this particular model I need to integrate some tool. Okay. Now in order

to integrate what tool I will first of all create and what is the basic schema definition for creating a tool. So

whenever we need to create a tool first of all I will go ahead and you know use a import function from langen.tools. I

will import something called as tool. Okay. Now this tool library that we are importing over here will be used as a

decorator. So when we use this as a decorator on top of any function that function will actually become a tool in

langin. Okay. So here first of all we'll write add the rate tool. I will go ahead and define my function. Let's say this

function is nothing but get weather. Now inside this get weather I will be using a variable which is called as location.

And this will give you a string type. Okay. And here I will also go ahead and define. See if you see the definition

whenever we talk about tool it is nothing is pairing of schema including the name of a tool description and or

argument definition. So here I am going to go ahead and provide some dock string. Now this dock string will play a

very important role. I will talk about it. Okay. So I'll say at a location. Okay. So get weather at a location. Now

this definition uh this schema that we have or this doc string that we have defined over here this is important

because when we bind this tool with the LLM the LLM will be able to identify the functionality of this particular

function okay what exactly it is doing from this particular dock string okay so that's the reason we have written this

dock string so now I will go ahead and say return and here you can write any functionality that you want okay so

let's Say I'm hard coding right now the temperature. What you can actually do is that you can go ahead and hit a API

request or database request over here and get the information. So I'll write it's sunny in this specific location

which location I'm actually using. Okay, by default I'm saying it's sunny. Okay, now this is done right. I have a tool

over here. Now this tool needs to be binded with my model, right? So if you see over here if I want to bind this llm

with this particular tool how do I do it okay so for that I will be using model dotbind

tools okay so bind tools and here we are basically going to use this particular tool which is called as get

weather okay get here we can go ahead and write model_with

tools now this is one way okay the other way is that what we have learned right we can directly use this

we can use this function right create agent give the model name give the tools and automatically this will get created

right that we have already shown and this is one of the functionality which we used to use before also that is

nothing but binding tools okay now once I bind this tool the next thing is that how do I call this okay see now in order

to call it I will say model bit tools do invoke What's the weather like in Boston? And here now I can go ahead and

iterate through this response tool calls. See if I just go ahead and print the response. First of all, you'll be

able to see I'll print this response. Now, when we are printing this response

here, you'll be able to see that the reasoning contain is the user is asking for about the weather in Boston. I need

to use the get weather function. See automatically now LLM is able to make a decision that what functionality needs

to be called and here you can see that we also printing the tool calls that it is doing. So tool call of name is

nothing but weather and argument it is basically requiring is nothing but location. Okay. So this is the most

simplest way of you know working with a tool. Just directly go ahead and use a decorator provide some kind of schema or

dock string and just go ahead and bind it with the tool. Either you can do like this or if you're directly creating an

agent you would just define that particular schema uh means the function and then you use this create agent with

the model name with the tool name and here you'll be able to get it right. This is the most simplest way. Okay.

[snorts] Now I really want to show you one more important technique which is called as

tool execution loop. Tool execution loop. Now see first of all inside this what I will do I will

paste this code now see initially we set up a message from the role user saying that the user is sending the message

what's the weather in Boston now we are using model with tools do invoke of message then here I will be getting my

AI message and inside this message we are also appending this particular AI message and you know inside this AI

message it will be nothing but it will be a tool call right we are making a tool call which is nothing but weather

data Right? We are making a tool call over here. Right? Now for tool calls in AI

message.tool calls. Now that get weather.invoke of tool call we are doing. See at the end of the day if you

see whenever we make a tool call we are basically calling get weather. And internally we are using this get

weather.invoke of tool call so that we get the response from this. See over here if I go ahead and show you when we

are making the tool call the tool call will go ahead and provide us the output that is nothing but the context and with

the help of this particular code get weather.invoke of tool call we are getting the tool results and that also

we are appending it inside our message and finally you'll be able to see the message text since we are using model

with tool.invoke invoke now see I will execute this step by step you'll be seeing the weather in Boston is sunny

right and if you go ahead and just see this messages section messages section you should be able to see the role the

AI message that you got and the tool message like when the tool got executed it is giving this particular response at

sunny in Boston so when model with tools do invoke it is going it is basically getting the context from the tool and it

is displaying the output Right. So that's easy with respect to the tool execution loop. Okay. So I hope uh you

got an idea with respect to tools. Very basic way of creating this. Now the main thing is that internally you can write

any definition you want to use inbuilt tools that are available in lang chain. You can directly go ahead and write the

code. The most important thing is that what response you are basically generating out of that particular tool.

Right? So this was a quick revision on understanding about how you can actually specifically work with a tool. So now as

we go ahead now we are also going to discuss about one more uh important thing that is called as messages. Now

what are the different types of messages? There is something called a system message, AI message, human

message. So that part we will go ahead and discuss it. So yes uh let's go ahead and discuss about that. So guys till now

we have covered various topics specific to tools and how you can integrate tools with the LLM models um and probably go

ahead and create a generative AI application. Now we are going to move towards our next topic which is called

as messages right and messages uh in short are a very important data structures that can be specifically used

with langin. uh I will for I have written the definition I will go ahead and write the

code in front of you each and everything we'll discuss step by step so first of all the messages are the fundamental

unit of context for models in langen they represent the input and output of a model carrying both the content and

metadata need to represent the state of a conversation when interacting with an LLM messages are object that contain

role content and metadata role is super important. Okay, role basically identifies the message type. Now first

of all what I'll do is that in order to show you the messages till now we have discussed in various places right you

can see that I'm getting an output with respect to tool. So this is one kind of message whenever you see an output from

a specific model right like here we have written model.invoke invoke on a specific question. The model when it is

giving its output will be in the form of a message. So whenever a model gives an output, it is basically a AI message.

Whenever a human is giving an input, it is nothing but a human message. So there are different kind of message structures

that we are going to see. There are specifically three types which we are going to discuss one by one. Okay. So

first thing first, what I am actually going to do? First of all, I will go ahead and initialize my model. Okay, now

you know how to initialize your model. So I have imported OS from langchin.hat_model.

Import init chat model. I'm using the gro API key as my environment variable. And then we have used init chat model

with this quen model from grock. Okay. So I'll go ahead and execute this. Now see this is really important. Okay.

Whenever I go ahead and write model.invoke on any specific input. Okay. So let's say I'll say uh please

tell me what is artificial intelligence. Okay. So this is my question.

Now by default when I give this specific input to the model this is treated as a human input or a human message. So once

I execute this this as an input to the LLM is going as an input which is nothing but a human message. And when I

want to see the output, I'll just go ahead and execute this. Now my output will be basically an output from the LLM

which is nothing but an AI message. And the content that is inside this is the output from the LLM model. Okay. Now

this is what a simple message basically looks like. Now two things we have discussed about human message AI

message. I will deep dive more into it and probably talk more about it. Okay. But first [clears throat] of all before

going to human message AI message we will start with a text prompt. Okay. So text prompt are nothing but they are

strings idle for straightforward generation task where you don't need to retain conversation history. Okay. Now

here you can clearly see that whenever I'm writing model.invoke with some specific question. Okay. So here when

I'm writing model.invoke with some question. Let's say I'll say what is langchain.

Okay. Now in this particular scenario I have not specified anything to the model like how the model should behave. Right?

I'm just providing a simple text. Right? This text is treated as an human message internally. But I can also say this as a

text prompt. Okay. So idle for straightforward generation task where you don't need to retain any

conversation history. Let's say that I just want to give an input and get an output from the model. So in this

particular scenario, I will just go ahead and use this phenomena. Right? So when I say model.invoke what is

langchain, I will directly get an output in the form of AI message. Okay. Now use text prompts when you have a single

standalone request. You don't need conversation history. You want minimal code complexity and right now we will

see in the different type like one more category which is called as message prompts. So here we have seen about text

prompts. In text prompts I just specify my input. I get the output from the model. So now we will try to understand

how is message prompts different than the text prompt. Okay. Now here we'll first of all see the definition.

Alternatively, you can pass messages in the list of messages to the model by providing a list of message

object. Okay. Now you need to first of all understand if I want to provide a list of messages, it can be a human

message, it can be an AI message, it can be a system message. Now you should understand what exactly is a system

message. System message is just like an instruction like how the LLM should behave. Okay, again let me repeat it.

What is a system message? It is nothing but it is a kind of a instruction to the LLM like how it should basically behave.

So in the case of message types you have different messages like system message, human message, AI message and tool

message. First of all we'll understand the definition of system message. System message tells the model how to behave

and provide context for interaction. Human message is nothing but it represents user input and interaction

with the model. AI message is nothing but response generated by the model including text content, tools and

metadata. Tool message represents the output of a tool call. Okay. So all this information is basically over here. So

here you can see system message definition, human message, AI message and tool message. So let's go ahead and

see this particular example. Okay. So first of all what I will do I will go ahead and import all these messages

type. So in order to import I will use from langchain dot messages import system message

human message AI message. Okay now I will create a list of messages. Let's say that I'm

having a conversation history also. So that's the reason I'm creating this list of messages. So let's say first of all I

use a system message. Now this system message is just like an instruction to the LLM model like how the LLM model

should behave. So I'll go ahead and write you are a poetry expert. Okay. So this is my first message. Let

me go ahead and write human message over here. In the human message I will go ahead and say um this will be an human

input. I'll say write an write a poem on artificial intelligence. Okay,

artificial intelligence because in chatbot usually this kind of conversation happens in a conversation

history, right? There'll be a list of messages that will be happening. So let's say here uh I give the output or

let's say I give this two information like a system message and a human message. Okay. So this is my list of

messages. Now I'll use model.invoke and I'll give this messages over here. Okay. Over here I'll get it and I'll go ahead

and get my response. Now let me do one thing. Let me go ahead and print my response dot content. Okay. Now see this

both the messages are basically going. Okay. First is the instruction to the LM like how you should basically go ahead

and u act like I'm saying you are a poetry expert and then probably I've given the input and based on this input

I will be getting my AI message as the output okay the user wants a poem about artificial and let me start thinking

about the key themes related to AI creating experts how human build AI then maybe do and all this information is

basically there and you're getting the output okay so this is what a simple you know a list of messages prompts look

like okay here we can pass a list of messages in the form of a conversation history here I can also go ahead and

write I provide AI messages over here and probably go ahead and try it out okay now let's see some more important

thing right here the kind of examples that you have seen is with respect to a system message okay this was just a

basic message itself right you just have a oneliner let me see one more example So here I've written system message I'm

writing you are a helpful coding assistant. I've given this messages list human message as an input. How do I

create a rest API? Right? And now you can also see this specific response. It will go ahead and try to create a rest

API. So here you can see all the information. Okay. The user is asking all this information is basically can

creating a rest API invoid involves defining endpoints that handle this and that. All the information is there.

Okay. So that basically means we are able to get a good answer. Now till now the system message that we have

specified is just a oneliner message. Sometime we want a detailed information provided in the system message so that

we give more information to the LLMs. Right? So what we will do I will show you one more example where we give

detailed information detailed info to the LLM through system message. Okay system message. So let's see this

example. So this example is also really good. So here now I will say like this. Now see inside this we have provided a

system message. I'm saying you are a senior Python developer with expertise in web frameworks. Now more context is

basically given here. Before that I've just told that hey you are a helpful coding assistant. We have not specified

any specific programming language like Python, Java, you know it can be C, C++, anything as such right? I've just

provided a generic information. The answer was also very generic. Okay. But in this particular scenario, you can see

that I provided a detailed information. You're assistant senior Python developer with expertise in web frameworks. Always

provide code examples and explain your reasoning. Be concise but thorough with in your explanation. Now I wrote how do

I create a rest API? The same thing. Now you see the response. The re response will be much more practical and it will

be related to definitely Python. So if you go ahead and see this here you can see start the steps choosing flask

install it the code example everything is over here and lot of messages are over here disable debug mode in

production add input validation and all right so you can clearly see that if we provide

more information inside this system uh message we will be able to get more proper response okay now this is what a

simple things is right now I have also told you that whenever we provide the messages, we can also provide this three

important information. One is role, content and metadata. Role basically identifies the message type whether it

is system, user or human. Content represents the actual content of the messages. It can be text, audio and

documents. Metadata is some kind like an optional fields. Okay. So let's say that I want to go ahead and define some kind

of human message over here. Okay. My my human message with some metadata. So here you can see content is hello name

is Alice ID is message 1 2 3. So here you can see we are providing two metadata information one is for

identifying for different users and one is uniquely identified for tracing. So this is basically for tracing you know

so that we can go ahead and trace it. Now if I go ahead and see the response see if I go ahead and just use

model.invoke on this human message you should be able to see the response. So the user said hello. So I should be in a

very friendly way. It'll be able to probably provide the response based on the metadata information also that we

specifically have. Okay. Now this is just a specific idea about how you can play with system message, human message.

Uh you know you can also have uh AI messages. You we have also spoken about the list of messages that you really

want to work on. Right? Right. Let's see one more example. Okay. Now this example is also amazing. So here you can see I

have written from langchen messages. I have imported AI message, system message, human message. AI message is

that I'd be happy to help you with the question. Okay, create an AI message manually. We have created it. Okay, this

is not generated by AI itself but we are creating our own message and we are assigning as label as AI message. Now I

am adding all the information into the conversation history. So say they say you are a helpful assistant. I have

written as a human input initially we have written can you help me AI message is nothing but I'd be happy to help you

with that question human message great what is 2 + 2 now this entire list of conversation can be also understood by

the llm and based on this it should also be able to give you the output so here you can see clearly how the output is

right first 2 + 2 is four that's straightforward but may I should I explain this this so this is a reasoning

model that we have specifically used right so That's the reason it is providing a lot of reasoning stuff and

all. Now inside this can I also go ahead and see my metadata. So in order to see the metadata so I can write response dot

metadata. Okay or usage metadata. And here you can see that you'll also be able to get the information like uh how

much was the input token, how much output token was generated by the LLM and what are the total number of tokens.

So that you will be able to see all the information out there. Right? So this is also there. Now we have discussed about

all the things. There is only one message that is remaining that is nothing but tool messages. Now already

in our previous example we have understood about tools. Tools message is nothing but it's just like an output

that is provided by the tools. Right? So whenever an LLM require a help of a tool, it will go ahead and make a tool

call and whenever that tool specifically gets executed, it is just going to go ahead and give you the output. Okay. So

finally let's go ahead and talk about tool okay and here I will be taking another example

right so here you can see I've used AI message and tool message in the AI message I've empty content but we are

making a tool call okay the name of the tool that we are going to make is get weather argument is nothing but location

as San Francisco and we have also used id result whatever we are basically getting we have hardcoded it now I'm

using this tool message with content is equal to weather result and tool ID. Now see I've asked the question what's the

weather in San Francisco then AI message is basically given from here okay and then tool message is nothing but the

output uh that we get from here after executing the weather result. So now if I go ahead and execute this and probably

go ahead and see the response I should be able to get the output as okay uh uh one more very important thing is that if

you see this specific tool message okay so if I go ahead and see my tool message it is nothing but it is coming as a tool

message okay and once this tool message is there we are giving as an in uh input to the model so that is the reason

model.invoke invoke of messages when we execute we are getting the response as AI message. So I hope you got an idea

with respect to different types of messages. You can go ahead and try it out. Explore more about it. You know u

since this is the updated version of langchain uh my responsibility is to cover all the specific topics as the

updates are basically coming up. Okay. Now uh as we go ahead we'll also be talking about different structured

output where we talk about pentic we talk about nested structures we talk about typed deck. Um so that part uh we

will be covering now. So now we are going to discuss about structured output. Till now uh we have

already seen messages. We have also got to know about the different type of message prompts like system message,

human message, AI message and tool message. And we also saw multiple examples and how to implement it with

the help of langen. Now in the structured output, why is structured output actually required? Okay. Now see

guys uh we will definitely be using different different LLMs and we want this LLM models to be requested in such

a way that so they provide the response in a format matching a given schema. So let's say that hey I am requesting a LLM

model to write me an essay on some specific topic and I definitely want the response of that LLM model to follow

some structure and that is where I would definitely want some kind of structured output right so this is where we

implement or we make the LLM to give a kind of structured output and we do it by using different techniques some of

the techniques are like py identic we can also use type date we can use data classes and that is what we will be

discussing in this particular section okay so over here you can see I have written a very detailed explanation

about structured output it says that model can be requested to provide a response in a format matching a given

schema is useful for ensuring the output can be easily passed and be used in subsequent processes langchen supports

multiple schema types and methods for enforcing structured output So the first uh technique that we are

going to use or first type that we are going to use is something called as pyntentic. Now pyntic model it provides

a richest feature set with field validation description and nested structure. So I will show you one

example like how we can create a structured output from the LLM specifically for the LM response itself.

Right? So first of all what I will do I will go ahead and import OS along with this what I am actually going to do is

that I will also go ahead and the first step is obviously I have to load my uh lm model right so I'll write from langin

dot chat models importit chat models right then I will write osen environment

and here I'm going to specifically write gro_i is equal to os.get get env since I'm

actually going to use my gro API key right so I'll write gro API key [clears throat] now the model that I'm

actually going to use is nothing but I will be using this gro model groan uh the model name is nothing but quen

and we will be using quen 32 billion parameters model it's a reasoning model right so this is the

model that I So here you can see [clears throat] cannot import uh name in it chat models.

Okay let's see what is the issue. So here you can see there is something called as init chat model. Uh we had

made a different import but it's okay. We have actually loaded our LLM model. Now let me quickly show you that how

with the help of pyentic you will be able to generate a structured output. The best part about pyntic is that it

also has field validation descriptions and also nested structure. So first of all in order to use pentic we need to

import one library which is called as from pentic import base models. Okay,

field. So this field is uh what we are going to specifically use in order to use field validation. Now here let's say

I want my lln to give the output in a some kind of structured schema. Okay. Now what schema it will basically

follow. So what I will do for that I will create let's say a class called as movie and inside this movie we will

inherit with this specific base model. Okay the base model that we have imported over here. And if you see that

it is nothing but it is a base class for creating pyic models. Right. and pying model has a very important property that

it provides you field validation description and it also provides you nested structure. Now let's say my

structure output from the LLM needs to have different fields. Okay. So one of the field is nothing but title. So let's

say this title should be of only type string. Okay. So here we are writing colon string. Okay. And this will be of

type field. And here I can go ahead and provide some description saying that this title is nothing but it is the

title of the movie. Okay. Now see my LLM needs to definitely generate some kind of output and it will

generate based on whatever fields I'm actually creating over here. And we are going to make sure that this title

should only be having string value over here. If it has a numerical value then it'll give us a error because pyic uh

will do this kind of field validation also. Okay. the pyntic model. Now, similarly, my second field will be

nothing but year. Let's say my year is there and it will be of int type and I will go ahead and write field and here

again this will be my description and I will say hey this is the year of this year.

This year the movie was released. Okay, the movie was released. And then coming to the third important let's say

that I want to also create one more field inside this. It is nothing but director string. And again I can

basically say this is a field. Now see you understand what this field is right. If you go ahead and uh just hover over

it and if you see what exactly field is this is basically providing you lot of different different parameters that you

can set which represents this particular uh variable right the year. Okay. So here I've just given that this

particular field is nothing but this is the year the movie was released. This information will be very much important

for the LLM right because once we are giving this kind of descriptions we can also set some other parameters like uh

you know we can set a liar. This will be very very handy because it will help the LLM to know in which field it needs to

place the output that it is coming from the LLM itself when we are displaying that in a structured output. Okay. So

this is my uh director field. In the director field, I will also go ahead and write some kind of description so that

it gives some idea to my LLM saying that okay, the director of the movie, director of the movie. Okay. Then I have

my ratings. This is also one field that I definitely want. My rating can be a float value. Okay. It needs to be a

float value because it can have different float value itself. And then I have my description. Inside my

description, I will go ahead and say the movies movies ratings

out of 10. Okay, out of 10. Now see this is the output that my LLM should be generating it. So that's the reason I've

created a class called as movie and it is inheriting base model. Inheriting base model basically means it is it is

just going to go ahead and if you just hover towards this base model it is it is nothing but it is a base class for

creating pyic models. And one important thing is that this pyentic model has real validation description and all.

Okay. Now let me go ahead and execute this. Okay. Now if I want my model to generate the structured output. So what

I will do I will just go ahead and write model with structure output and we will give like what structure output it needs

to give of this particular movie class. Okay so this movie class is over here and here I will go ahead and define

model with structure. Okay model with structure. So this is what uh my uh important model way is you

know now see as soon as I go ahead and execute this. Okay, I go ahead and execute this and if you go ahead and

just display it what is this model with structure, it shows that it is a runnable binding.

It has uh information from Chad Gro model and then it also has this py tool parser. Okay, now this is really

important because now I'm going to display how the output will get displayed whenever we ask any question

to this particular model with structure. So for that I will go ahead and write model with structure dot invoke

and here I will go ahead and ask a question provide details. Let's say I want a details about the movie movie

inception. So if I go ahead and use model invoke if you remember model is nothing but it is not having any schema

attached right. So here if you are attaching any schema or any structure output it is nothing but model with

structure. So if I just go ahead and write model.invoke and I say hey provide me the details of the movie Inception.

So here you can see this is how is the default output we will get. Okay once we execute this see this is my AI message.

Okay I need to provide a detail about the movieception. The inception probably has to do a concept of planting an idea.

So it is probably providing all the details but I don't want all these details. I want the details in this

structure output. I want it in the form of title, year, director, rating. Right? So I should be able to get that. Now if

I go ahead and use this model with output dot invoke and now I want to go ahead and create I'm asking the same

question. See over here I'm asking the same question response. Now if I go ahead and display the response, you