Hero - Build your bot

When Teneo matches a Teneo Linguistic Modeling Language (TLML) condition against user input it also keeps track of the words of the input that are involved in the match. These words are called __\_USED_WORDS__ in Teneo, and they can be referred to from listeners and from attached scripts.

## Used words in Listeners
[Listeners](/article/build/conversations/concepts/listeners) in Teneo consist of two parts: a TLML Syntax part and a Execution Script part. Every word that matches the expression of the Syntax condition part is stored in the special __\_USED\_WORDS__ variable from where they can be used for further processing. An example is given below.

![used words](//images.ctfassets.net/2vbtnveccz5s/4y16e0jkMgatKumNJVUZ4N/7f5e05abb38da6014c5537e0c7123842/used_words.png?classes=w60)

## Used words in Attached Scripts
When used in [attached scripts](/studio/language-understanding/concepts/attached-scripts), the __\_USED_WORDS__ variable contains the words that matched the part of the condition that the script has been attached to. An example is given below, where __\_USED_WORDS__ is used in a script attached to the language object __COFFEES_SERVED.NN.LIST__.

![Build - Used words: 1-used word script](//images.ctfassets.net/2vbtnveccz5s/4HhZtKTbBzp0PDfSeA7oke/74d4c5cb4b274ec0b3e01816871d5d99/1-used_word_script.png?classes=w60)

## Scripting API
Teneo features a scripting API method called __\_.getUsedWords()__ that allows access to different stages of the input processing. This means that you can access different versions of the user input, depending on the parameter you pass. You may access the user utterance as it was (__\_.ORIGINAL__), a simplified version of it (__\_.SIMPLIFIED__), or its final version after having passed the whole input processing pipeline (__\_.FINAL__).

Method | Value
----------------|------------------
\_.getUsedWords(_.ORIGINAL) | Returns the words spelled exactly as given in the input text, without any further word processing.
\_.getUsedWords(_.SIMPLIFIED) | Returns the simplified words of the input text.
\_.getUsedWords(_.FINAL) | Returns the words of the input text after all preprocessing steps (e.g. simplification, auto-correction, compound splitting, etc.)

In contrast to the __\_USED\_WORDS__ variable which stores the user input as one string, these methods return the user input as a list of strings. For example the sentence "I want to order a cappuccino" is returned as ["I", "want", "to", "order", "a", "cappuccino"]. If you want them to look good in your output you thus have to add a __.join(" ")__ at the end of the call which will join everything into one string separated with whitespaces: 
```groovy
_.getUsedWords(_.ORIGINAL).join(" ")
```

!!! Note that there is also an API method called __\_.getNotUsedWords()__ that maps the words that have not matched the condition. For this method, the same parameters can be used as for __\_.getUsedWords()__.

## Optionality and \_USED_WORDS
Teneo features two ways of expressing optional words in an input: the [optional match option (:O)](/studio/reference/condition-syntax#optional-match-option) (for example: __I >> (really):O >> like >> you__) and the [maybe operator (~)](/studio/reference/condition-syntax#limit-unused-words-and-maybe) (for example: __(how+are+you) ~(doing/feeling/dear)__). If the user input matches an optional part of a Syntax Condition, the words of this match are also included in __\_USED_WORDS__.


Build - Used words

When Teneo matches a Teneo Linguistic Modeling Language (TLML) condition against user input it also keeps track of the words of the input that are involved in the match. These words are called __\_USED_WORDS__ in Teneo, and they can be referred to from listeners and from attached scripts.

## Used words in Listeners
[Listeners](/article/build/conversations/concepts/listeners) in Teneo consist of two parts: a TLML Syntax part and a Execution Script part. Every word that matches the expression of the Syntax condition part is stored in the special __\_USED\_WORDS__ variable from where they can be used for further processing. An example is given below.

![1-used-words](//images.ctfassets.net/2vbtnveccz5s/1AcKHFoFV33gt5r75WYIxo/12d895dbfb9be72c68d7259476fb08f0/1-used-words.png?classes=w50)

## Used words in Attached Scripts
When used in [attached scripts](/studio/language-understanding/concepts/attached-scripts), the __\_USED_WORDS__ variable contains the words that matched the part of the condition that the script has been attached to. An example is given below, where __\_USED_WORDS__ is used in a script attached to the language object __COFFEES_SERVED.NN.LIST__.

![Build - Used words: 1-used word script](//images.ctfassets.net/2vbtnveccz5s/4HhZtKTbBzp0PDfSeA7oke/74d4c5cb4b274ec0b3e01816871d5d99/1-used_word_script.png?classes=w60)

## Scripting API
Teneo features a scripting API method called __\_.getUsedWords()__ that allows access to different stages of the input processing. This means that you can access different versions of the user input, depending on the parameter you pass. You may access the user utterance as it was (__\_.ORIGINAL__), a simplified version of it (__\_.SIMPLIFIED__), or its final version after having passed the whole input processing pipeline (__\_.FINAL__).

Method | Value
----------------|------------------
\_.getUsedWords(_.ORIGINAL) | Returns the words spelled exactly as given in the input text, without any further word processing.
\_.getUsedWords(_.SIMPLIFIED) | Returns the simplified words of the input text.
\_.getUsedWords(_.FINAL) | Returns the words of the input text after all preprocessing steps (e.g. simplification, auto-correction, compound splitting, etc.)

In contrast to the __\_USED\_WORDS__ variable which stores the user input as one string, these methods return the user input as a list of strings. For example the sentence "I want to order a cappuccino" is returned as ["I", "want", "to", "order", "a", "cappuccino"]. If you want them to look good in your output you thus have to add a __.join(" ")__ at the end of the call which will join everything into one string separated with whitespaces: 
```groovy
_.getUsedWords(_.ORIGINAL).join(" ")
```

!!! Note that there is also an API method called __\_.getNotUsedWords()__ that maps the words that have not matched the condition. For this method, the same parameters can be used as for __\_.getUsedWords()__.

## Optionality and \_USED_WORDS
Teneo features two ways of expressing optional words in an input: the [optional match option (:O)](/studio/reference/condition-syntax#optional-match-option) (for example: __I >> (really):O >> like >> you__) and the [maybe operator (~)](/studio/reference/condition-syntax#limit-unused-words-and-maybe) (for example: __(how+are+you) ~(doing/feeling/dear)__). If the user input matches an optional part of a Syntax Condition, the words of this match are also included in __\_USED_WORDS__.


Studio Web - Build - Used words

Used words

Analyze your bot

Analyze Log Data

Analyzing sessions

Augmenters

Concepts

Extract values with Augmenters

How To

Metadata

Running custom queries

Counting coffees with Metadata

Reference

Teneo Query Language Cookbook

Teneo Query Language Reference Guide

Teneo Query Language Syntax Overview

Teneo Query Language

Data hierarchy

Event

Property

Session

Transaction

How to

Explore session statistics

Find stuck flows

Generate session logs

Locate and view a session

Make use of skip constraints

Make use of sub queries

Query variables

Troubleshoot the Safetynet

Use relative dates in queries

Query Syntax

Command

Constraint

Meta-parameter

Selection

Transformer

Build your bot

Bot design

Best practices

Data footprint

Encrypting user data in sessions

Flow checklist

Plan your bot

Starting a new Teneo project

Writing good answers

Writing good examples

Conversations

Context restrictions

Flow stack

Greeting message

Listeners

Safetynet

Trigger Ordering

Create a custom order group

Handle ambiguous inputs

Make your bot pro-active

Share information between flows

Use listeners

Flows

Bulk Import

Entities

Junctions

Outputs

Sub-Flows

Transitions

Intent triggers

Variables

Add a script to your flow

Branch at the beginning of a flow

Use TLML Syntax Match

Use a Sub-Flow

Use Bulk Import

Language Understanding

Annotations

Attached scripts

Language conditions

Language objects

Languages

Lexical resources

Libraries

Linguistic Modeling Language

Localization

Match requirements

Combine Match requirements

Create a solution in your language

Create your own language objects

Find language objects and entities

Localize a bot

Normalize the user's spelling

Optimize language conditions

Recognize plural and singular

Store what the user said

Advanced Condition Coding

Annotations Reference

Condition Syntax Reference

DateTime Handler

Engine Scripting API Reference

Input Processing Path

Language Object Reference

Scripting

Engine scripting API

Groovy basics

Integration manager

Resource file manager

Scripts

Add a Groovy class

Add an integration

Add files to your solution

Annotate user inputs

Anonymize user data

Define a scripted context

Populate output parameters

Store input parameters

Test your bot

Run automated tests

Test your bot with Botium

Dialog Tester

Deploy your bot

Engine API

Versioning and Publishing

Publish your bot

Version Flags

Work with Version Flags

SDK's

Android

JavaScript

Node.js

Getting started

After Match

Extract Entities

Class Manager

Introduction to transitions

Introduction to entities

Deal with Follow-ups

Dialogue and Context Model

Getting started with Teneo

Handle interruptions

Skip conditions

Teneo in 10 minutes

Flows and match requirements

Entities and After Match

Your First Flow

Your First Solution

Optimize your bot

Optimize classes

Improve the balance

Review Inputs

Refine your bot

Debug your bot in Tryout

Use data to improve your bot

Use Teneo's improvement tips

Troubleshooting

My flow doesn't trigger

My flow behaves unexpectedly

I see warnings in Tryout

Suggestions

root

Table of Contents