Let's have a look at output parsers. Output parsers is one of those topics that seem to get overlooked in Lang chain and Flowwise tutorials. And in my opinion, it's probably one of the most important features to learn.

We will use output parsers in some more complex scenarios throughout the series, but in this video, I do want to show you the fundamentals. So to get us started, I've created a very simple flow that contains an LLM chain, the OpenAI node with the GPT 3. 5 Turbo instruct model, as well as a simple prompt template.

So far, this is nothing new. Let's go ahead and set up our prompt template. So let's expand this, and for the prompt template, let's type something like "Determine if the following sentence is true or false", and let's add a placeholder called "sentence".

Let's save this. So let's save this chat flow, then let's test this out, and let's enter something like "The sky is green". And we get this text back with the value of "false".

But take note that this is simply a string value from the model, and this could be uppercase false, lowercase false, there could be quotes, it could even be an entire sentence. So we can actually use an output parser to ensure that we receive the response in a specific format. And you will see later on in this video, how we can then use that value to implement some very cool logic.

So let's close this, and let's click on "Add nodes", then let's open up output parsers, and let's add a structured output parser. Then let's connect this structured output parser to the output parser input on the chain. Then within the structured output parser, click on additional parameters.

We can go ahead and delete these two sample properties. Let's add a new item, we can give it a name by double clicking on this property value. I'll give it a name, I'll just call it "sentiment".

For the type, we have the options of setting a string, a number, or a boolean. And what we want is a boolean value, which can only be true or false, and not a string and a whole bunch of other things. And in the description, we can enter something like "sentence is true or false".

Let's click off this popup to close it. Let's save this, and in the chat, I'm actually going to clear the chat history. And in the chat, let's type something like "1 plus 1 equals 3".

And you will now notice that instead of receiving a string response, we now receive a JSON object. And within this object, we can see that property "sentiment" with a value of "false". Now, this might seem a little bit technical if you're not familiar with JSON, but don't worry, I will show you exactly how we can use this in a very simple way within this flow.

But for those of you with JSON experience or coding experience, you can probably already see the benefit of this. For example, let's say we call our Flow-wise application through an API endpoint, and we expect to receive a JSON value coming back. So in our code, it's very easy to use this response.

If that didn't make sense to you, please don't worry, it will all make sense as we start using this in the series. Let's have a look at another interesting use case of this. Let's change this prompt.

So let's remove this first part, and let's simply say "extract information from the following sentence", and let's save this. And let's click on "format prompt values", and let's ensure that sentence is indeed mapped to the question from the chat box. Now, let's say we've got an example where we pause in a sentence like "Max is 30 years old and married to Angie", and let's say that we want the model to extract the name "age" and the spouse's name from any given sentence, and it should then return that information in a very specific structure.

So let's remove that sentence from the prompt, let's save our Flow, let's update our output parser by clicking on additional parameters, let's remove the sentiment, and let's add an item called "name", which is of type "string", and in the description, let's enter something like the name of the person, then let's add another property called "age". For age, let's return a number with a description of the age of the person, and these descriptions are important as this will tell the model how to extract this information and which property to map that information to. Lastly, let's set another property called "spouse", which is of type "string", and for the description, I'll enter the name of the spouse.

Let's close this, let's save the chat flow, and let's test this out in the chat. Let's enter "Max is 30 years old and married to Angie", and let's send this. And I think it took less than a second for that response to come back, and we can see that our application was able to successfully extract the name "the age" as well as the name of the spouse.

Now imagine using this in an actual application. The user can pass in pretty much any sentence, and this flow will extract all the relevant information and return it in a format that we can use downstream. Let's have another look at where this can be useful, and then I'll show you how we can conditionally call chains using an output parser.

First, let's change this prompt template to something like "provide a comma separated list of synonyms for the word word". Let's save this, then in the format prompt values, let's delete "sentence". Let's add a new value called "word", because this is what we call the placeholder in the prompt template.

Let's click on "edit", and let's select the value from the chat box. Let's also go ahead and delete this structured output parser, then let's save this chat flow, and let's run chat. Let's clear this, and in the chat, let's enter a word like "happy".

We now receive a list of comma separated words like so, but again, this is simply a string, and there's no guarantee that the model will always respond with this specific structure. We can force this into a JSON list by adding an output parser. In "add nodes", let's go to "output parsers", and let's select "custom list output parser".

Of course, let's connect this to our chain. For this list output parser, we can specify the separator, which will be a comma in this instance, and we can simply leave length blank. Now, watch what happens when we run the same chat again.

Let's parse in "happy" again, and this time, we receive a JSON list of string values. So again, if we are using this flow in an application, we can simply use this as an array and loop through the values. Now, let me show you another powerful use case of using output parsers, and that is to conditionally call different chains based on a value.

Let's delete this output parser for now, and let's change this prompt template to something like "determine if the following review is positive", and let's add a placeholder called "review". Let's save this. Then let's open format prompt values.

Let's delete "word". Let's add a new value. Let's call it "review", and let's click on "edit", and let's select the value from the chat box.

Now, before we add an output parser, let's simply save this. Let's run this in the chat, and actually, let's clear the chat history, and let's write something like "the service was terrible", and this tells us that this was a negative review, or what about "the food was great", and this is positive. So let's say we want to call a different chain, depending on whether the review was positive or negative.

