## Objectives

As part of the expansion of Conversational AI project you may want to make your application available in multiple languages. In this section you will learn about the native Teneo feature for multi-language implementations, the Localization feature. 

At the end of this section you will:

- Know how to make your application available in multiple languages
- Understand how you select what should be included in a Local branch
- Know how to prepare and create a Local solution branch
- Understand what needs to be localized and how updates are communicated to the Local branches
- Create your own Local branch

Objectives - Make your Bot Available in Multiple Languages - Advanced  - Learning Journey

Objectives

Once we have built a successful bot and rolled it out for one market, we want to be able to expand that bot. Aside from expanding it in terms of functionality and use cases, we may also want to introduce it into different languages and markets. However, simply translating training data and bot answers into a different language would be an inefficient approach, and is often not enough; a different market tends to mean various cultural differences that dictate which use cases should be included in the bot, and in some cases, the backend systems our bot interacts with will differ between regions and markets as well. Languages, markets, and other project specificities all determine how our bot should look and act, and achieving this to the highest standard requires a more fine-tuned approach.

![Build - Localization: 1-icons](//images.ctfassets.net/2vbtnveccz5s/6blz18xwRwLWjguHdJW3so/51dbca001f3cfd4383e1dfc465d8de76/1-icons.png?classes=w50)

In Teneo, the approach taken to localize projects uses the concept of branching.

## Localization using branching in Teneo
Branching allows us to efficiently localize our solution. By first designing and developing our main master solution for one specific language and market, and then branching from there, we can easily reuse whichever parts we want in our new local solutions. In this way, our local solutions are created with all of the parts of the master solution that we want to include, and we're free to create and add all the other content that might be necessary to support the local language and market.

In Teneo we call these solutions 'Master' and 'Local', where the Master solution is the main solution every Local solution is created from. The full list of terminology can be found in our [documentation](https://documentation.artificial-solutions.com/latest/#/knowledge-base/solution/localization-setup?id=terminology).

We recommend for one common language to be chosen when creating the main Master solution. In large companies where the common language is English, this may mean that the best approach is using a solution in English even if the bot was developed in a different language. This is because the local solution owners must be comfortable with the content inside the Master solution to be able to create accurate Local solutions.

!!! A detailed explanation of these steps can be found [here](https://documentation.artificial-solutions.com/latest/#/user-guide/solution/localization-setup).

The button used for branching a solution can be found in the solution overview and looks like this:

![Build - Localization: branching solution view](//images.ctfassets.net/2vbtnveccz5s/3622W7dPUGGd2OOUAjGJwh/1240d96a17a3735ca471115ff1ee4349/branching_solution_view.png?classes=w50)

The buttons used for establishing the content of your local branch inside your solution can be found in the 'Branching' section in the top bar and look like this:

![branching in ribbon bar](//images.ctfassets.net/2vbtnveccz5s/32Hr6TIimDMDlHVUSJaIVf/1ab67584a50dfec5dc38512a5c003631/branching_in_ribbon_bar.png)

## High-level process

Part of the general process for localizing a bot is to get an overview of the use cases. Knowing the content will help us to better plan, as the localization depends on the specific language, market, and content.

The first step is to decide on what parts of the content to localize in the Master bot and enable these for branching.

### What to Localize
We recommend for the developer to have a deep understanding of how the Master bot works before adding everything to the Local solution. Consider the following recommendations when choosing what content is relevant:

*   Cultural aspect - for countries that use similar language but have different cultures, it is important not to create these flows inside the Master solution. These should instead be manually added to the Local solution.
*   Lingual aspect - Paths inside flows might differ depending on the language of the solution. The solution owner should think of vague use cases that work for specific languages and create these in the Local solutions.
*   Market-specific cases - one thing that is relevant for a certain market might not be relevant across all markets. For example, there may be a promotion going on in Europe that might not be relevant to the Asian side of the business.

Once you have finished choosing the relevant content, you can branch from the Master solution to create your new Local solution. The next step is to then go through the solution flow by flow and localize the content of the flows.

The first step is usually to go through the flow trigger and match requirements and starting by translating the example inputs which should trigger the flow.  
Understanding and translating the example inputs will give a good idea of the scope of the flow and transitions inside the flow and let you decide on the most suitable match requirements.

### Class Match 
For Class Match you will, in most cases, just need to localize the training data. This can be done through the [Class Manager](/getting-started/class-manager).

![class match](//images.ctfassets.net/2vbtnveccz5s/6LcJYIjE9wkBSExA0CJox6/e1732b512825717a98265ed5d44994a8/class_match.png?classes=w50)

!!! However, please note that in certain cases some flows may need to make use of Teneo Linguistic Modelling Language based match requirements as well to get the precision needed in the specific language.

### Entity Match 
For Entity Match you will need to localize the content inside the selected [Entity](/article/build/flows/concepts/entities). This can be done in one of the following ways:

*   Editing the current Entity by
    *   Opening the Entity from the flow - This can be done by selecting the relevant node and holding __Ctrl__ while clicking once on the Entity. This will open the Entity in a different window.
    *   Locating the Entity from the solution window - This can done by locating the relevant Entity among the Language Objects created inside the solution and opening it in 'Edit' mode.

Once you have opened the Entity, make sure to localize both the Entry and the String variable.

![Build - Localization: 4-entities](//images.ctfassets.net/2vbtnveccz5s/4klbeP7r3E4MCJQxj8HVPX/fa6dd30efa6651c6057e5257e4bfe3a3/4-entities.png?classes=w30)

!!! Note that Script variables do not need to be localized as they are usually written as a [Script](/article/build#scripting).

*   Creating your own Entity with the relevant use-case in your own way. A guide on how to create your own Entities can be found [here](/getting-started/create-custom-entities#create-a-coffees-served-entity).

![entity match](//images.ctfassets.net/2vbtnveccz5s/4Al0V5SNBuygUdeeDt1uR/6649366210c0571214808dda0a22c916/entity_match.png?classes=w50)

### Language Object Match
For Language Object Match you will need to localize the content inside the selected [Language Object](/studio/language-understanding/concepts/language-objects). This can be done in one of the following ways:

*   Editing the current Language Object by
    *   Opening the Language Object from the flow - This can be done by selecting the relevant node and holding __Ctrl__ while clicking once on the Language Object. This will open the Language Object in a different window.
    *   Locating the Language Object from the solution window - This can done by locating the relevant Language Object among the Language Objects created inside the solution and opening it in 'Edit' mode.
*   Creating your own Language Object with the relevant use-case in your own way. A guide on how to create your own Language Objects can be found [here](/studio/language-understanding/how-to/create-your-own-language-objects).

![lo match](//images.ctfassets.net/2vbtnveccz5s/lRnETz5w9Fbxxe6PXOruW/1e1b6b3eebab1fdaf27ed4ccc7bb6d36/lo_match.png?classes=w50)

### TLML Syntax Match
For TLML Syntax-based Match requirements, you will need to construct Syntax Match Requirements.  
* This is easier if your language has [language resources](/studio/language-understanding/concepts/lexical-resources), as you can make use of the pre-built language objects to match a large number of expressions.  
* Normally we recommend that you create and use language objects to represent your domain-specific language, as these will help you scale your solution. These language objects are likely to be inherited from your [Master](https://documentation.artificial-solutions.com/latest/#/user-guide/solution/localization-setup?id=master-solution) solution.

![TLML match](//images.ctfassets.net/2vbtnveccz5s/2UGWAEVO3v83RtUjMXsuaR/aca63fa32a1276584e499a184da83bd0/TLML_match.png?classes=w50)

In the How to section, we will demonstrate [how to localize a bot](/studio/language-understanding/how-to/localize-a-bot).

## Localize with Conversational Language Understanding (CLU)
By integrating Conversational Language Understanding (CLU) with Teneo, you can benefit from the combined conversational power of both tools. One significant advantage of this approach is the ability to combine a Teneo bot with CLU multilingual capabilities in order to create a powerful multilingual bot based on a single CLU model.

![teneoxclu](//images.ctfassets.net/2vbtnveccz5s/38FpMOQf0ILhxQaVMpjjco/cadba5b9570ab295a8a01e7e327989ee/teneoxclu.png?classes=w30)

This is how a conversation in Spanish, English, Swedish, Turkish, and German with the final multilingual bot could look:

* Spanish - __Hola!__ (Hello)
* English - __My name is John__
* Swedish - __Minns du vad jag heter?__ (Do you remember my name?)
* Turkish - __İyi misin?__ (Are you well?)
* German - __Auf wiedersehen__ (Goodbye)

![tryout](//videos.ctfassets.net/2vbtnveccz5s/5CA2xLo8JnEA5hlgi9Ndjg/2092f7a2b0dfd521ade5a194d4a03d7b/tryout.mp4)

!!! You can see a practical example on how to Localize with multilingual CLU [here](/guide/localize-with-multilingual-clu).


Build - Localization

The Localization feature

Localizing a bot for different languages, markets, and/or cultures is a common use case. This is accomplished in Teneo through branching, where we have the option of creating a 'Master' version of a solution and its own 'Local' versions for each of the different languages we are interested in. In this way, Teneo allows us to create local solutions with all of the parts of the master solution that we want to include, making it an efficient way to create bots for different languages and markets. You can read more about localization [here](/studio/language-understanding/concepts/localization).

!!! A webinar on Localization can be found [here](https://www.brighttalk.com/webcast/17594/495696?utm_source=ArtificialSolutions&utm_medium=brighttalk&utm_campaign=495696).

In this guide, we will demonstrate how it is possible to localize the 'Longberry Baristas' solution, which is in English, to another language with resources, Swedish. More on branching can be found in the [Documentation](https://documentation.artificial-solutions.com/latest/#/home/teneo-6/teneo-studio?id=testable-working-master).

!!! Note that branching is also supported for languages without resources.

## Prepare your solution

We will start by preparing the solution we want to localize. In this case, it is the 'Longberry Baristas' solution that's included in the environment you can request access at [Teneo Developers](https://developers.artificial-solutions.com/signup/?utm_source=as-developers-guide&utm_medium=localize-solution-guide).

1.  Select the solution, 'Longberry Baristas'.
2.  Click on 'Open' above the Solutions field.

## Include relevant content for branching

It is time to include the relevant content from Longberry Baristas for branching.

### Flows

We will start off with two of the bots' key flows.

1.  Select the flows 'User wants to order a coffee' and 'User asks about coffees we offer'.
2.  Click on 'Include' in the 'Branching' section in the ribbon bar. The buttons in the 'Branching' section look like this:

![include content for branching](//images.ctfassets.net/2vbtnveccz5s/5OeSZw77gI9q59A7sMzXXx/b5807f68403fddc45144ea34c51855aa/include_content_for_branching.png)

A more detailed explanation of these steps can be found [here](https://documentation.artificial-solutions.com/latest/#/user-guide/solution/localization-setup).

!!! We selected these two flows as they offer the key functionality that we want to offer in Longberry Baristas. In a real use case we would also want to include a 'User wants to know if we have a store in city', as this is also an integral part of what a user would expect Longberry Baristas to be able to answer.

### Classes

These flows use Class Match, which also means that they depend on [Classes](/studio/flows/concepts/triggers#class). These are stored in the [Class Manager](/getting-started/class-manager).

1.  Open the 'Class Manager' by selecting the 'Class Manager' button located in the 'Solution' section.
2.  Select the classes 'ANOTHER_ONE_PLEASE', 'ORDER_A_COFFEE' and 'TELL_ME_ABOUT_YOUR_COFFEE'.
3.  Finally, click on the 'Include' button in the 'Branching' section.

### Entities

Entities are also used in these flows, and also need to be included for branching.

1.  Select the 'Language Objects' folder.
2.  Select 'COFFEES_SERVED.ENTITY'. Click the ‘Include’ button in the ‘Branching’ section.

### Variables

The 'User wants to order a coffee' flow also makes use of a [global variable](/studio/flows/concepts/variables#global-variable) that needs to be included for branching.

1. Click on the 'Solution' tab.
2. Click on 'Globals'.
3. Under 'Variables', select the variable 'coffeeTypeInFocus'.
4. Click on the 'Include' button.
5. Finally, click on the 'Save All' button located on the sidebar in the solution backstage. This will make sure everything you selected to be included for branching inside the solution will be stored and saved.

### Other solution content

At this point, we would also need to go over any other content we may need to include, such as [Integrations](/studio/scripting/concepts/integration-manager), [Contexts](/studio/conversations/concepts/context), [Global Scripts](/article/build/scripting/concepts/scripts#global-scripts) and [Listeners](/studio/conversations/concepts/listeners). However, for the two key flows we have selected in Longberry Baristas, no other content is used. Therefore, we can go ahead and start localizing!

### Forget something?

Don't worry! It is possible to update your 'Master' solution if you forgot to include something before branching. Simply go back to the 'Master' __Longberry Baristas__ solution, and include it. Then return to your 'Local' solution, go to the Solution backstage, and click on the 'My Work' section. We can now see the changes from the 'Master' solution, where we can either select __Update All items__ to update everything or __Update Selected items__ to only update relevant parts. Once updated, the local solution will pull in the changes from the Master solution.

## Localizing Longberry Baristas

Now that we have prepared our solution, let’s branch our English Longberry Baristas bot to a different language. This process is fairly similar regardless of language; we will be using Swedish for this example.

!!! While this guide is written with a Swedish translation, feel free to pick another language and translate as necessary for the following steps.

1.  While in the Solution window, select the 'Longberry Baristas' solution.
2.  Click on 'Branch' above the solutions field.
3.  Make sure the 'Solution Language' for this first bot is Swedish. This will be the mother tongue of your bot.
4.  Under 'Solution Content', click on 'Master and Template' and select the latest version of 'Teneo Dialogue Resources Swedish' from the list.  
5.  Fill in a name for your solution, for example `Longberry Baristas - Swedish (svenska)`.

!!! For languages without dialogue resources leave the __Master only__ selected under 'Solution Content'.

6.  Finally, click 'OK' and wait for the branching to complete.

![1-branch](//videos.ctfassets.net/2vbtnveccz5s/2x9XQJ2fji6WAlTaZEG1e5/03c814cbe0058424d65ccea5062b4a83/1-branch.mp4)

### Identify Warnings and steps to take

Warnings in Tryout appear as yellow warning triangles. To see more detailed warning messages, open the Try Out window and navigate to the Messages section. More information on warnings can be found [here](/article/optimize/refine-your-bot/troubleshooting/warnings-and-errors-in-tryout).

![t1 warnings in tryout](//images.ctfassets.net/2vbtnveccz5s/4UKBcQZHCtruFLJGXpvfu4/4bbdf0055a9c2a9ba87c32b800ecc91a/t1_warnings_in_tryout.png)

### User asks about coffees we offer

The most important aspect when localizing bots is for the final language to actually make sense for the target audience. Both in respect to the language that they actually use and the language that fits the market and culture. Flow triggers with Class-based match requirements are usually the easiest to localize. They usually use a limited number of Language Objects, where the only parts that need any localization are the training examples. To localize a Class-based match requirement trigger, do the following:

1.  Open the 'User asks about coffees we offer' in edit mode.
2.  Select the trigger and change its name to the local version of your selected language; for Swedish this is, `Vad har ni för utbud?`.
3.  Replace the Intent examples with these Swedish translations,
```example-inputs
Vad har ni för utbud?
Har ni bryggkaffe
Har ni cappuccino
Serverar ni macchiato
Vilka kaffesorter har ni tillgängliga?
Vilka typer av kaffe har ni
Vilken kaffesort serverar ni
Har ni latte?
Vilka olika kaffedrinkar har ni
Vad säljer ni?
Vad har Longberry Baristas för utbud?
Vad för kaffeutbud har ni?
```
4. Open the selected Class Match by holding __Ctrl__ and clicking once on the class name. This will open the 'Class Manager'.
5. Edit the same class and rename it `BESKRIV_KAFFEUTBUD`.
6. Replace the training examples from the translated examples above.
7. Replace the TLML Syntax in the Match section with `(%KAFFE.NN.LEX/%DRYCK.NN.LEX)`.
8. Press 'Save' and return to your flow.

Now that we are done with the class, next up we have the transition and the outputs to be localized.

1.  Select the transition 'Coffee type mentioned and served' and rename it to `Kaffedryck nämns och serveras`.
2.  Go down the same path and select the Output node, 'We serve coffee type!' and replace its name with `Vi serverar kaffedrycken!`. While at it, replace the output answer with `Ja, ${mentionedCoffee} finns med bland vårt utbud!`.
3.  Go ahead and select the other Output node and replace its name with `Vi erbjuder en mängd olika handgjorda kaffesorter...`.
4.  Replace the Answer with the Swedish translation, `Vi erbjuder en mängd olika handgjorda kaffesorter från espresso till macchiatos, flat whites och ännu fler.`.
5.  Hit 'Save'.

![2-user asks about coffees we offer](//videos.ctfassets.net/2vbtnveccz5s/6bZ5FUoIiYUu3mpOJrLsmU/225fbadc99185984322b1d949d5986f1/2-user_asks_about_coffees_we_offer.mp4)

Congratulations, you have now localized part of your solution! Let us move on to the next flow.

### User wants to order a coffee

Some flows will have multiple triggers with multiple match requirements. Localizing these is simply a matter of going trigger by trigger and match requirement by match requirement. Let us start by going through the triggers one by one.

#### Order a coffee trigger (Class and Entity)

1. Open the 'User asks about coffees we offer' in edit mode.
2. Let us start with the trigger 'Order a coffee'. Replace its name with `Jag vill beställa kaffe`.
3. Replace the Intent examples with
```example-inputs
En vanlig kaffe, tack!
Jag vill beställa kaffe!
Har ni Espresso?
Skulle jag kunna få en macchiato?
Jag vill ha en flat white.
En latte tack!
Jag vill ha en latte tack!
Har ni vanligt bryggkaffe?
En bryggkaffe
```
3.  Open the selected Class Match by holding __Ctrl__ and clicking once on the class name. This will open the 'Class Manager' in a new window.
4.  Edit the same class and rename it `BESTÄLL_KAFFE`.
5.  Replace the training examples with the translated examples above.
6.  Press 'Save' and return to your flow.

![3-order a coffee trigger](//videos.ctfassets.net/2vbtnveccz5s/Jzxr6HM0SAAKqyNQ9KtwR/ccc2ac35308195f08d73ff3e6e9c4020/3-order_a_coffee_trigger.mp4)

#### Another one please Trigger (Class)

1. Next, let's move on to the trigger 'Another one please'. Replace its name with `En till tack`.
2. Replace the Intent examples with
```example-inputs
1 till
En till
En till beställning
får jag beställa en till
Jag vill lägga en till beställning
Kan jag få en till kopp
```
3.  Open the selected Class Match by holding __Alt__ and pressing once on the class name. This will open the 'Class Manager'.
4.  Edit the same class and rename it `EN_TILL_TACK`.
5.  Replace the training examples from the translated examples above.
6.  Press 'Save' and return to your flow.

![4-another one please trigger](//videos.ctfassets.net/2vbtnveccz5s/1xxgRr4poJXUYPueQo7AME/c3e9a38683dc4d7fe005effcd9c2bfde/4-another_one_please_trigger.mp4)

#### Can I have one of those trigger (TLML Syntax and Context)

1. Finally, let's move on to the trigger 'Can I have one of those?'. Replace its name with `Kan jag få en sån?`.
2. Replace the Intent examples inside the trigger with the following:
```example-inputs
Kan jag få en sån?
Då tar jag en sån
Kan jag få en sån, tack!
```
In the same trigger, the Global Variable Context Match will continue to work, but the TLML Syntax Match will need some updating. As you’ve already translated the examples, you can let Teneo generate a condition for you as done [here](/article/build/flows/how-to/tlml-syntax-match#generate-a-condition).

3. Expand the Advanced Options under the syntax panel and click on ‘Draft’.

![5-can i have one of those trigger](//videos.ctfassets.net/2vbtnveccz5s/7nyuhNrEzgBVNBPJFAkSir/2aa20e76de5085f823a121f268460263/5-can_i_have_one_of_those_trigger.mp4)

#### Localize the transitions

Next in line is the localizing of the transitions with conditions found inside the flow.

__User responds with coffee type__

This transition has a condition for 'COFFEES_SERVED.ENTITY' which needs to be localized by doing the following,

1. Select the transition 'User responds with coffee type' and rename it to `Användaren svarar med kaffesort`.
2. Scroll down to the 'Match' section. Open the mentioned [Entity](/article/build/flows/concepts/entities) in edit mode by holding __Alt__ and clicking once on the 'COFFEES_SERVED.ENTITY'. This will open the entity in a new window.
3. Replace the current entity with the following:    
    |  Coffee name  |  coffeeType  |
    |  :-----          |  :-----          | 
    |  americano|  americano | 
    |  %CAPPUCCINO.NN.LEX|  cappuccino | 
    |  cortado|  cortado | 
    |  %ESPRESSO.NN.LEX|  espresso |  
    |  frappuccino|  frappuccino |  
    |  latte|  latte |  
    |  lungo|  lungo | 
    |  macchiato|  macchiato |  
    |  ristretto|  ristretto | 
    |  flat white|  flat white |  
    |  kokkaffe|  kokkaffe |  
    |  bryggkaffe|  bryggkaffe |  
    |  brygg kaffe|  bryggkaffe |      
    |  bryggd kaffe|  bryggkaffe |  
    |  bryggkaffen|  bryggkaffe |  

4. Save and return to your flow.

![6-user responds with coffee type](//videos.ctfassets.net/2vbtnveccz5s/7M5mcnqoCKMlF1l12P5Up2/7be26dff87b6e3899270e7d92aebecbd/6-user_responds_with_coffee_type.mp4)

__Get user name__

Lastly, we have the final transition, which includes 'PERSON.NER' as a Match.

1.  Select the transition called 'Get user name' and rename it to `Användaren svarar med namn`.
2.  Leave the condition as it is. For languages without language resources we suggest you replace 'PERSON.NER' with the Language Object created in the earlier steps [here](/studio/language-understanding/how-to/localize-a-bot#order-a-coffee-trigger-class-and-entity).

!!! If you have not created a [Language Object](/studio/language-understanding/concepts/language-objects), please follow these steps to [store the users input](/studio/language-understanding/how-to/store-what-the-user-said#catch-the-user-s-words).

![7-get user name](//videos.ctfassets.net/2vbtnveccz5s/2ob9xWICjJt7ZFlHoI5ZQ4/24a79d737275eb7a0edc928294b0e6a2/7-get_user_name.mp4)

#### Localize the outputs

Next up we need to localize the outputs found inside the flow.

__Ask for coffee type__

1.  Select the first output node called 'Ask for coffee type'. This will open the output configuration panel.
2.  Rename the output node to `Fråga om kaffesort`.
3.  Locate the 'Answers' field and replace the answer with `Ok, vilket kaffe vill du beställa?`.
4.  There is also a [Resume Prompt](/studio/flows/concepts/outputs#resume-prompts) that should be replaced with `Vi fortsätter med din beställning. Vilket kaffe vill du ha?`.

__Ask for name__

1.  Select the third output node called 'Ask for name'. This will open the output configuration panel.
2.  Rename the output node to `Fråga om namn`.
3.  Locate the 'Answers' field and replace the answer with `Ok, vilket namn ska jag skriva ner för beställningen?`.

__Summarize Order__

Last in line is the final output node where the user's order is summarized.

1.  Select the third output node called 'Summarize Order'. This will open the output configuration panel.
2.  Rename the output node `Sammanfatta order`.
3.  Locate the 'Answers' field and replace the answer with `Tack för din beställning, ${userNameForOrder}. En ${orderedCoffeeType} är redo att hämtas om fem minuter.`.
4.  Save your flow.

![8-localize outputs](//videos.ctfassets.net/2vbtnveccz5s/1icLEWoiWX7YEDpHrqiVEh/a8e80c43647e198030dd5c83b5e423f0/8-localize_outputs.mp4)

## Try it Out

You are now done with the key flows in your first localization of the whole solution. Let us test it in Tryout!

1.  Open the 'Tryout' window located in the 'Solution' section.
2.  Let us try the flows we just localized. In this case, you can test your flow by trying out the following examples:
*   `Vad för kaffeutbud har ni?`
*   `Jag vill ha en bryggkaffe`

## Test Yourself

Go ahead and include more flows to localize from the original 'Longberry Baristas'. Use your local solution language when following the steps above.

Make your Bot Available in Multiple Languages

Objectives

Next page