LangGraph Tutorial: Mastering Branching & Conditional Flows for AI Agents

Key Takeaways

Hey there, it's good to see you. The next concept that we want to cover in this video is the concept of branching and conditional flows in Langraph. And this is important because it gives you the ability to decide which node to invoke based upon the outputs from the previous node. Let's dive deeper into this. So first let's talk about why branching is introduced in this entire workflow. Because branching lets the graph route the state to the right node. A lot of times based upon the user intent, you need to invoke a respective agent. Say for example, if your user is just about small talk, right? So they're just randomly chatting about any particular query that they have, right? So it's not anything specific, right? So it's just a question on the small talk that the users are doing. How how are you and things like that. You do not need to route it to any specific person. But example could be next. Next next up, they could even ask for some support. Let's say they their order is stuck somewhere or they are waiting for a refund to be issued things like that. So in such case you can then decide to have a support agent that can help user you know answer the respective question and if that particular support agent also cannot handle it then you need to hand off to a human so that a human being can actually you know assist that particular user. Now branching is basically this particular node which allows your state to be redirected to the correct node based upon the intent of the query. Now typically in lang graph branching is achieved as follows. So you have a classifier node which basically classifies the intent based upon the values provided in the state and the classifier will then return a label. This label will indicate which successive node to invoke and the edge will basically use that label to decide which is the next node to be invoked in that particular work. So now for example let's say the classifier node at the top will read the latest user message and based upon the intent it will either route it to a support assistant or a general chat assistant. So if the user's in instant it will basically do a simple chitchat right? So it's it's not specific. It's just a random uh you know short talk or a small talk that the user wants to perform then we can route the agent to a simple general chat agent. But if not you want the users to have a dedicated support agent to answer the query. Then if it looks like a support question then you will have to route it to a support agent. Now this basically this classifier node will then redirect you to the correct agent and the graph will then return a state after the selected agent has run. So if this agent has run the state will be updated by this agent. If the second agent has run it will be updated by the second agent. Now the conditional edges has to be implemented follows right. So edges can be defined with small Python functions. We will define it as well in our hands-on. These function will read the state to decide which is the next node to be called. And here typically the routing logic is pretty simple and easy to test. We are going to keep it pretty simple so that we can test it out as well. Always remember to have some fallbacks because this fallback node is basically the node which is going to be invoked if something goes wrong. Right? So while having the conversations going you find that the user intent is not you know supported because the user is continuously asking you to redirect to let's say a customer or support a actual human being. So that actual human being can be a fallback mode. So in case this entire workflow fails you redirect the user back to a human so that the human being can start interacting with an agent. So always have a fallback mechanism in place which can be invoked in case anything in that entire workflow goes wrong and branching helps better error handling logic isolated right because of that right so because when you have a fallback this fallback can be a dedicated node in itself and hence the error handling can be isolated from the rest of the code right so if a tool fails then you can go to the error handler as well so that you can gracefully exit out of the code and actually redirect your queries to a user to help that particular user out. So what are we going to do in this hands-on? In this hands-on, we are going to add a simple classifier node to an existing graph. This node will then decide which agent to invoke and we'll also print and log which branch was chosen based upon the example query. Let's jump into the hands-on to practice this out. All right. So now in this demo, we are going to see how branching and conditional flows work. As always, we are going to here we are going to keep it simple. We are not going to introduce any LLM in between. So the the formal idea is to have a initial state which is going to include the messages user input and now you will see a new field called intent which is basically what the intent of this user input is and depending on this intent we are going to then decide which node to call and the result is basically the output which is returned to us by the corresponding node. So we are going to initialize this particular state first and then we are designing this classifier node. As I mentioned, this is a simple Python function which takes your states and then depending upon the user input, we are going to decide what the intent is. So support keywords are basically the keywords that we are searching for in order to invoke our support agent. Right? So if any particular text contains the keywords like errors, issue, bug, refund, problem, support, anything like this, then simply we are going to set the intent to support if any of these keywords are present. Else we are simply setting it to chitchat. Meaning it's basically a small talk kind of a situation. And then we are going to take our messages. We are going to append a new system message which has classified the intent as whatever intent we have identified and we'll return back the updated state. And the support agent will then be invoked if the support is required or a chitchat agent will be invoked if the user is simply talking to that particular agent. And the user node is basically the input node that we are handling. So in this case the support agent is basically invoked anytime the user wants to have some support. Right? So in this case this is the simple answer that we are appending just to keep it simple. But if the chitchat agent is supposed to be invoked, then we are going to invoke the second agent which is going to interact with the user. And then let's create these and add all these edges to our graphs. Right? So we are going to add the nodes first. User, classifier, support agent and chit chat agent. And then you can see we are setting up the entry point as the user node. That's the first point of entry. Then we add the edge between user and classification. This is always deterministic. Every time a user intent comes, we are going to first classify the intent. And then after classification we have this particular function which is called route after classification. Now this will decide this edge will decide which agent to call. Now if the intent is support then we are going to return the support agent. This is the connection. Else we are going to return the chat agent which is basically this connection. Now here you can see we are then adding a conditional edge. So here this is basically a deterministic edge. But now we are adding a conditional edge which is based upon classification. And this is basically route after class. This is the name of the function that we are using and the inputs and the expected outputs that you are actually mapping it to. So if the output is support agent then it needs to connect it to support agent. If it is chitchat agent then it needs to connect with the chitchat agent right and then we are adding both these a edges together. Now now if support agent after that the workflow is ending and from chitchat agent also the workflow is ending because that's a conditional edge. We'll then compile everything and see what the updated app looks like. And as you can see here you will see a branched workflow this time wherein from the classifier we have two agents that can be invoked and depending upon the intent we are going to either invoke the chithat agent or the support agent and both of which will basically then end the workflow. The rest of the workflow is pretty much similar as the previous cases. And now you can see we have two queries. One which is basically kind of a small talk and the second one which is specific to a support query. And we will run both of these one by one to see which agent is invoked for the first one. Right? So user has this input and the system has identified the intent as chitchat which is correct and therefore the chitchat agent has been invoked here. The second one which was basically a refund issue. So therefore the support agent has been invoked and this time you will see the support agent got called and the result is coming from the support agent as well. Right? This is a quick demonstration of how you can add you know conditional edges in your workflows by simply setting up conditional edge and deciding based upon the intent which node to invoke next. That's all for this video. I'll see you in the next one. Thank you.