So let's actually add two more chains to this flow. So I'll add a chain over here, and let's say this is the positive chain, and this chain will specialize in positive reviews. For example, we might want this chain to thank the user for their positive review, and then ask the user if they would like to post a review on our website.

And let's add another chain that will specialize in dealing with negative reviews. I'll actually call it "negative", and this chain could, as an example, ask the user if they would like to log a support ticket, and apologize for the bad experience. So we've learned in the previous videos that for these LLM chains, we need to add a model as well as a prompt.

Let's start by adding a model, and for the model, I'm actually going to use a chat model, and specifically the chat OpenAI model. And that is simply because we've seen in the previous video, these chat models produce way better output than the instruct models. Let's go ahead and select our credentials.

I'll leave the model as 3. 5 turbo, and I'll set the temperature to 0. 7.

Let's also add a prompt template. So under prompts, let's select a prompt template, and let's connect this prompt template to the chain. Then let's set our template by clicking on "expand", and let's enter something like "You are a customer support assistant".

First, thank the client for the review, and then ask if they would like to post a review to our website. Also summarize the review, and let's add a placeholder called "review", and let's save this. Now let's do the same thing for the negative chain.

First, let's add a model. Again, I'll add a chat model, and I'll add the chat OpenAI model. Then let's connect this model to the chain, let's select our credentials.

I'll leave it as "gpt 3. 5 turbo", and let's set the temperature to 0. 7.

Now for the prompt, let's go to prompts, and let's add a prompt template. Let's connect the prompt template to the chain, and let's give this a value, and let's enter something like "You are a customer support assistant" that deals with negative reviews. Write an apology for the following review, and ask the user if they would like to be contacted by a customer service rep, and it's also adding our review, and it's prefix this as well with review, like so.

So if you wanted to, you could try and cram all of this into a single prompt, but in real world applications, these chains might use different models based on what we want them to do. And once we have a look at agents, you might want to hand this output over to a chain in one instance, or in another to an agent. But this example is good enough to demonstrate the point.

Now let's have a look at how we can conditionally call these chains based on the output of this chain. At the moment, this chain will tell us if the review is positive or negative, but this is simply a string value, like so, and there's no guarantee that this response will always follow this convention, and the model could even return an entire sentence if it wanted to. So let's use an output parser to force the response to be a boolean value.

So under nodes, let's go to output parsers, let's add this structured output parser, and let's connect this to this chain. Let's actually call this the sentiment chain as well. For the output parser, let's click on additional parameters.

Let's delete these sample properties. And for the value, let's call it positive. For the type, let's set it to boolean.

And for the description, let's say the review is positive. So if the review is positive, this value will be set to true. Otherwise, it will be set to false.

So now we know we will always receive a JSON object with the property positive, and that value can either be true or false. Now, in order to conditionally call these chains, I'm just going to make some space by moving these chains over a bit, like so. And now we can conditionally call these chains by adding a utility called if-else.

So under add nodes, let's go to utilities, and let's add this if-else function. We can now use this if-else function to conditionally call chains based on the input that it receives. So let's pass the output of this chain into the if-else function.

First, let's change the output to output prediction, and then let's attach this to the if-else function. We now need to give this input a variable name. So let's click on add, and let's call this sentiment.

We can now assign a value to sentiment by clicking on edit. Let's click on this input box, and let's select a value from the sentiment chain, like so. So we know from the output parser that this response will return one property called positive, and this can either be true or false.

So we can now reference that value in this function, and this might seem a little bit intimidating if you're not familiar with coding, but don't worry, this is not too difficult to understand. And this is the few times in Flow-wise where you might have to write very simple code. Just follow along in this if-function block, pick on expand, and what we want to do is reference that sentiment variable, which is called sentiment, and in order to tell this that we are referring to the variable, we simply have to add a dollar sign in front of it.

And within sentiment, we have one property called positive, and what we want to do is if this value is true, remember, it can only be either true or false, then we will return the value of true. Let's click on save, and for the else function, we don't have to change anything. So how this works is this if-else node has two outputs, a true output and a false output.

So if the condition in this first block is true, then whatever chain is connected to this true output will be called. Otherwise, whatever is connected to this false output will be called. So if the sentiment is positive, then we want to call this positive chain.

So we can do that by connecting this true output to the prompt value of the positive chain, and we can connect the negative chain by connecting this false output to the prompt value of the negative chain. And now you should be left with a flow that looks something like this. So in a nutshell, the first chain will return a structured output with a property called positive, which is either true or false.

That value is then passed into the if-else function, and if sentiment. positive equals true, then we call the positive chain. Else, if the sentiment was negative, we will call the negative chain.

Now let's test this out by saving the flow. Let's click on chat, and let's type something like "the food was awesome". And now we are receiving a response from the positive chain, saying "Dear valued customer, thank you so much for taking the time to share your feedback.

We truly appreciate it. " In order to showcase your review on our website and to let others know about your experience, we would like to ask your permission to post it. Fantastic.

And in the series, we will have a look at adding tools to these applications that will actually make updates to databases. Let's try a negative use case, something like "the waiter was rude" and "the food was called". And this time, based on the prompt template, we expect the model to apologize and ask if a customer support rep should contact the customer.

So let's see if that is the case. Firstly, it is apologizing to the customer, and indeed we can see a message saying, "A customer support representative would be more than happy to reach out to you and personally address any concerns you may have. " So there are plenty of use cases for output parsers, and I hope you do see the value of learning this important tool.

Output Parsers & IfElse Function - FlowiseAI Tutorial #4