In a few minutes, you will be able to say 'Hello!' to your first solution in Teneo! Let's get started.

## Log in to Teneo Studio
First, you need to log in to Studio. 

1. Fill in your username and password. The login credentials are the same as for the team console used when signing up.
2. Click 'login'.

Once logged in you will be greeted by the main solution window. In this view, you can see all the solutions available to you in this environment. A solution can be thought of as a container where all the bot's knowledge is stored.

As you can see, the environment has already a solution called 'Longberry Baristas'. We will now go ahead and create our own solution to be placed right beside it. 

![1-log in](//videos.ctfassets.net/2vbtnveccz5s/1DdLI2eT8oePfzEjyUloVj/438c9e2c47d5eb8b44c56a498a3cf129/1-log_in.mp4)

## Create a solution
Building a bot in Teneo means building a solution. A solution is a container for all knowledge, conversational logic, and additional resources that make up your bot.
This is what you need to do to create a solution:

1. Select the Plus(+) icon in the bottom right corner and create a new solution.
2. Select a solution language for your first bot. This will be the mother tongue of your bot. For this example, we will use **English**. 
3. Under 'Solution Content', choose 'Create from Template' and select the latest version of your language, ('**Teneo Dialogue Resources English**') from the list. This will boost your bot with lots of pre-built flows. The bot will then, right out of the box, understand and respond to greetings, meta-requests (like 'Can you repeat that?'), feedback (like 'Great!' or 'You are funny') and conversational small talk.
4. Click 'Next' and continue by giving your solution a fitting name like, `My First Solution`. 
5. Finally, click on 'create' to create your first solution. It may take a couple of minutes for your solution to be created. You will be notified when it’s done.

![2-create my first solution](//videos.ctfassets.net/2vbtnveccz5s/5Ek2aiNBlpigZRGQ9QAANK/c89883807676cf0626931d336a86c0a3/2-create_my_first_solution.mp4)

Once your solution is open you will be greeted with the solution dashboard where you can see an overview over your solution properties, together with an explanation on each of the elements inside Teneo.

## Hello World!
Now that you have created your first solution, it is time to open your solution and talk to the bot. The 'Tryout' panel in the main solution window allows you to test your bot and chat with it.
1. Open your solution by clicking on its name in the main Solutions window. 
2. Once inside the solution, you will be greeted with the Solution dashboard.

Being able to have a conversation with your bot is a crucial part of the development process to ensure that everything is working as intended. Let's give it a try now.
1. To the bottom right corner of the Studio web window, you'll find a small icon with chat icons. This is the Tryout button where the user can talk to the bot. Click on it to open up the Tryout window.
2. Test the solution by writing `Hello` to your bot. The input field is at the bottom of the panel.
3.  Perhaps you can try some other small talk questions too, like:
*   `How are you?`
*   `My name is John`
*   `What is my name?`
*   `I like you`

![3-tryout](//videos.ctfassets.net/2vbtnveccz5s/2oqaARrY3bgEthmaK0C3YC/ae0491c660078e7d49daf1f760026d5a/3-tryout.mp4)

## Summary
Great job, you've created your very first solution! Let's take a quick recap on what we did in this section:
*   Created a 'Solution' that holds all the conversational logic of the bot.
*   Explored 'Tryout', which allows you to interact and test the bot directly from Teneo.

Studio Web - Your First Solution

Your First Solution

Now that you have created a solution for your bot, it's time to add your first dialog. In Teneo, all dialogs are designed as flows. Flows contain the logic needed to resolve a specific question of the user. They can be simple (e.g. a flow that answers the question "What kind of coffee do you have?") or complex (e.g. a flow that helps the user order a coffee), but they always represent some kind of pre-defined conversational pattern.  

Throughout these pages, we will create a bot for Longberry Baristas, a very hip (yet fictitious) coffee bar. We will start with a simple flow to handle the following conversation:

> **User:** What kind of coffee do you have?    
> **Bot:** We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.

To achieve this we will do the following:
* Create a folder in which we can store our flow.
* Add a new flow.
* Provide example inputs to recognize the user's intent.
* Generate a Match based on the provided example inputs.
* Add an answer text.
* Save and test our flow.

The result will look like this:  

![final flow layout](//images.ctfassets.net/2vbtnveccz5s/378hRv0r4i0TWNe3bRv89g/3bf979b04f1e9e69ac5fb5fdd0ed18c4/final_flow_layout.png)

Before you continue, make sure you are logged in to Teneo and have opened the solution you created earlier.

## Create a 'Flows' folder
Flows are stored in folders. In the solution, you see several folders with flows that came out of the box. These flows make sure your bot will understand and respond to greetings, meta-requests (e.g. 'Can you repeat that?'), feedback (e.g. 'You are great') and conversational small talk (e.g. 'How are you?'). Since you are the owner of this solution, you can change the answers in these flows if you wish.

We will store our flows in a separate folder, so let's create that first.

1. In the Solution dashboard in your new solution, click on the Solution Structure tile.
2. Click the Plus(+) icon to create a new document. Once clicked, you will have the option to create a folder. 
3. Click on the 'Folder' icon. Give it the name `Flows` and click on 'Create'.

![1-create flows folder-fixed](//videos.ctfassets.net/2vbtnveccz5s/1iXRzz3belNUkT1JS67B9G/4b3f70365792db86923a1f294a16e35f/1-create_flows_folder-fixed.mp4)

!!! You can add as many folders and sub-folders as you like and you can structure them any way you like. This is particularly handy for bots that handle multiple domains.

## Create your first flow
Now that we have a folder in which we can store our work, we can create our first flow:
1. Navigate to the Flows folder.
2. Click the Plus(+) icon followed by the 'Flow' button. This will create a new flow. 
3. Enter the name of the flow in the Name field, e.g. `User asks about coffees we offer`.
4. Finally, click on 'Create' to create your new flow.

![2-coffees we offer](//videos.ctfassets.net/2vbtnveccz5s/46WgFhJiU0eU31G2auPcbK/6b7ccdf510a8be40aba3bfdae545c7d6/2-coffees_we_offer.mp4)

As you can see, flows are represented graphically in Teneo. Simple flows just contain a trigger that recognizes the user's intent (the blue box at the top) and an output that contains the bot's answer (the purple box at the bottom). More complex flows contain more elements like multiple triggers, scripts, different outputs, etc. We're going to start with a simple flow, so you will only need to populate the trigger and the output that you see in the flow graph.

### Populate the trigger
Intents are used to recognize inputs from the user that express a similar intent. In this intent, we want to capture and understand the user's intent around which coffee Longberry Baristas serve. It is important to recognize that there can be several ways of expressing the same intent. For example, 'What coffee do you sell?' or 'Which coffees do you serve?'. To make the trigger match on user input, we need to add a [match requirement](/studio/flows/concepts/triggers#match-requirements). This requirement is essentially a criterion that needs to be met for an input to be matched.

1. Locate the intent at the top of the flow.
2. Give the intent a name like `Tell me about your coffee`.
3. Click on the 'Edit' button, located at the right corner of the intent. This will allow you to edit the User Intents field. Add the intent `What kind of coffee do you have?`.
4. Make sure you click on 'Close' to leave the edit window.

![3-populate trigger](//videos.ctfassets.net/2vbtnveccz5s/5HZr7lYC2Wwp6MTf4WrFH8/2ee2638a313439374334c70485699c7c/3-populate_trigger.mp4)

!!! You might have noticed that the Trigger Intent has a yellow 'TODO' label under it; this means that the trigger does not contain a defined Match yet. Hovering over the 'TODO' label will give you more info on what's missing. We will define a Match below.

Now, you can repeat the step above to add more examples.

1. Paste the following examples into the User Intent fields.
* `Do you have brewed coffee`
* `Do you serve macchiato`
* `Do you have cappuccino`
* `Tell me about the coffees you have`
* `Tell me about your coffee`
* `What coffee do you serve?`
* `What kinds of coffees do you serve?`
* `What kinds of drinks do you sell`
* `Which coffees are offered by Longberry Baristas?`
* `Which drinks do you have?`
* `Which sorts of coffees do you have`
2. Close the edit view. 
3. Finally it is time to add a Match to the intent. This can by done by clicking on the Plus(+) icon that has a yellow 'TODO' label beside it. 
4. Navigate to 'Match' and click on the 'Generate' button to automatically generate a Match based on the example specification.

![4-populate trigger pt 2](//videos.ctfassets.net/2vbtnveccz5s/4zjC40kCEbkQq6Hexft3ie/700b11f5d49850ec28422a1bb25e664f/4-populate_trigger_pt_2.mp4)

### Add multiple examples
When you generate a new Class Match, the class gets generated based on the training data that you assigned in the Intent examples. Once the class is generated, it gets added to the overall machine learning model of your solution. However, if you want to expand your Class with additional training data, you have to do so in the [Class Manager](/getting-started/class-manager). You will learn more about the class manager on a later page.

!!! The Intent examples are also used for Auto-tests for when you want to [automatically test your bot](/studio/refine-your-bot/how-to/how-to-test-your-solution).

### Add an answer text
Next, we will need to set the bot's answer in the flow. There are many options to define the bot's response. For now, we will focus on the answer text only.

1. Navigate to the Output node and give it a name like, `We offer a variety of handcrafted coffee drinks...`.
2. Click on 'Edit' to expand the edit view. Here you can add an answer you want the bot to give when the flow is triggered. Add the following answer to the output, `We offer a variety of handcrafted coffee drinks - from espressos to macchiatos to flat whites and more.` and close the edit view.

![5-add output](//videos.ctfassets.net/2vbtnveccz5s/4x1ndCPdTBVhXQ3yvHneTu/cb413b6c9ae2065dc327f38efbf8d54e/5-add_output.mp4)

## Save your flow
Now that we have added everything needed to our first flow, it's time to save it:
1. Hit 'Save' in the top right.
2. In the popup that appears you can leave a short description that will appear in the flow's version history, then click OK.

![6-save](//videos.ctfassets.net/2vbtnveccz5s/6Kg9YdoijoRBTezy4uzbMY/8723c27e5aef05deffa186fb62b26cf3/6-save.mp4)

!!! Adding a description will help you remember the changes you did and will show up in the Flows version history.

Done! Congratulations! You have created your first flow.

## Test your flow
Now that you have created your first flow, it's time to test your work inside Studio Web. 

1. Click on the Tryout button, located at the bottom right corner. This will open the Tryout window.
2. In this case, you can test your flow by trying out the following examples.
* `What kind of coffee do you have?`
* `What drinks do you serve?`

![7-tryout](//videos.ctfassets.net/2vbtnveccz5s/3zBESv8wutk9mKgdYpUd38/cf433c11398f79855c987446b6b4fa3a/7-tryout.mp4)

As you can see, both inputs will trigger your flow. Teneo not only recognizes the exact learning examples you entered but also different variations that express a similar intent.

## Summary
You have just created your first flow, so you have already seen a few important concepts in Teneo:
* Flows, which contain the logic to resolve a specific question of the user.
* Folders, where you can store your flows and language objects.
* Triggers, to recognize the user input or intent.
* Match, to set a criterion that the user input must match.
* Outputs, to provide the bot's response.
* Tryout, which you use to test your flows.

## Test yourself
Try adding another flow where the user can ask which coffee sizes are available at Longberry Baristas. The bot should return the three available sizes: **small**, **medium**, and **large**.

Studio Web - Your First Flow

Your First Flow

Sometimes your bot will need some additional information from the user before it can provide a final answer. On this page, you will learn how to branch after an output prompt and take different paths depending on the user response. These paths in Teneo are known as transitions and are used to tie flow nodes together.

We'll use the following example, where the bot provides information about the coffee mug to the user, and then the bot needs a confirmation from the user before it proceeds to reserve a coffee mug:

> **User:** I want to buy a coffee mug.  
> **Bot:** The official Longberry Baristas coffee mug is only available for purchase in our store. Would you like me to reserve a mug for you?
> 
> **User:** Yes.  
> **Bot:** I have reserved a Longberry Baristas coffee mug for you.

or

> **User:** I want to buy a coffee mug.  
> **Bot:** The official Longberry Baristas coffee mug is only available for purchase in our store. Would you like me to reserve a mug for you?
> 
> **User:** No.  
> **Bot:** Ok, I will not reserve a coffee mug for you.

To achieve this we will do the following:
*   Create a new flow.
*   Populate a trigger with example inputs and generate a Match
*   Add an output response in the form of a question.
*   Create a 'yes' transition if the user replies with 'yes'.
*   Add output response for the 'yes' scenario.
*   Create a 'no' transition if the user replies with 'no', and then add answer text for the 'no' scenario.
*   Save and test the flow.

This is what our flow will look like when it is completed:  
![final flow layout](//images.ctfassets.net/2vbtnveccz5s/52ulJkKdJX36FedBh4Mxrc/e8876727422cc71c4c32aee21a9f46b5/final_flow_layout.png)

This page will only cover the communication with the user. To actually reserve a coffee mug, we would have to integrate with a service; we will leave that part out for now.

## Create the basic flow and populate the trigger

The first steps are to create a new flow and populate the trigger with relevant training examples. Start by doing the following: 

1. Navigate to the 'Flows' folder and create a new flow.
2. Enter the flow name `User wants to buy a coffee mug` into the name field.
3. Click on 'Create' to create the flow.
4. Navigate to the trigger and name it `I want to buy a mug`.
5. Add the positive learning intents below by clicking on the 'edit' button.
* `Do you have branded mugs for sale?`
* `Can I buy a mug please?`
* `Do you sell mugs?`
* `Can I purchase a mug?`
* `Purchase coffee mug`
* `I want to buy a mug`
* `Do you have coffee mugs for sale?`
* `I would like to purchase a coffee mug`
* `I want to buy your coffee mug`
* `Do you sell longberry barista mugs?`
* `I want to have a longberry barista branded mug`
* `I want to buy a mug!`
6.  Now we need to add a Match. Click on the Plus icon below the Intent trigger, followed up with 'Match' and 'Generate'. This will automatically generate the best Match requirement based on the User Intents.

![1-buy coffee mug](//videos.ctfassets.net/2vbtnveccz5s/2OncR9XQIzJqepuVGpunR7/39035cceade9df3c442cc4c344d8abd0/1-buy_coffee_mug.mp4)

## Add answer texts to the output

Now we will populate the output node with answer texts. In this case, the output node will be used to give the user information about the Longberry Barista coffee mug and then ask a question, rather than just give a definitive answer.

1. Navigate to the output and enter a name like `Ask the user if they want to reserve a mug for in-store purchase`.
2. Add the following answers to the output node (each line represents an output):
*   `The official Longberry Baristas coffee mug is only available for purchase in our store. Would you like me to reserve a mug for you?`
*   `Right now you can only buy our coffee mug physically in our store. Do you want me to reserve one for you?`
*   `Our coffee mug is only available for purchase in our store. Shall I reserve one for you?`

![2-populate output](//videos.ctfassets.net/2vbtnveccz5s/3nZTwJnmgIdP7KyLiyucSq/f61ed58052acf9086312f9aadf136dcb/2-populate_output.mp4)

Output nodes can contain multiple answer variations to make the conversation more dynamic. Teneo allows you to either randomly choose an answer and return it to the user, or to set order for the outputs to be returned.   

```infobox
## A brief explanation of transitions

Before we start extending our flow with transitions, it might be a good idea to quickly go over the concept of transitions. Transitions link different flow nodes together and determine the paths a dialogue can follow within a flow.

By default, all transactions will create transitions that contain a User Intent. These transactions require the addition of one or more Matches. Transitions that have a User Intent but no assigned Match requirements will get a yellow 'TODO' label as a reminder.

![user intent in transition](//images.ctfassets.net/2vbtnveccz5s/1V5ntz6J3gWqwwAvOku84O/057b16549f7a8dca30ea4a9dbc88ff56/user_intent_in_transition.png)

When the User Intent is enabled, the most recent user input must match the set Match to continue down the transition. You can remove the User Intent option for a transition. This means that the transition will allow any user input to continue down the transition as it has no Match requirements. Transitions are also ordered, which tells Teneo in which order to test the Match on conditional transitions.

Transitions add a step for the user to give a response by default. This is represented by a separate node in the flow graph. This means that the flow processing will stop and wait for the user to provide new input at this step.

![give response transition](//images.ctfassets.net/2vbtnveccz5s/6HITaQekff62tvaTh89v2Z/59807be2ccf78863c5df0e27c10ca711/give_response_transition.png)

If the user input fits the transition's Match requirement, the flow processing will resume along with the transition. If the transition is not set to wait for user input before continuing, the flow processing will not stop and wait for new user input. If this is the case, the most recent user input will be tested against the Match requirement.

```

## Add two transitions

We have now reached the point in the flow where we expect the user is going to say either 'yes' or 'no'. Depending on what is said, the bot should react differently. Let us start with adding these transition.

1. Located under the output node 'Ask the user if they want to reserve a mug for in-store purchase', click on the Plus icon, followed up with 'Fork To' and 'Multiple complete transactions'.
You will now have the option to select the number of times the output should be forked.
2. Enter '2' and click on confirm.
Notice that two new paths are shown for the user to take. These will now be edited to cover the 'yes' and 'no' options.

![3-add transitions](//videos.ctfassets.net/2vbtnveccz5s/5hwFfTG02Ipu0NnInAbUvG/e4aec7944acd5659352d1f55c2944c71/3-add_transitions.mp4)

So far, you have created two flows in your solution, each containing one trigger with a Class Match. But in the next section, you will get to add a Language Object-based Match to a transition.

### Add a Language Object Match

Now we need to make sure that one of the paths only matches (the line that connects two output nodes) when the user says ‘yes’. To achieve this, we need to add a new type of Match requirement, namely a [language condition](/studio/language-understanding/concepts/language-conditions). Simply put, language conditions check if a user input matches a certain pattern. They can be generated from a set of examples or you can specify them directly. Let's generate one from a set of example inputs.

1. Navigate to the the transition located to the left.
2. Give the transition the name `User says 'Yes'`. This increases the readability of the flow and makes debugging easier.
3. Paste the following Intent examples:
* `Yes`
* `Indeed`
* `Yep`
4. Finally, click on the Plus icon, followed up with 'Match' and 'Generate', this will automatically generate the best Match requirement based on the example specification.

After a few seconds, the match requirement field will get the value `(%YES.PHR)`. This is the 'Match' for 'Language Objects' that was generated. The language condition uses a 'language object' called YES.PHR, which recognizes various phrases (hence the suffix .PHR) that mean 'yes', like 'by all means', 'absolutely' and 'yup'. This perfectly covers our need for this transition. Note that there is a lot more you can do with language conditions, but that will be covered later.

The condition used as a Match in this example is based on the User Intents, and unlike class, there is no ‘condition manager’. This means that all conditions are managed on the node or transition itself.

![4-yes path](//videos.ctfassets.net/2vbtnveccz5s/01vZF7MMvMNC10go6YA0VO/0f583634c7f32c27eb0c2f664ac28b11/4-yes_path.mp4)

So far, we have only added one Match per trigger and transition. We have only explored two different types of Matches, Class, and Language Objects. However, triggers and transitions can contain one or more match requirements. It is also possible to mix the Match requirement types depending on what the use-case requires, this is however not going to be covered on this page. You can read more about it [here](/studio/flows/concepts/triggers#match-requirements).

### Add an answer text

The last step to complete the 'yes' branch is to specify how your bot should respond when the user says 'yes'. The output node below the 'User says Yes' should be selected: 

1. Give the output a descriptive name like: `I have reserved a coffee mug for you`.
2. Finally, add the answer text: `I have reserved a Longberry barista coffee mug for you.`

![5-add output](//videos.ctfassets.net/2vbtnveccz5s/5Ulewn2n8oZctCUMk8YIob/024200b87487e6b9fd0f384bf2822d31/5-add_output.mp4)

## Create the path for the user saying 'no'

Now, we will specify what should happen when the user says 'no'. We'll follow the same steps as when adding the first branch:

1.  Navigate to the transition located to the right.
2.  Give the transition the name `User says 'No'`.
3.  Paste the following Intent examples:
* `No`
* `Never`
* `Nope`
4.  Finally, click on the Plus icon, followed up with 'Match' and 'Generate', this will automatically generate the best Match requirement based on the example specification.

![6-no path](//videos.ctfassets.net/2vbtnveccz5s/5yIlV7mcGDSMKHiWtIjRKM/64b0ec36bf5ecfb66b65c67913793a0b/6-no_path.mp4)

### Add an answer text for 'no'

Almost there! Now we need to make sure that the reply is recognized and taken care by the flow.

1. Navigate to the Output node below the transition.
2. Give it the name: `Ok, I will not reserve a coffee mug for you.`
3. We can reuse the name of the output node as our answer text.
4. Finally, save your flow by clicking 'Save'.  

![7-output for no path](//videos.ctfassets.net/2vbtnveccz5s/4nuH3KfwNJR2lm90gFpx47/02affca55532f95b3d70d9b0056f41e3/7-output_for_no_path.mp4)

## Try it out!

That's it! If you would like to test the flow from within Studio, minimize or close the flow, if the 'Tryout' window is not open, you can reopen it panel in the 'Solutions' window and have a go.  

![8-tryout](//videos.ctfassets.net/2vbtnveccz5s/57RY7uhSHPWkwW3unNBbQ3/3b89112a3cb64fd6fe19f90e7bcf1fb9/8-tryout.mp4)

## Summary

You've just created your first interactive flow and used the following components:

*   **Match**, which are used to set criteria that the user's input must match.
*   **Multiple answer variation**, used to make the bot's responses more dynamic.
*   **Language condition**, which you can use to ensure that the user input matches a certain pattern.
*   **Transitions**, which determine the path your dialogue should take.

## Test yourself

Try to add one more branch, but this time for if the user answers with an answer that does not meet the match requirements of the __Yes__ or __No__ transitions. Make sure to test your flow in Try Out!


Studio Web - Transitions

Transitions

Teneo offers a wide range of Match requirements to add to your trigger. One of them is the Machine Learning-based Class. We know from the previous page, [Your First Flow](/getting-started/your-first-flow#populate-the-trigger), how to generate a Class while working on a flow. This chapter will be about maintaining these classes.

Located in the Solution Dashboard is the 'Classes' tile. Clicking it will open the Class Manager, which looks like this:

![class manager](//images.ctfassets.net/2vbtnveccz5s/35yJv3kaEG3Gs5p5OfIGNg/8efd1a87eb118bc03a86b63922270b56/class_manager.png)

Here you can see a list of the classes inside the solution. The filter can be used to quickly locate specific classes. Selecting one will let the user see and edit the training examples used in that class.

!!! It's important to acknowledge that the training data is inside the Class Manager; changing it will fully affect the flow using the class.

## Add a training example

If we select the 'TELL_ME_ABOUT_YOUR_COFFEE' class, we can see that the solution doesn't have training data for the coffee type 'Cortado', even though it is a popular coffee type.  

If we want to add this coffee type inside the Class we'll need to do the following.

1.  Open the 'Class Manager' and select 'TELL_ME_ABOUT_YOUR_COFFEE' class.
2.  Click on 'Add Training Example' and add `Do you serve Cortado?`.
3.  Hit 'Save'.

Now you'll see the before and after we added training data for the coffee type 'Cortado'.  

![1-add training example](//videos.ctfassets.net/2vbtnveccz5s/6coy1umh7zc0DqmLaxmrg2/f18c75751c9a7ef385684cab7857d6a5/1-add_training_example.mp4)

!!! When you go back to the Tryout window you'll see a small text saying, 'Model training in progress', this indicates that the changes you've made are saved and the platform is currently re-training the classes in the machine learning model. This will change to 'Model update completed' when it's done.

## Add a test example
It is important to note that training examples can only be added from the Class Manager page once the Class has been created. It is not possible to add training examples from the flow editor page. This will only add 'Test Data' that will be used when [testing your bot](/article/build/test-your-bot/run-automated-tests) and not 'Training Data'.

![test data in a flow trigger](//images.ctfassets.net/2vbtnveccz5s/13zSLmJ8vO7HuxKHwag5gE/db21667ddede6ceaffec84962c80c495/test_data_in_a_flow_trigger.png)

Test data can also be viewed and added in the Class Manager itself. Let's try that now.

1.  Open the 'Class Manager' and select 'TELL_ME_ABOUT_YOUR_COFFEE' class.
2.  Click on 'Add Test Example'.
3.  Add the test data `Do you serve espresso?` and hit Enter.
4.  Hit 'Save'.

![2-add testing example](//videos.ctfassets.net/2vbtnveccz5s/6NSmSm2xYZoB9QECtRuLIq/45c9ca562ca946b2b42404fc4722a96d/2-add_testing_example.mp4)

## Generate examples
Teneo's copilot features allow you to quickly generate new training and test examples with the help of Generative AI. These can be generated based on existing examples or based on the class description.

!!! In order to enable copilot features, make sure to first [define settings to use Generative AI](/documentation/latest/home/teneo-7.4/teneo-studio#teneo-studio_generative-ai_studio-account-page).

### Training examples
Let's generate some training examples based on existing examples.
1. Open the Class Manager and select the 'TELL_ME_ABOUT_YOUR_COFFEE' class.
2. Click on 'Generate Training Examples'.
4. Select whether you want to generate examples based on existing examples or based on the description, and how many examples you'd like to generate.
5. Click on 'Confirm'.

The new examples should appear with a yellow highlighting line to distinguish them from previously existing examples.

![generate training examples](//videos.ctfassets.net/2vbtnveccz5s/4G2Fv0OHWIeGkZp7eCd0iJ/8e40992270021d1626278e79b828c02c/generate_training_examples.mp4)

### Test examples
Just like training examples, test examples can be generated either based on existing examples or a description. Let's try the latter approach this time.

1. While still in Edit mode, switch to the Test examples tab.
2. Click on 'Generate Test Examples' and select the option to generate based on a description.
3. Enter a description, such as `The user asks questions about which types of coffee you serve`.
4. Click on 'Confirm'.

Just as before, the newly generated examples are marked with a yellow highlighting.

![generate test examples](//videos.ctfassets.net/2vbtnveccz5s/7ox4uZbl2qlHsIoJPP1qaV/e24cc1cd6a5bea346951f03666c8630b/generate_test_examples.mp4)

Studio Web: Class Manager

Class Manager

Teneo comes with a collection of pre-built [Entities](/studio/flows/concepts/entities/) that you may use in your flows. However, sometimes we need to create custom entities for our bot. This is the case for the different kinds of coffee types that are served at Longberry Baristas. In the following section, we will walk you through the creation of this custom entity.

## Create a 'Language Objects' folder

Before we create our entities, it might be a good idea to create a folder that we can use to store them. This is not required, but as a solution grows, folders help to structure your Teneo assets. To create the folder, proceed as follows:

1. In the folder view, click on the Plus icon to create a new document.
2. Several other icons will appear. Click on the folder icon.
3. Give your folder a name, such as `Language Objects`, and click on 'Create'.

![1-LO folder](//videos.ctfassets.net/2vbtnveccz5s/2YiPnDkjwTcJLSszuBdWqj/09af01c9eda87d2bbd2af2a62be91960/1-LO_folder.mp4)

## Create a 'Coffees served' entity

Let's create the entity for recognizing the different kinds of coffees that are served at Longberry baristas. In Teneo, an entity can either contain words, phrases or [language objects](/studio/language-understanding/concepts/language-objects). Generally speaking, language objects are usually lists of synonyms or thematically related words, which are used to recognize the wide variety of user inputs. This means that language objects ensure a broader coverage, including the plural forms, declinations, and synonyms of the words compared to just using words or phrases. In other words, we do not have to specify every form or synonym of a word to get great coverage. For example, the language object '%AMERICANO.NN.LEX' will not only recognize "Americano", but also the plural form "Americanos". 

The entity that we are creating in this section will contain both language objects and words like brewed coffee (singular) and brewed coffees (plural). Since no language object covers the different forms of ‘brewed coffee’ we have to specify them ourselves in the entity. It would be a good idea to create a language object that covers both singular and plural forms of ‘brewed coffee’, and then use that language object as an entry in the entity instead. However, we will skip this step for now... 

This is how we will go about it:

1. Open the newly created 'Language Objects' folder.
2. Click on the Plus icon, followed by Entity icon (when you hover over it, you should see the text 'Create new Entity'.
3. Call the entity `COFFEES_SERVED` (the type .ENTITY is automatically defined).
4. Click on 'Create'. The newly created Entity should open automatically.
5. Inside the Entity, click on 'Add string  variable'.
6. Name the string variable `coffeeType`.
7. Next, select the option to __Add entry__.
8. Add the following entries into the Entity window:
    |  Coffee name  |  coffeeType  |
    |  :-----          |  :-----          | 
    |  `%AMERICANO.NN.LEX`|  `americano` | 
    |  `%CAPPUCCINO.NN.LEX`|  `cappuccino` | 
    |  `%CORTADO.NN.LEX`|  `cortado` | 
    |  `%ESPRESSO.NN.LEX`|  `espresso` |  
    |  `%FRAPPUCCINO.NN.LEX`|  `frappuccino` |  
    |  `%LATTE.NN.LEX`|  `latte` |  
    |  `%LUNGO.NN.LEX`|  `lungo` | 
    |  `%MACCHIATO.NN.LEX`|  `macchiato` |  
    |  `%RISTRETTO.NN.LEX`|  `ristretto` | 
    |  `flat white`|  `flat white` |  
    |  `flat whites` |  `flat white` |  
    |  `brewed coffee`|  `brewed coffee` |  
    |  `brewed coffees`|  `brewed coffee` |      
    |  `filtered coffee`|  `brewed coffee` |  
    |  `filtered coffees`|  `brewed coffee` | 

    !!! Note that filter coffee and brewed coffee are considered synonyms and both should return the type 'brewed coffee'.  

8. Hit 'Save'.

As you can see the entity structure is similar to a spreadsheet as it contains columns and rows. The left column contains entry values like language objects and words. In the right column, we have the variable 'coffeeType' which contains the string value of the entry on the corresponding row. For example, if we recognize "Americano", the variable 'coffeeType' would get the value "americano". You will learn more about how to extract data from user input on the next page. 

!!! The language objects used in the entity above are of the type [lexical entries](/studio/language-understanding/concepts/language-objects#names-and-types-of-language-objects), which are the smallest building blocks from which more complex language objects can be built. All language objects have a suffix that denotes which type it is. On this page, we have worked with lexical entries which have the suffix ‘.LEX’. Language objects of the type lexical entries usually contain different inflections, regional variations, and spelling of a word.

![2-coffees served entity](//videos.ctfassets.net/2vbtnveccz5s/39MRKzYz7SOHMAJoBGITEs/8be85d1165adfea01dbdd9f4a4070f51/2-coffees_served_entity.mp4)

## Generate Entity entries
Teneo's copilot features allow you to quickly generate more entries for entities. Let's try that now to expand the entity.

!!! In order to enable copilot features, make sure to first [define settings to use Generative AI](/documentation/latest/home/teneo-7.4/teneo-studio#teneo-studio_generative-ai_studio-account-page).

1. Click on 'Generate Entry'.

As we already have existing entries, let's generate more based on those. If you prefer, you could also generate entries based on a description which you would need to enter at this step.

2. Select the number of entries you wish to generate and click on 'Generate'.

![generate entity entries](//videos.ctfassets.net/2vbtnveccz5s/5ZVl5grcKV4PAS2u5mRJNo/bf6968d5f0b9bee723a56d7c414590fc/generate_entity_entries.mp4)

Make sure to evaluate the generated entries. If generating Language Objects, you may need to create the referenced Language Object for the entity entry to be valid. For example, let's add one for the invalid Language Object reference to `AFFOGATO.NN.LEX`:

1. Navigate to Language Objects and add a new Language Object.
2. Give it the name `AFFOGATO.NN.LEX`.
3. Add the TLML Syntax `affogato`.
4. Hit 'Save'.

Repeat the process for other invalid LO references, `COFFEES_SERVED.ENTITY` and populate the string variable column 'coffeeType'. Your entity should now look something like this:

![finished entity](//images.ctfassets.net/2vbtnveccz5s/45L21hhw59cY43Gl82m9Fs/5304094853c2fb9711bebadec42421c2/finished_entity.png)

## Summary

Great job! You have just created your first custom entity and worked with these components:

* **Folder**: Helps you keep your solution organized,
* **Entity**: A way of structuring data and mapping entry values to variables that can be used for data extraction,
* **Language objects**: Used to get broader coverage for plural forms, declinations, and synonyms of words so the bot can recognize a wide variety of user input.

```infobox
## Test yourself
We have now successfully added an entity that stores coffee types. Next, have a go at adding another entity by yourself. This time, make a new entity to hold the following coffee sizes:

|  Coffee size  |  coffeeSize  |
|  :-----          |  :-----          |
| small |  small |
| medium |  medium |
| regular | medium |
| large |  large |
| big |  large |
| supersize |  large |
| venti | large |

```

Studio Web - Introduction to Entities

Entities

Sometimes it's not enough to recognize which flow to trigger. Your bot may also need to extract some piece of information from the input to respond appropriately.  

A typical use case is picking up the user's order and repeating it, like in this example:

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: A cappuccino, please.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

In the following, we will show you how to create a flow that enables users to have this kind of conversation with your bot. This approach will make use of the entity we [created earlier](article/getting-started/create-custom-entities). These are the steps involved:

*   Add a new flow.
*   Set up a flow variable.
*   Add another output node.
*   Configure a data action to extract information.
*   Use the information in the output.

![final flow layout](//images.ctfassets.net/2vbtnveccz5s/D9GDASjtqH4eZcJMVmpNX/5eef38ee86b83e31faa6ac3cf248caac/final_flow_layout.png)

## Create a new flow

We will begin by creating a new flow. Just as previous flows we have built, it will have a trigger and an output node.

1. While inside the Flows folder, click on the 'Create' button followed by 'Create new flow'.
2. Give the flow the name `User wants to order a coffee`.

We now need to create a flow variable. The flow variable will later hold the coffee type that the user has mentioned.

3. Add a new variable below the flow descriptions and give it the name `orderedCoffeeType`.
4. Put `""` in the 'Variable value' field. This initializes the variable with the empty string.
5. Finally, click on 'Create' to create your flow.

![1-create order a coffee flow](//videos.ctfassets.net/2vbtnveccz5s/2Gif7mSIXyGzqZauRsjHph/a5ca6c3e3889abae49e9d949d4bc53c8/1-create_order_a_coffee_flow.mp4)

Let's proceed by further developing our flow.

### Populate the trigger

1.  Name the trigger `Order a Coffee`.

Now it is time to populate the trigger:  

2. Paste the following learning examples into the User Intent fields:
* `A small filter coffee, please`
* `Can I get a coffee?`
* `Can I have a coffee, please?`
* `Can I order a coffee`
* `Can I order an espresso?`
* `Can you get me a coffee`
* `Could I get a large macchiato?`
* `Could I have a flat white`
* `Could I order a large americano`
* `Give me a Frappuccino, please`
* `I want a small cappuccino!`
* `I want espresso`
* `I want to order a coffee`
* `I would like a coffee`
* `I would like to order a coffee`
* `I'd like a large espresso`
* `I'd like to order an americano`
* `May I have a filter coffee?`
3.  It is now time to generate a Match Requirement. Click on the Plus icon under the trigger, followed by 'Match' and 'Generate a draft'. This will automatically generate a Match Requirement for the trigger.
5.  Your trigger is now configured.

![2-populate trigger](//videos.ctfassets.net/2vbtnveccz5s/2hAPcB5KbhW3S5eP4SM2an/5bea75c495713df2daf8e7d689b082c2/2-populate_trigger.mp4)

### Populate the output node

In the output node, we want to prompt the user to indicate the desired coffee type in more detail:

1.  Name the output node `Ask for coffee type`.
2.  Click on 'Edit' and paste the following: `Ok, what coffee would you like?`.

![3-add output](//videos.ctfassets.net/2vbtnveccz5s/Gk4OxPvEnvAZLacKzwoHY/f0a935573536353193af42a701ed6543/3-add_output.mp4)

## Extract information from the user input

So far so good. You now have a flow that triggers when users want to order a coffee and answers with a question about the coffee type. To be able to pick up the coffee type from the user input, we now need to proceed with the following:

*   Using After Match, extract the coffee type mentioned by the user. 
*   Add an additional output node that will summarize the order including the coffee type.

### Configure the transition

The transition after the output node should only be traversed if the user mentions a coffee type. To ensure that, we need to:

1.  Click on the Plus icon after the output node.
2.  Select 'Continue with', followed by 'Transaction'. This will create an additional output node.
3.  Select the Plus icon under the user intent.
4.  Click on 'Match', followed by 'Entity'.
5.  Select `COFFEES_SERVED` in the Entity field. This means that Teneo will only continue when the user mentions something which matches the entity.

![4-configure transition](//videos.ctfassets.net/2vbtnveccz5s/4I4ztKJM2Dv9oKj8C416fR/fb129d99efb73930f2a6f3a537c5d70d/4-configure_transition.mp4)

### Extract information from the entity

Finally, we will store the coffee type that the user has mentioned in the flow variable `orderedCoffeeType`, and we will do so using a data action:

1.  Click on the Plus icon under the Match we just created.
2.  Select 'After Match', followed by 'Entity'.
3.  Enter `COFFEES_SERVED` in the text field.
4.  Click the 'Add Variable Mapping' button. This will allow you to extract a value from the Entity to be stored in a variable.
5.  The 'Source' (left) field denotes the value of the NLU variable of the entity 'COFFEES_SERVED' that we want to store. In our case `coffeeType`.
6.  The 'Target' (right) field denotes the name of the variable where the extracted value is to be stored. In our case `orderedCoffeeType`.

![5-extract info](//videos.ctfassets.net/2vbtnveccz5s/72bzsSMHFCEnL0qopRf1nn/bc20d2b411d6ece1cf79a5b25f2bf662/5-extract_info.mp4)

### Summarize the order

Now it's time to edit the last output node which will hold the summary of the user's order. This output will name the coffee type mentioned by the user, which we have stored in the variable `orderedCoffeeType`.

1.  Navigate to the last output node.
2.  Name this output node `Summarize order`.
3.  Click on 'Edit' and paste in the following answer to summarize the order: `Ok, a ${orderedCoffeeType} will be ready for pickup in 5 minutes.`.
4.  Finally, save the flow.

![6-summarize order](//videos.ctfassets.net/2vbtnveccz5s/2nRQQc01QA1Dm4IkcZg9Ku/db020a54098340c4f28b3ed57b275efb/6-summarize_order.mp4)

## Test the scenarios

Now it's time to test the flow!

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: A cappuccino, please.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

![7-tryout](//videos.ctfassets.net/2vbtnveccz5s/4nOi5KQ9EQceIEQ8N38953/a969603a70b207769c06744ed67e60e7/7-tryout.mp4)

## Test yourself

If you have done the previous [test yourself](/getting-started/create-custom-entities#test-yourself) there should be a working entity for Coffee Sizes. Add that entity here and don't forget to try it in Tryout.

Studio Web - Extract Entities

Extract Entities

Sometimes the user tells you the answer to certain questions earlier than expected. To make conversations flow more naturally, we can tell the bot not to ask questions it has already received answers to. We will do this by adding a Match requirement stating we will only ask the relevant question if the bot has not already received the answer. Otherwise, an additional path will skip the question.

Before adding the additional path:

> **User**: I'd like to order a Cappuccino  
> **Bot**: Ok, what coffee would you like?  
> **User**: I already told you, a Cappuccino!  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

After adding the additional path:

> **User**: I'd like to order a Cappuccino.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

## Extract entities from the first input

Currently, the first stage of the 'User wants to order a coffee' flow does not extract the coffee type entity if mentioned in the first input. To do that, we need to add another After Match on entities but this time for the trigger:

1.  Open the 'User wants to order a coffee' flow.
2.  Under the first User Intent node, 'Order a Coffee', click on the Plus icon followed by 'After Match' and 'Entity'. We will use this to extract values from our previously created [entity](/getting-started/create-custom-entities#create-a-coffees-served-entity).
3. Select the entity `COFFEES_SERVED.ENTITY`.
4. Click on 'Add Variable Mapping' below the entity name.
5. Now use the drop-down menu below to determine the source __coffeeType__ and the target __orderedCoffeeType__. This transfers the value from the source and assigns it to the target.

![1-after match entity](//videos.ctfassets.net/2vbtnveccz5s/7env7jNkVObJrNPWzKXbMs/f36b6b9c853c771884d642723bbd0ff3/1-after_match_entity.mp4)

## Specify when output should be given

Now it's time to add a new path to avoid asking the user for the coffee type if the user has already mentioned it in their first input.

1. Click on the Plus icon above 'Ask for coffee type', followed by 'Continue with' and 'Junction'.
2. Click on the Plus icon above 'Ask for coffee type' again, this time selecting 'Match' and 'Flow variable'.
3. In the dropdown menu, select 'orderedCoffeeType'.
4. Into the evaluation script, paste `""`.

The existing path will now only be executed if the value of the 'orderedCoffeeType' variable is empty. Let's add the path we want the bot to take if the variable has already been assigned a value in the After Match where we pick up a coffee type from the user's first input.

5. Hover over the arrow beneath the junction that does not go to the existing path. You should see a small green dot.
6. Click and drag to create a new path from the junction to the 'Summarize order' node.
7. Hit 'Save'.

To summarize, what we have done here is to check whether the first user input contains a coffee type and, if it does, store that in the 'orderedCoffeeType' variable. After the junction, we then either ask the user what coffee type they want, if we haven't already extracted this, or we skip ahead to summarizing the order, if we have extracted it.

![2-add skip path](//videos.ctfassets.net/2vbtnveccz5s/19imasiTQWcqBsErPfhNbh/446ee7e852c66f443eab556d95bc4853/2-add_skip_path.mp4)

## Test the scenarios

Now it's time to test the flow!

> **User**: I'd like to order a coffee.  
> **Bot**: Ok, what coffee would you like?
> 
> **User**: A cappuccino, please.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

It is now possible to put all details into one single request:

> **User**: I'd like to order a cappuccino.  
> **Bot**: Ok, a cappuccino will be ready for pickup in 5 minutes.

Studio Web - Adapt to user input

Adapt to user input

Quite often users will ask a follow-up question to an answer your bot just gave, like so:

> **User:** I want to order a coffee   
> **Bot:** Ok, what coffee would you like?      
>
> **User:** Espresso     
> **Bot:** Ok, a espresso will be ready for pickup in 5 minutes.     
> 
> **User:** I'd like one more *(follow-up)*  
> **Bot:** Ok, what coffee would you like?
> 
> **User:** Flat white this time  
> **Bot:** Ok, a flat white will be ready for pickup in 5 minutes.

As you can see in the example dialogue above, follow-ups are quite often very generic inputs that can have different meanings depending on the context of the conversation. In the example above, the user wants to order another cup of coffee; however, in a different context, the user might have meant to place the same order again, for example.

There are different ways to manage dialog context in Teneo. We will now explain one way: dealing with inputs that can be considered direct follow-ups to the same flow. We are going to implement the example dialog above by adding a context-dependent trigger to the [coffee order flow](/getting-started/build-a-slot-filling-flow#create-a-basic-flow) flow that we created earlier.

What we will do is the following:

*   Add a second trigger to our flow.
*   Make the trigger context dependent using the Match for Context, Follow up of Flow.

The final result will look like this:

![final flow layout](//images.ctfassets.net/2vbtnveccz5s/O4RiKp5ekZjb3sZalKBoZ/d789e6cfd8ffd62cad83a0691d932688/final_flow_layout.png)

Let's get started!

## Add a second trigger to the flow

Go ahead and add a second trigger to handle the follow up questions:

1. Open the flow 'User wants to order a coffee'.
2. Add another Intent trigger using the Plus icon next to the existing Intent trigger at the top of the flow.
3. Give the trigger the name `Another one, please`.
4. Add Intent examples to the newly created trigger:  
* `Another one`
* `Can I order another one`
* `One more`
* `Can I make one more order`
* `Another order`
* `1 more`
5. Generate a Match by clicking on the Plus icon under the newly created trigger, followed first by Match and then Generate.

![1-add second trigger](//videos.ctfassets.net/2vbtnveccz5s/3bf6tk9BjuLTq29GaNBZOs/ee125d8654cf0c36ac2e668146d936a3/1-add_second_trigger.mp4)

## Make the trigger context dependent

We are going to context restrict the second trigger 'Another one please' so it only fires if the same flow has just been active. To achieve this we are going to use a global scripted context which uses a script to evaluate if a context is true.

1. In the Match node under the 'Another one' trigger, click on Add match requirement.
2. Select Global scripted context.
3. From the dropdown, choose the global context 'Follow up of Flow'.
4. Select the value __sameFlow__ from the dropdown menu.
5. Lastly, save the flow.

![2-context dependent](//videos.ctfassets.net/2vbtnveccz5s/3YEpcqna1YMtrZPsUqP7YI/d8089c8d6e77bf7f32ad9684adcf0940/2-context_dependent.mp4)

!!! The global scripted context 'Follow up of Flow' only evaluates to true if the context restricted trigger exists in the same flow as the previously fired flow. For more details, see: [Predefined context restrictions](/studio/conversations/concepts/context#predefined-context-restrictions).

## Test your flow
That's it! Now you can save the flow and give it a try in the Tryout window.

First try a working case:

> **User:** I want to order a coffee      
> **Bot:** Ok, what coffee would you like?         
>
> **User:** Espresso       
> **Bot:** Ok, a espresso will be ready for pickup in 5 minutes.      
> 
> **User:** I'd like one more *(follow-up)*       
> **Bot:** Ok, what coffee would you like?         
> 
> **User:** Flat white this time        
> **Bot:** Ok, a flat white will be ready for pickup in 5 minutes.      

Then try the following input that you would normally use as follow-up, but this time without any preceding question:

> **User:** I'd like one more.  
> **Bot:** I'm sorry but I didn't get that.

Getting started

Log in to Teneo Studio

Create a solution

Hello World!

Summary

Next page