verbot-4-manual

Last updated: Friday, January 28, 2005
Verbot 4 Manual

Table of Contents
Foreword 0
Part I Verbot4 4
Part II Introduction 4
................................................................................................................................... 51 System Requirements
................................................................................................................................... 52 Getting Started
Part III Verbot Scripting Interface (Overview) 6
................................................................................................................................... 81 File
.......................................................................................................................................................... 8New
.......................................................................................................................................................... 9Open
.......................................................................................................................................................... 10Recent Files
.......................................................................................................................................................... 11Save
.......................................................................................................................................................... 12Save As
.......................................................................................................................................................... 13Exit
................................................................................................................................... 152 Tools
.......................................................................................................................................................... 15Edit KnowledgeBase Info
.......................................................................................................................................................... 16Merge Knowledge
.......................................................................................................................................................... 20Print KnowledgeBase
.......................................................................................................................................................... 22Synonyms
.......................................................................................................................................................... 23Replacement Profiles
.......................................................................................................................................................... 24Skin Editor
.......................................................................................................................................................... 30Search Rules
.......................................................................................................................................................... 31Test KnowledgeBase
.......................................................................................................................................................... 34Compile KnowledgeBase
.......................................................................................................................................................... 34Expand KnowledgeBase
................................................................................................................................... 353 Help
.......................................................................................................................................................... 35Editor Introduction
.......................................................................................................................................................... 36Online Help
.......................................................................................................................................................... 37Community Forum
.......................................................................................................................................................... 38About
................................................................................................................................... 394 Resource Files Details
.......................................................................................................................................................... 40Resource Files
................................................................................................................................... 405 Rules
.......................................................................................................................................................... 41Rule Name
.......................................................................................................................................................... 42New Rule
.......................................................................................................................................................... 42Rename Rule
.......................................................................................................................................................... 43New Child
.......................................................................................................................................................... 44Delete Rule
Part IV How To's 45
................................................................................................................................... 471 Creating your First Rule
................................................................................................................................... 522 Creating Child Rules
................................................................................................................................... 533 Using Virtual Child Rules
Verbot 4.0 ManualI
© 2004 Conversive, Inc.

................................................................................................................................... 604 Creating Synonyms
................................................................................................................................... 635 Using Synonyms
................................................................................................................................... 676 Running Applications
................................................................................................................................... 697 Loading, Testing, and Talking - Oh my!
................................................................................................................................... 718 How to Compile a KnowledgeBase
................................................................................................................................... 729 The Teaching.vkb KnowledgeBase
Part V Advanced Features 76
................................................................................................................................... 771 Command Line Options
................................................................................................................................... 772 KnowledgeBase Templates and CSV Files
.......................................................................................................................................................... 77Creating a CSV file
.......................................................................................................................................................... 80Creating a KnowledgeBase Template
.......................................................................................................................................................... 82Expand or Compile
................................................................................................................................... 833 Variables
.......................................................................................................................................................... 89Internal Variables
.......................................................................................................................................................... 91Variables with Alternate Text
................................................................................................................................... 914 Tags and Inputs
.......................................................................................................................................................... 92MS Agent Tags
.......................................................................................................................................................... 93Special _Inputs
.......................................................................................................................................................... 94Verbot Tags
......................................................................................................................................................... 94agent.load
......................................................................................................................................................... 94exit
......................................................................................................................................................... 94learn
......................................................................................................................................................... 97load
......................................................................................................................................................... 97mem.get
......................................................................................................................................................... 97mem.set
......................................................................................................................................................... 98quit
......................................................................................................................................................... 98read
......................................................................................................................................................... 98readprint
......................................................................................................................................................... 98run
......................................................................................................................................................... 98send
Part VI Glossary 99
................................................................................................................................... 991 Child Rules
................................................................................................................................... 1032 Comma Separated Value (CSV) files
................................................................................................................................... 1033 Compiled KnowledgeBase Files (ckb)
................................................................................................................................... 1044 Expand
................................................................................................................................... 1045 Inputs
................................................................................................................................... 1086 KnowledgeBase
................................................................................................................................... 1097 KnowledgeBase Template
................................................................................................................................... 1098 Outputs
................................................................................................................................... 1099 Primary Rule
................................................................................................................................... 11010 Rule
................................................................................................................................... 11011 Synonyms
................................................................................................................................... 11212 Synonym Output
IIContents

................................................................................................................................... 11213 Verbot
................................................................................................................................... 11214 Virtual Child Rules
................................................................................................................................... 11215 Verbot KnowledgeBase Files (vkb)
Part VII Documentation History 113
Index 0
Verbot 4.0 ManualIII

Verbot4 4
1 Verbot4
Last Update: Friday, January 28, 2005 2:43 PM
Download this help file exe format
Download this help file PDF format
2 Introduction
A Tale of Two Applications.
With Verbot® 4.0 technology, creating your own intelligent agent becomes as straightforward as typing
a sentence or command in natural language text. This manual includes information which will quickly
get you up to speed with creating your own Verbot® personality. Of course you don't have to create
your own Verbot® KnowledgeBase, but doing so is half the fun!
Verbot® 4.0 Standard Edition comes with two applications. Verbot® 4.0 Standard Edition Player, and
the Verbot® Scripting Interface.
Verbot® 4.0 Standard Edition Player
The Verbot® Player loads KnowledgeBases and displays an animated character that you can interact
with through text based conversation. Content within a KnowledgeBase Rule allows the Verbot®
character to open desktop applications, and perform various animations.
Verbot Scripting Interface
The Verbot Scripting Interface is used to create custom KnowledgeBases. The easy to use interface
allows you to create Rules which contain Inputs and Outputs. Inputs can utilize Verbot® Synonym files
to help make scripting a breeze. Outputs can contain special tags which can open and run
applications, as well as animate the Verbot® in many ways.
If you're anxious to get started creating your own Verbot® personality see: How to's

Verbot 4.0 Manual5
2.1 System Requirements
System Requirements:
· Windows 2000/XP
· Microsoft Agent
· Text to Speech Engine
· .Net Framework 1.1 or higher
· SAPI 4.0*
Microsoft Agent Links:
Microsoft Agent Main page:
http://www.microsoft.com/msagent/
Microsoft Agent Download page:
http://www.microsoft.com/msagent/downloads/user.asp
Microsoft Text to Speech Downloads:
http://www.microsoft.com/msagent/downloads/user.asp#tts
*Windows XP users require SAPI 4.0 download
http://www.microsoft.com/msagent/downloads/user.asp#sapi
Microsoft .Net Framework Downloads:
The best way to install the .Net Framework is through Windows Update.
Locate it and install as needed from Windows Update.
http://www.windowsupdate.com
(Note: If .Net is not listed as a windows update, you already have it installed)
Alternative Download:
http://msdn.microsoft.com/netframework/technologyinfo/howtoget/default.aspx
2.2 Getting Started
Verbot Technology was designed from the ground up to be user friendly, yet powerful. If you're eager
to begin Scripting we provided links to a few terms and tutorials to quickly get you up and running.
Terms you should know:
· KnowledgeBase
· Rule
· Input
· Output
· Synonyms
How To's to get you up and running:
· Creating your First Rule
· Creating Child Rules
· Using Virtual Child Rules
· Creating Synonyms

Introduction 6
· Using Synonyms
Once you've mastered creating Rules and Synonyms you'll be ready to move on to more advanced
features. Click here for an overview of How To's
3 Verbot Scripting Interface (Overview)
When the Verbot Scripting Interface (VSI) first opens, you will have access to the following items:
· File
· New
· Open
· Recent Files
· Save
· Save As
· Exit
· Tools
· Edit KnowledgeBase Info
· Merge KnowledgeBase
· Print KnowledgeBase
· Synonyms
· Replacement Profiles
· Skin Editor
· Search Rules
· Test KnowledgeBase
· Compile KnowledgeBase
· Expand KnowledgeBase
· Help
· Editor Introduction
· Online Help
· Community Forum
· About
· Resource Files Details
· Resource Files
· Add Files
· Delete Files
· Rules
· Rule Name
· New Rule
· Rename Rule
· New Child
· Delete Rule

Verbot 4.0 Manual7

Verbot Scripting Interface (Overview) 8
3.1 File
3.1.1 New
The "New" menu item allows you to create a new KnowledgeBase for your agent.

Verbot 4.0 Manual9
3.1.2 Open
The "Open" item on the menu allows you to open a previously saved KnowledgeBase, or a
KnowledgeBase which may have been downloaded.

3.1.3 Recent Files
The "Recent Files" item on the menu allows you to open recently opened KnowledgeBases. Use this
feature to quickly load KnowledgeBases you have been working with.

Verbot 4.0 Manual11
3.1.4 Save
The "Save" menu item saves the currently opened KnowledgeBase.

3.1.5 Save As
The "Save As" menu item saves the currently opened KnowledgeBase under a different name.

Verbot 4.0 Manual13
3.1.6 Exit
"Exit" of course, exits the Verbot Scripting Interface.

Verbot 4.0 Manual15
3.2 Tools
3.2.1 Edit KnowledgeBase Info
The "Edit KnowledgeBase Info" tool is used to fill in details about the loaded KnowledgeBase.
Using the "Edit KnowledgeBase Info" tool you can do the following:
· Author: Name the Author of the KnowledgeBase
· Author Website: Provide a URL to the Author's website
· Copyright Info: Provide Copyright Information
· Licence Info: Provide information about how the KnowledgeBase is being released
· Rating Level: Set a KnowledgeBase Rating: Kids, General, Teens, Mature Audience, Unknown
· Additional Check boxes: Language, Violence, Sexual Content, Other
· Rating Description: provide any additional information on the rating you would like to include.
· Comment: Type any additional comments about the KnowledgeBase here.

3.2.2 Merge Knowledge
Come together right now over me.
To merge to KnowledgeBases together, click the "Merge KnowledgeBase" link. The Merge
KnowledgeBase dialog box.

Verbot 4.0 Manual17
When the dialog box first opens your current loaded KnowledgeBase is displayed. You may click any
Rule in the "KnowledgeBase Rules" field to display its details in the "Rule Details" field.
To merge another KnowledgeBase with the currently displayed KnowledgeBase click the "Merge
KnowledgeBase" button.
Select the KnowledgeBase you wish to merge with the currently displayed KnowledgeBase and click
"Open"

Once you click "Open" the KnowledgeBase merge process will begin. It may take several minutes to
process depending on the size of the KnowledgeBases.
As the KnowledgeBases are processed Information will be printed to the "Information" field. While the
KnowledgeBase is being processed the "Ok" button will be grayed out. However, you can cancel the
process anytime by clicking the "Cancel" button.
When the process is complete you can look over the changes or click the "Ok" button to except
changes. You may also click "Cancel" to cancel all changes.

Verbot 4.0 Manual19
Look at all the pretty colors.
As the KnowledgeBase loads information about the process is color coded and printed in the
Information field. When the process is complete, Rules that have been changed in some form are also
color coded.
Each color means something different. Here is a brief overview of what the color coding means:
· Green = The Rule that an Input existed in the original KnowledgeBase and the loaded
KnowledgeBase.
· Blue = The Rule did not exist in the original KnowledgeBase and was added from the loaded
KnowledgeBase.
· Red = Red text only appears in the Information box. Red text items are a result of duplicate Rule IDs
being identified. All duplicate Rule IDs are regenerated automatically to avoid problems and require
no manual manipulation.

3.2.3 Print KnowledgeBase
It's not a KnowledgeBase, it's a Novel!
In some cases you may wish to view you're Verbot KnowledgeBase from beginning to end. The Print
KnowledgeBase menu item allows you to print the entire KnowledgeBase out for review of Inputs and
Outputs.

Verbot 4.0 Manual21

3.2.4 Synonyms
The "Synonym" Tool opens the Synonym Editor used to create and Edit Synonym files.
For information on Synonyms see: Synonyms
For information on creating synonyms see: Part 3 : Creating Synonyms
For information on using synonyms in your KnowledgeBase see: Part 4 : Using Synonyms

Verbot 4.0 Manual23
3.2.5 Replacement Profiles
The "Replacement Profile" editor allows you to designate different text to be sent to the TTS verses the
text displayed within the Verbot Output box.
If for example you created a "Replacement Profile" that might be used in the United Kingdom - you
might want to map the text "Television" to the word "Telly".
With the "Replacement Profile" editor you can remap the word "Television" to send the word "Tell e" to
the Verbot TTS Engine (spelling can be adjusted to allow the text to speech engine best represent the
word.), and present the word "Telly" within the Verbot Output box.
Below is an image of the "Replacement Profile" Editor which includes the example above as well as
"smilies" remaped to Verbot Animations.
The image below is the result from asking the Verbot "do you watch Television?". Although the original
Output contained the text "Television" instead of "Telly". The Replacement Profile above replaced
"Television" with "Telly" in the Output box, and sent the text "Tell e" to the Verbot TTS engine.

3.2.6 Skin Editor
The Verbot Skin Editor currently allows you to create skin files which can be loaded into the Verbot
Player.
Skins include information such as screen size, colors, and agent to use when the skin is loaded.

Verbot 4.0 Manual25
Agent to use
Select the Agent you wish the Skin to utilize when it first loads.
TTS Mode
Select the TTS engine the Agent should use.
Speed
Use the slider bar to adjust the rate of speed in which the Agent speaks.
Pitch
Use the slider bar to adjust the pitch of the Agents voice.
Restore Defaults
Use the "Restore Defaults" button to restore the Speed and Pitch of the Agents voice to the default

settings.
Window Height
You may select the height of the Verbot Player window in pixels.
Window Width
You may select the width of the Verbot Player window in pixels.
Allow User to resize window
By unchecking the check box disables the user from re-sizing the Verbot Player.
Input Text Font
You may select the font style and size for the Input box.
Output Text Font
You may select the font style and size for the Output box.
Background Image Filename
Use the background choose button to select an image file to use as a background (skin) for the Verbot
Player.
Image file formats include: bmp, png, gif, jpg, and jpeg
Input Text Color
Use the Choose Color button to select the color you wish to use for the Verbot Player's Input text.

Verbot 4.0 Manual27
Input Background Color
Use the Choose Color button to select the color you wish to use for the Verbot Player's Input
background.

Background Color
As an alternative to an image file you can simply select the background color you wish to use for the
Verbot Player.
Output Text Color
Use the Choose Color button to select the color you wish to use for the Verbot Player's Output text.

Verbot 4.0 Manual29
Output Background Color
Use the Choose Color button to select the color you wish to use for the Verbot Player's Output
background.

Agent Background Color
As an alternative to an image file you can simply select the background color you wish to use for the
Agent's background in the Verbot Player.
3.2.7 Search Rules
The "Search Rules" tool allows for you to search a KnowledgeBase for a text string.
Using the check boxes on the Search Rules interface you can search specific areas of the
KnowledgeBase.
By default Rule Names, Rule Inputs, and Rule Outputs are checked. You can use the check boxes to
select the area
relevant to your search.

Verbot 4.0 Manual31
3.2.8 Test KnowledgeBase
"Test KnowledgeBase" allows you to test an open KnowledgeBase within the Verbot Scripting
Interface.
To use click on the "Tools" menu --> "Test KnowledgeBase"
A popup window like the one below will open. Type your question in the Input box.

Once you type in your question press the "Enter" key on your keyboard.
Matches will be found and highlighted.
If a rule has Variables, they will be displayed within the Variable field with their current value. This is
useful for finding out what Variables are set to during runtime and what is being captured.

Verbot 4.0 Manual33
You may click on any of the highlighted Compiled Inputs to load the Rule that fired into the Verbot
Scripting Interface.

3.2.9 Compile KnowledgeBase
The "Compile KnowledgeBase" feature creates compiled KnowledgeBases which can in some cases
speed up very large KnowledgeBase interactions.
You'll usually never need to compile a KnowledgeBase unless you notice that the Verbot is responding
slowly to queries.
3.2.10 Expand KnowledgeBase
Expand KnowledgeBase creates a .vkb file based on a KnowledgeBase Template. Once a
KnowledgeBase Template has been expanded it can be viewed and tweaked within the Verbot
Scripting Interface.
For more information on KnowledgeBase Templates see: Creating a KnowledgeBase Template

Verbot 4.0 Manual35
3.3 Help
3.3.1 Editor Introduction
The Editor Introduction is a short cut to the online help. New Verbot users are encouraged to click the
link to learn more about scripting.

3.3.2 Online Help
The "Online Help" links to the latest documentation. Currently updates are made daily.

Verbot 4.0 Manual37
3.3.3 Community Forum
The "Community Forum" menu item links to the Verbot Community Forum. You may wish to join the
forum access Verbot downloads such as additional KnowledgeBases and Characters. You'll also be
able to interact with a large audience of Verbot users from around the world.

3.3.4 About
"About" is useful for displaying the version number and build number of the Verbot application in use.

Verbot 4.0 Manual39
.
3.4 Resource Files Details

3.4.1 Resource Files
The "Resource Files" field displays the currently assigned resources.
Currently supported resource file types are Synonym Files.
The "Add" button allows you to add new resources, files to the currently loaded KnowledgeBase.
The "Delete" button allows you to remove resources from the currently loaded KnowledgeBase.
For information on creating synonyms see: Part 3 : Creating Synonyms
For information on using synonyms in your KnowledgeBases see: Part 4 : Using Synonyms
3.5 Rules

Verbot 4.0 Manual41
3.5.1 Rule Name
The first step for creating a KnowledgeBase is creating a Rule.
The "Rule Name" field is where you type in the name of the Rule you wish to create. The Rule name
can be anything and is used only as an identifier.
To create a new Rule, type in the name of the Rule you wish to create and Click the "New Rule"
button.
To create a Child Rule, select an existing Rule from the Rule tree field, type in a name for the Rule and
click "New Child"
To learn more about creating Rules see: Part 2 : Creating your First Rule

3.5.2 New Rule
The "New Rule" button is used to create a new Rule in the currently loaded KnowledgeBase.
3.5.3 Rename Rule
The "Rename Rule" button is used to rename the selected Rule within the Rule tree.

Verbot 4.0 Manual43
3.5.4 New Child
Child Rules are used to create a hierarchy within Rules. Once a Primary Rule fires the Child Rule is
eligible to fire.
To create a Child Rule select a Rule within the Rule tree and click "New Child."

3.5.5 Delete Rule
To delete a Rule select a Rule from the Rule tree and click "Delete Rule". The selected Rule will be
deleted.

Verbot 4.0 Manual45
4 How To's
From start to finish you'll have fun learning!
This Section is designed to get you up and running with the Verbot Scripting Interface.
Verbot® 4.0 has been designed to allow anyone to script complex and engaging virtual personalities,
even those without previous programming experience. With the Verbot Scripting Interface, you can
create your own personalized KnowledgeBases, as well as scripting interactions with applications and
character animations.
The Verbot Scripting Interface
This section will introduce you to the Verbot Scripting Interface. Learn out about the features of the
interface and where they are located.
Creating your First Rule
KnowledgeBases are made up of Rules. Rules consist of Inputs and Outputs. This section will walk

How To's 46
you through creating your first Verbot® Rule, from there you're on your way to making fantastic
KnowledgeBases of your own design!
Creating Child Rules
Learn how to create Child Rules, that allow the Verbot to follow a hierarchy based conversation.
Using Virtual Child Rules
Learn how to link Rules to other Rules using Virtual Child Rules.
Creating Synonyms
To aid you with creating Inputs with minimal repetition. Verbot® Synonym files can be created and
added to any KnowledgeBase you create. This section will step you through making a synonym file.
Using Synonyms
The Creating Synonyms walked you through creating a powerful synonym file, This section will show
you how to harness the power by stepping you through using synonyms within your Inputs.
Variables
Learn how to retain, and recall user based input with Variables.
Variables with Alternate Text
Learn how to display text when a Variable has not yet been set.
Internal Variables
Learn about built in Verbot Variables like displaying the time and date.
MS Agent Tags
Find out how to make your Verbot® smile, move about, and more!
Verbot Tags
Verbot Tags add functionality such as Read, Send, and Run.
Special _Inputs
Verbot® 4.0 has a few special inputs used for start up, and when the Verbot is left idle for an extended
period of time.
Running Applications
Now that you know Verbots® can smile and move around. Give them something to do! This section
guides you through opening applications and urls.
Loading, Testing, and Talking
Now that you have a custom KnowledgeBase, find out how to load it and test it.
How to Compile a KnowledgeBase
Learn how to Compile a KnowledgeBase to share with your family and friends.
The Teaching.vkb KnowledgeBase
Learn how the Teaching.vkb KnowledgeBase helps your Verbot learn dynamically.
Advanced Features:
Creating a CSV file
Learn to create CSV files with your favorite spreadsheet software.
Creating a KnowledgeBase Template
Learn to create KnowledgeBase Templates that use data from a CSV file to create data driven
KnowledgeBases.

Verbot 4.0 Manual47
Expand or Compile
Once you have a KnowledgeBase Template with associated CSV file ready to go, it's time to Compile
it, Expand it, or you can do both. The following section describes the difference between Expanding
and Compiling.
4.1 Creating your First Rule
Creating Rules in Verbot® 4.0 is quick and easy.
Rules hold the knowledge of your Verbot®. A Rule is made up of Inputs and Outputs. An Input is used
to match to what the user types. Once an Input finds a match the Output (or Response) is presented to
the user.
To create a Rule you must first give it a name. Start by typing in the Rule Name input box. We'll
use"Hello World" for this example.

How To's 48
Once you've typed "Hello World," click the "New Rule" button or simply press "Enter" to create a
Primary Rule.
Your screen should look like the following:
Adding an Input to your Rule
Now that you've created a Rule. You'll need to add an input or two to make it available for your Verbot®
to use. An Input can be made up of single or multiple words.
For the purposes of this example, we simply want the Verbot® to respond to a user typing in "Hello" or
"Hi".
To create an Input click the "Add" button within the "Inputs Group".

Verbot 4.0 Manual49
You'll notice that "Hello World" appears in the pop-up window and is highlighted. As a convenience, the
Editor assumes your Rule name will be your first input. However for this example we want the Rule to
fire on the input of "Hello" or "Hi". Change the text from "Hello World" to "Hello". And click "Ok" or press
the "Enter" key.

How To's 50
Now that you've added "Hello," you may want to also add the Input "Hi". To add another Input, click the
"Add" button within the "Inputs Group" and repeat the process as you did with "Hello". You can add as
many inputs as desired.
Now that you've finished adding your inputs, it's time to create an Output (also known as a Response).
To create an Output click the "Add" button within the "Outputs Group". A pop-up box appears with two
fields. The top field is used to hold the Verbot® Output. The lower field is used to hold extra commands
(i.e. a command to run a program).

Verbot 4.0 Manual51
Enter "Hello World" within the top field and click the "Ok" button or press the "Enter" key. The Output
has been added. You've now created your first Rule.

How To's 52
At this point it's a good idea to save your KnowledgeBase. Click "File" --> "Save" on the menu.
After you've saved your KnowledgeBase you can test your Rule two different ways. You can:
1. Load the Verbot Player then load your KnowledgeBase or
2. Use "Test KnowledgeBase" from the "Tools" menu.
4.2 Creating Child Rules
A Child Rule is designed to fire only after a Parent or Primary rule has previously fired. Looking at the
window, the child rules"red" or "yellow" will never fire unless the "two colors" rule has fired immediately

Verbot 4.0 Manual53
before.
A primary rule can have as many Child Rules as you want. You may even choose to assign Child
Rules to other Child Rules and can even have a conversation follow a hierarchy structure.
Note: In order to keep the User on track, you may want to use Virtual Child Rules to insure the Verbot
is getting the response desired.
For more information on Rules see: Creating your First Rule
For more information on Virtual Child Rules see: Using Virtual Child Rules
4.3 Using Virtual Child Rules
Virtual Child Rules are used to link Rules to other Rules, virtually! The best way to understand how
Virtual Child Rules work is through a tutorial to see them in action.

How To's 54
Example 1: All I want from you is a straight answer!
In the following example, you'll learn how to have the Verbot ask a question and receive one of three
possible Inputs from the User.
We'll start by creating a _startup Rule. A _startup is a special Input that the Verbot looks to fire when it
is first loads.
You can see that the _startup Rule has the Input "_startup" and the Output "Hi! Would you like to take
a quick quiz?"
Next, we'll make a few Child Rules. One for the Input "yes," one for "no," and one that will fire if there is
no match.

Verbot 4.0 Manual55
As you can see above the _startup Rule now has three Child Rules. Here is what each Rule contains
so far:
_startup
Input: _startup
Output: Hi! Would you like to take a quick quiz?
anything else
Input: *
Output: I'm sorry. I really need a "Yes" or "No" Answer.
no
Input: no
Output: Okay no problem.
yes
Input: yes
Output: Great. Let's get started! What is the name of the planet most people live on?

How To's 56
Okay let's test it. Click on "Tools" --> "Test KnowledgeBase"
The _startup Rule will fire and display: "Hi! Would you like to take a quick quiz?"
Now, if you were to type "yes" or "no," the appropriate Child Rule would fire. However, if you were to
send the Input "maybe" - the only Child Rule that would match would be the Rule "anything else" using
the Input "*" with the Output "I'm sorry. I really need a "Yes" or "No" Answer."

Verbot 4.0 Manual57
The problem we would have if you answered the Verbot with "yes" or "no" after the "anything else" Rule
has fired - is that there are no Child Rules for the "anything else" Rule. This is where Virtual Child
Rules come in.
Close the Verbot Script Tester window. Click on the Rule "anything else" to select them and then click
on the "Virtual Child" button. The Rule Activation List window will pop up.

How To's 58
"Click" on the check box for the following Rules: "anything else", "no" and "yes".

Verbot 4.0 Manual59
Once you've selected all three Rules click on "Ok". To test the Script open the "Verbot Script Tester"
("Tools" --> "Test KnowledgeBase") and test the KnowledgeBase again.
Type in the Input "maybe".
As before your Input of "maybe" fires the "anything else" Rule with the Output: "I'm sorry. I really need a
"Yes" or "No" Answer."
The Verbot will keep firing the "anything else" Rule until the Input of one of the Virtual Child Rules is
received ("no" or "yes").
Once "no" or "yes" is received by the Verbot, it will look for another Child Rule. If a Child Rule is not
found it will search through the Primary Rules.

How To's 60
4.4 Creating Synonyms
The Synonym Editing Interface is used interchangeably to create groups of words which can be used
as synonyms within Rule Inputs.
Creating Your First Synonym
Type in the text you would like to use to describe your synonym. In this example we will call our
synonym "What is". Once you type in "What is," click the "Add" button. The Synonym should look like
the following screen shot:

Verbot 4.0 Manual61
Next, enter the synonyms words/phrases. In this example we'll add "What is" and then the contraction
"What's".

How To's 62
Save your Synonyms
Once you have added the desired amount of synonyms, click "File" --> "Save".
After you have named and saved your synonym, you may click "File --> Close" to close off the
Synonym Editor Window.
That's it! You've created your first synonym file.
For information on Synonyms see: Synonyms
For information on using Synonyms see: Part 4 : Using Synonyms

Verbot 4.0 Manual63
4.5 Using Synonyms
First Things First...
The Synonym Editing Interface allows you to create groups of words or phrases which can be
interchanged within an Input.
Before using Synonyms you should already be familiar with the Synonym Editing Interface, and have a
synonym file saved.
Quick Links:
Using Synonyms within an Input
Using Synonyms within an Output
Using Synonyms within an Input
When the Verbot Scripting Interface loads, it should look like the following screen shot. You'll notice the
right side contains a group called "Resource Files". A Resource File is where you will load your
previously created synonym file.

How To's 64
To add a Resource File:
1. Click the "Add Files" button
2. Locate the Synonym file you created. The file should have the .vsn extension.
3. Select the Synonym file and click the "Open" button on the dialog box
4. Your synonym file should now be added to the Resource Files field. (see image below)

Verbot 4.0 Manual65
Add a new Rule
You should be familiar with creating Rules by now. If not, please review:
Part 2 : Creating your First Rule.
You should remember that your synonym file "what is" contains the synonyms "What is" and "What's."
The name of the synonym is "What is".
Before you can use the synonym, you'll need a rule. Below you'll see that a Rule entitled "What is a
Verbot?" has been created.

How To's 66
Now that you have created a Rule, you need to add an Input. To use the synonym "What is" within the
Input, you have to format it in a special way so that the Verbot Engine "knows" that a synonym exists
for "What is".
In order to use a synonym, you will need to write the synonym name--in this case, "what is"-- and
enclose it in parenthesis. Here is an example. Click the "Add" button within the Inputs group. When the
Input dialog box appears, type in the following Input: "(what is) a Verbot?", then click ok.

Verbot 4.0 Manual67
As you can see, from the image above, the Output: "A verbal software robot." has been added.
You now have one complete Rule ready to test. Make sure you save your KnowledgeBase by clicking
"File --> Save."
If this is your first time saving, you'll need to name the file. That's it! You're now ready to test your Rule.
To see that it works properly, you should do some testing. To do so, click on "Tools"->"Test
KnowledgeBase." You will notice that you get output if you type "What is a Verbot?" or "What's a
Verbot?" and that is because you have a synonym that contains them both.
Using Synonyms within an Output
Much like using Synonyms within Inputs you can use Synonyms within Outputs. The Verbot will pick
one of the phrases from that Synonym group and insert it in your output.
4.6 Running Applications
You may have noticed when you were creating Outputs that there is a field labeled "Command". The
"Command" field is used to open a web address in the user's default browser or to run an application.
Below are a few examples using the "Command" field within the Output dialog box.

How To's 68
To open a web address just type in the URL. For example: http://www.verbots.com
To open a text file in Microsoft Notepad, type in the application name and file name to open. For
example: notepad c:docsmytext.txt

Verbot 4.0 Manual69
4.7 Loading, Testing, and Talking - Oh my!
By now, you should have a pretty good idea about creating Rules, Synonyms, and using Variables and
Tags.
Now that you have your completed KnowledgeBase, it's time to load it up and test it.
Follow these quick easy steps to begin interacting with your own KnowledgeBase.
1. Click on the Verbot 4.0 icon on your desktop (The Verbot will load with the last known
configuration.)
2. Once the Verbot has loaded, click on the menu item labeled "Tools --> Options."
3. Click on the tab labeled "KnowledgeBases."

How To's 70
4. Click on the "Add" button and locate the KnowledgeBase you created.
5. Once you have selected your KnowledgeBase, click "Open."
6. Your KnowledgeBase should now be listed in the KnowledgeBase selection field.

Verbot 4.0 Manual71
7. Your KnowledgeBase will be added to the top of the list. The list order identifies what Rule will be
evaluated first when two Rules match from each KnowledgeBase. In other words, if the engine
finds matches for an Input in two different KnowledgeBases, it will fire the response from the
KnowledgeBase that is at the top.
8. Before clicking "Close," you may uncheck any KnowledgeBase you do not wish the Verbot to use.
Once you've finished selecting KnowledgeBases, click "Close."
9. The Verbot will load your selected KnowledgeBase(s). Now you should try testing the Rules you've
created.
Note: That the above process reflects using the Verbot Player for final testing. You may also test
during development of your Scripts using Test KnowledgeBase on the Verbot Scripting Interface menu.
4.8 How to Compile a KnowledgeBase
Why Compile a KnowledgeBase?
The main reason to compile a Verbot Knowledge base is to distribute your KnowledgeBase to family
and friends who may have Verbot Standard Edition, but can still download the Free Verbot Player to
interact with your creation.
How to Compile a KnowledgeBase.
Compiling a KnowledgeBase is simply a matter of loading a KnowledgeBase into the Verbot Scripting
Editor, then from the top menu select "Tools-->Compile KnowledgeBase"
The currently loaded KnowledgeBase will be compiled and saved with .ckb extension.

How To's 72
4.9 The Teaching.vkb KnowledgeBase
Who needs an Editor?
The Teaching.vkb KnowledgeBase allows new Rules to be dynamically added while chatting with the
Standard Player. You may want to open the Teaching.vkb KnowledgeBase to see how the Learning
Rules have been setup. You may also want to tweak Inputs to your own preference using the um... the
Editor :)
Note: This feature can only be used if you own Verbot Standard Edition and is not supported by the Free Verbot Player.
How to use the Teaching.vkb
To teach the Verbot while chatting with the Standard Edition Player do the following:
Make sure that the Verbot Standard Edition player has the required KnowledgeBases loaded and
selected. Teacher.vkb and LearnedKnowledge.vkb should be loaded and checked.
Note: Wondering what the difference between a .vkb file and a .ckb file is? Click here to find out.

Verbot 4.0 Manual73
To teach the Verbot something new type into the Input box on the Verbot Player and press "Enter".
For example type in: What is a gizmo?

How To's 74
The Verbot will respond with something along the lines of "I don't know" or some other response
depending on the KnowledgeBases you have loaded.
Type in: remember a Gizmo is a special device.
Then press the "Enter" key.

Verbot 4.0 Manual75
Julia will say something along the lines of: I'll be sure to remember that.
To test her type in: What is a gizmo?
Press the "Enter" key.

How To's 76
Julia will now respond with: A Gizmo is a special device
Note: This is a new feature and we will be adding and tweaking the Teacher.vkb KnowledgeBase in coming updates. You may
also want to create your own learning Rules using the Verbot Scripting Editor.
The Teacher.vkb contains various sample learning Rules that you can use to dynamically add Rules
while interacting with the Verbot. You may also add your own learning Rules to capture different kinds
of Inputs.
Note: When editing the default Teacher.vkb file, you may have to compile it to a .ckb file in order to interact with your changes
in the Verbot Player.
To find out more about the learning tags used in the Teacking.vkb see: Verbot Tags section.
5 Advanced Features
The Verbot 4.0 Standard Edition includes advanced features which aid in the development of Verbot
KnowledgeBases.
Use the links below to jump to areas of interest.
KnowledgeBase and CSV Files
· Creating a CSV File
· Creating a KnowledgeBase Template
· Expand or Compile

Verbot 4.0 Manual77
5.1 Command Line Options
The --input command line option allows you send an Input to the Verbot and start up.
Verbot4Engine.exe --input="This is my input text."
5.2 KnowledgeBase Templates and CSV Files
KnowledgeBase Templates allow you to create data driven KnowledgeBases. For example, you can
create a list of names and phone numbers in a spreadsheet program such as Microsoft Excel. Once
complete you can export the data to a CSV file which an in turn be imported into the Verbot Scripting
Interface. Using the data from the CSV and Template Rules, a new KnowledgeBase can be created
which include the CSV data which can then be accessed through conversational interactions with the
Verbot.
The following sections cover the creation of KnowledgeBase Templates and CSV files:
· Creating a CSV file
· Expanding or Compiling
5.2.1 Creating a CSV file
What is a CSV file?
CSV also known as Comma Separated Value files are a standard export format for many applications,
most notably is Microsoft Excel. Use the CSV format you can create data driven KnowledgeBase by
entering your data by way of a spreadsheet program such as Excel or Open Office Spreadsheet. Using
KnowledgeBase Template Rules you can access CSV data by Compiling or Expanding the
KnowledgeBase Template.
Note: If you don't have Microsoft Excel you may want to download Open Office which includes a spreadsheet application.
Adding Data.
This section assumes you have Microsoft Excel. If you haven't done so already, open a blank Excel
spreadsheet.

Advanced Features 78
The first row is considered a heading. For this example you are going to make a Verbot phone book.
So in row 1 column A enter "Name". Then in row 1 column B enter "Number". Your spreadsheet should
look like the following:
Now that the spreadsheet has headings you can begin entering names and numbers for your friends
and family. Your spreadsheet should end up looking something like this:

Verbot 4.0 Manual79
Now that you have your headings and data entered, it's time to save the file as a CSV file. Click "File"--
>"Save As"
The following dialog box should appear. Click on the "Save as type" drop down and locate the file type:
"CSV (Comma delimited)" format. Type in phone_book for the name of the file, and click the "Save"
button.

Once your you've saved the file it's time to move on to the next section
Creating a KnowledgeBase Template.
5.2.2 Creating a KnowledgeBase Template
What is a KnowledgeBase Template?
A KnowledgeBase Template is used to create data driven KnowledgeBases. The first step is to
create a CSV file which contains the data you wish to access. Then create Template Rules to access
the data.
What is a KnowledgeBase Template Rule?
A Template Rule is a Rule that has been setup to use CSV data to created new Rules. The new Rules
are created when you click "Expand" or when the KnowledgeBase is compiled using "Compile
KnowledgeBase" The following section assumes you completed the Creating a CSV file section and
are ready to create a KnowledgeBase Template.
Creating a KnowledgeBase Template.
To begin creating a KnowledgeBase Template, open the Verbot Scripting Editor. Once the Verbot
Scripting Editor is loaded it's time to make your first Template Rule. If you're not familiar with Rule
creation you may want to review the Creating your First Rule section.
Create a new Rule using the following information:

Verbot 4.0 Manual81
Rule Name: Get Phone Number
Input: What is #Name's phone number?
Output: #Name's phone number is #Number.
You're screen should appear as shown below:
Now you have a Template Rule created it's time to assign a CSV file to the KnowledgeBase. Click the
"Add Files" on the Resource Details panel shown below:
Locate the phone_book.cvs file you created in the Creating a CSV file section and click "Open" to add

it to the Resource Files Details field.
Note: Multiple CSV files can be used within one KnowledgeBase.
At this point it's a good idea to save your KnowledgeBase.
Now that you have a Template Rule and a loaded CSV file it's time to Expand or Compile the
KnowledgeBase.
5.2.3 Expand or Compile
Expanding or Compiling
Once you have a KnowledgeBase Template with associated CSV file ready to go, it's time to Compile
it, Expand it, or you can do both. The following information describes the difference between
Expanding and Compiling.
Why should a KnowledgeBase be Expanded?
When a KnowledgeBase Template is Expanded a new .vkb file is created based on the
KnowledgeBase Template Rules and the loaded CSV file. Once the KnowledgeBase is Expanded and
the new .vkb file is created, the new .vkb file can be loaded within the Verbot Scripting Editor for
tweaking or to view the results.
How to Expand a KnowledgeBase Template
Why should a KnowledgeBase be Compiled?
Compiling a KnowledgeBase Template creates a new .ckb file which created based on the
KnowledgeBase Template Rules and the loaded CSV file. Once the KnowledgeBase is compiled a new
.vkb file is created which can be loaded into the Free Verbot Player or the Verbot Standard Edition
Player for testing or use. It is important to note that the Free Verbot Player can only load Compiled
KnowledgeBases (.ckb). To share your KnowledgeBase with friends you'll need to provide them with
this link to the Free Verbot Player and supply them with your KnowledgeBase Compiled (.ckb).
How to Compile a KnowledgeBase Template
How to Expand a KnowledgeBase Template
To Expand a KnowledgeBase Template you can click on the Expand icon or click "Tools"-->"Expand
Templates" on the menu.
Once you have clicked the "Expand", a dialog box will pop-up. Give the KnowledgeBase Template a
new name. For example: phone_book_expanded.

Verbot 4.0 Manual83
Click the save button to begin the Expand process. Depending on the size of the CSV file and the
amount of Template Rules it may be several seconds to Expand the KnowledgeBase Template. Once
the Template is expanded you may load the resulting .vkb file into the Verbot Scripting Interface to see
the results and tweak if needed.
How to Compile a KnowledgeBase Template
To compile a KnowledgeBase Template click on the Compile icon or click "Tools"-->"Compile
KnowledgeBase" on the menu.
Once you have clicked "Compile" the process begins. (Note: no dialog box pops up. The file is
automatically saved with the .ckb extension)
Depending on the size of the CSV file and the amount of Template Rules it may take several minutes
to Compile the KnowledgeBase Template. Once the Template is compiled you may load the resulting
.ckb file into the Verbot Player to interact with it. In order to view the results of a KnowledgeBase and
CSV file you will need to Expand the KnowledgeBase.
5.3 Variables
My name is [username], do you remember me?
Variables help the Verbot remember things about you. Some variables can even be setup to remember
things like phone numbers, family members and more.
The easiest way to understand Variables is by looking at an example. Let's start by learning how a
Verbot remembers your name.

Understanding What Variables do.
When a user first speaks with a Verbot, the Verbot doesn't know the user's name. For example, if you
asked the Verbot "What is my name?" it would most likely respond with "Your name is Friend."
However, if you told the Verbot "My name is Mary" the Verbot would respond with "It's nice to meet you
Mary."
The Verbot now knows that your name is Mary. If you were to ask "What is my name?" the Verbot
would now respond "Your name is Mary."
What is my name?
Let's look at a sample response in which the Verbot does not know your name. "What is my name"
Rule first - so we can see how the Verbot responds with "Friend" if it doesn't know your name.
Rule Name: What is my name
Input: (what is) my name
Output: Your name is [name:Friend].
Note: (what is) <-- is a Synonym. Click Here to find out more about Synonyms
You might have noticed that before you tell the Verbot your name, it call you "Friend". The Verbot uses
"Friend" because the Variable "name" is not set.
The following example shows a Variable with the default setting of "Friend". You can of course replace
"Friend" with anything you like (or not use an alternate at all, which would return nothing).
Example:
Your name is [name:Friend].

Verbot 4.0 Manual85
My name is [name]
We now know that if a variable is not set it will use alternate text if available, but how do we set the
Variable? It's actually rather simple. Let's look at the Rule "My name is [name]."
Rule Name: My name is [name]
Input: My name is [name].
Output: Good to meet you [name]!
The Variable "[name]" that is found within the Input "My name is [name]," tells the Verbot to record
whatever text the user types in the place of "[name]."
The [name] within the Output simply prints out the text that was captured in the Input. Having the
Verbot repeat back what it has captured not only makes the conversation with the Verbot more
realistic, but it also makes it more personal.
For example, if you type "My name is Mary." the Verbot will respond "Good to meet you Mary!" and the
Variable [name] is stored with the value of "Mary." From that moment on, whenever the Verbot finds
the variable [name], it will display "Mary" in the output.

Variables in Variables: "Joe's phone number is 555-5555"
There are times when you want to save information, such as recording your friend's telephone
numbers. To do this, you need to use Variables inside other variables.
Saving Joe's Number, and Jenny's, and John's, and Juan's too!
In the Rules above, you learned how to save a single name (Mary) to a single Variable ([name]).
However, to save multiple phone numbers we'll need multiple Variables. How do you that with a single
Rule? Let's find out.
Rule Name: Save Phone Number
Input: [contactname]'s phone number is [[contactname]s_phone].
Output: I'll try to remember that [contactname]'s phone number is [[contactname]s_phone].
The Rule above contains [contactname] which is a Variable exactly like the [name] Variable we used
before. However, you'll notice that there is another Variable in the Input which uses [contactname]
within itself. [[contactname]s_phone] is a Variable within another Variable. We use the first Variable
"[contactname]" to create a unique variable which can be retrieved by a different Rule.

Verbot 4.0 Manual87
Let's see what happens when you type the following Input: "Joe's phone number is 555-5555."
First, thing that happens is "Joe" is stored within the Variable "[contactname]."
Now that "Joe" is stored within the Variable "[contactname]," the Verbot can then use "Joe" within
another Variable. In this case, "[[contactname]s_phone]" is set to the Variable name of "Joes_phone"
with the value of "555-5555".
So, here is what you end up with:
contactname = "Joe"
joes_phone = "555-5555"
Note that is you typed in the same sentence using a different friend' information, you would get another
unique variable. For example, if you typed in "Jenny's phone number is 555-8888." The Variables
would be as follows:
contactname = "Jenny"
jennys_phone="555-8888"
Notice that contactname is always set to the last Input (Jenny) but a unique variable is created
(jennys_phone).

Retrieving the Variable: "What is Joe's phone number?"
Using the example above - we have two Variables available: joes_phone and jennys_phone. To
access the Variables we create the following Rule:
Rule Name: Get Phone Number
Input: What is [contactname]'s phone number?
Output: [contactname]'s phone number is [[contactname]s_phone].
That's it. Now to access Jenny's number you would type "What is Jenny's phone number?"
Note: It would be a good idea to add other inputs so that it'll match to phrases such as "give me
Jenny's number" or simply "Jenny's number."

Verbot 4.0 Manual89
5.3.1 Internal Variables
Internal Variables.
Assuming you've read the Variables section, you already know that Variables are used to capture
information from within an Input as well as display that captured information later. Internal Variables
are built in functions which can be used to prevent information within a response.
[_time]
[_time24]
[_date]
[_month]
[_dayofmonth]
[_year]
[_dayofweek]
[_input]

[_lastinput]
[_lastoutput]
Pardon me do you have the time? (Time Variables)
The Date and Time Internal Variables allow the Verbot to present the time, date, year, and more within
a response. Listed here are the different Time Variable's and a description of what they present:
Tag: (Used within Verbot Output) Output Format: Example Output: Example
Verbot
Output:
[_time] h:mm tt The time is [_time] "The time is
4:20 PM"
[_time24] HH:mm Wake up soldier it's [_time24] "Wake up
soldier it's
16:20"
[_date] MMM. d, yyyy Today is [_date] "Today is
Jan. 3,
2010"
[_month] MMMM Another beautiful [_month] "Another
beautiful
January"
[_dayofmonth] d Today is day [_dayofmonth] "Today is
day 3"
[_year] yyyy The year is [_year] "The year is
2010"
[_dayofweek] dddd Today is [_dayofweek] "Today is
Saturday"
What did I say? You said [_input]!
[_input]
Prints last User Input within the Verbot response. This tag can also be used to save User Input to other
variables.
Ex.
Rule Name: What did I say?
Input: What did I say?
Output: You said: [_input]
Sample Conversation
User Input: "What did I say?"
Verbot Output: "You said: What did I say?"
What did I say? You said [_lastinput].
[_lastinput]
Prints User's last input before the current input.
Ex.
Rule Name: What did I say?

Verbot 4.0 Manual91
Input: What did I say?
Output: You said: [_lastinput]
Sample Conversation
User Input: "How old are you?"
Verbot Output: "I'm 5 years old."
User Input: "What did I say?"
Verbot Output: "You said: How old are you?"
What did you say? I said [_lastoutput]!
[_lastoutput]
Prints last Verbot response.
Ex.
Rule Name: What did you say?
Input: What did you say?
Output: I said: [_lastoutput]
Sample Conversation
User Input: "How old are you?"
Verbot Output: "I'm 5 years old."
User Input: "What did you say?"
Verbot Output: "I said: I'm 5 years old."
5.3.2 Variables with Alternate Text
I'm sorry I didn't catch that? (Alternate Text Variable)
The Alternate Text Variable allows you assign alternate text in case a variable has not yet been
defined.
[name:alternate text]
Example:
Rule Name: What is my name?
Input: What is my name?
Output: As far as I know, your name is [name:Friend].
In the example above if the User asks "What is my name?", the Verbot will respond in one of two ways
depending on if the Variable name is set.
If the Variable name has been set, the Verbot will respond with the set Variable. For example if name
was previously set to "John", the Verbot will respond with "As far as I know, your name is John"
However, if the Variable name has not been previously set the Verbot will respond with: "As far as I
know, your name is Friend."
5.4 Tags and Inputs
Verbot Standard Edition allows the use of Tags and built Inputs within KnowledgeBases.

· MS Agent Tags
These tags are used to interact with the MS Agent Character. Includes movement and animation
tags.
· Special Inputs
This section covers special Inputs which can be used in KnowledgeBases
· Verbot Tags
Allow your Verbot to interact with Users in dynamic ways.
5.4.1 MS Agent Tags
Tags and Microsoft Agent
Verbot® 4.0 utilizes Microsoft Agent, because of this, not only will you be able to create your own
characters for use with Verbot® 4.0 engine, but you'll also be able to utilize the animation features of
MS Agent.
Note: All Verbot® animation is done with tags that are inserted into Output/Response fields. For example, to make a Verbot®
character smile, simply insert the following: "Here is my smile <agent.play smile>"
Microsoft Agent Tags:
<agent.play animation>
<agent.gestureAt x y>
<agent.moveTo x y speed>
<agent.moveHome>
<agent.pause ms>
<agent.speak text>
Show a little emotion will ya?
<agent.play animation>
Plays the agent animation.
Ex: I really like you.<agent.play quiz>
Animation Available:
Verbot® Character Sylvie® currently has the following animations:
angry
lookaround
quiz
Sad
smile
stickit
wow
Note: these animations are only valid for the character "Sylvie®" . Though you are able to download
any MS Agent and use it with Verbot® 4.0, the animation commands will vary for every character.
This way! No, No. That way!
<agent.gestureAt x y>
Tells the agent to gesture at the given screen coordinates(?).
Ex: Click the Start button.<agent.gestureAt 0 768>
*Verbot® Character Sylvie® does not currently support gestures. To use this feature try the MS Merlin
character.
Move stage left!

Verbot 4.0 Manual93
<agent.moveTo x y speed>
Moves the agent to the given screen coordinates(?).
The moveto command allows you to set screen coordinates for the Verbot® character to move to. Like
the Animation Tags, the moveto tag is inserted into Outputs.
To make the character move, you would insert "<agent.moveto x y s>" where "x" is the x screen
coordinate, "y" is the y screen coordinate, and "s" is the speed in which to move.
Ex.
"I'm going to move up. <agent.moveto 800 600 1>"
or
"<agent.moveTo 0 0 1>Can't catch me!<agent.moveTo 500 400 10>"
Get back here!
<agent.moveHome>
Moves agent back to center of Verbot Player window.
The moveHome command should be used to reposition the agent to the center of Verbot Player
window. The command is usually helpful after using the moveto command above.
How to make a Verbot® relax a little.
<agent.pause ms>
Pauses the agent for the given number of milliseconds.
Ex: My name is<agent.pause 2000> Rex!
Say it, don't text it!
<agent.speak text>
Speaks the given text without displaying it.
Example:
If you were to use the following text within an Output, "The secret word is:" would be displayed in the
out put box.
However, the text "This text will not display in the output box." would only be spoken, but NOT
displayed in the Output box.
The secret word is: <agent.speak This text will not display in the output box.>
5.4.2 Special _Inputs
The following special inputs are used to interact with Verbot 4.0 in a few different ways.
_startup
The "_startup" tag is used within an Input. When Verbot 4.0 first loads it automatically checks to see if
a Rule with the Input "_startup" exists. If so, the Rule is fired. The _startup Input tag is best used to fire
a Rule with startup greetings.
_bored
When the Verbot character becomes idle for an extended period of time, Verbot 4.0 will attempt to fire
the Input "_bored". You can set how long the Verbot must sit idle before the boredom response is
activated from the Verbot 4.0 Interface.

_blank
The _blank Input is used to fire a rule based on an Input that contains no text. For example: if you were
to submit an Input with no text (i.e. by pressing enter) when interacting with the Verbot, this would reply
something like: "To talk to me, you need to type something in the Input box."
5.4.3 Verbot Tags
Read! Run! Send! Verbot Tags add functionality.
The Verbot engine utilizes custom tags used for interacting with the Verbot engine. Tags include
reading text files, running programs, and adding dynamic Rule creation abilities.
Note: All Verbot® tags are inserted into Output/Response fields. For example, to make a Verbot® shut down the Verbot
Interface, simply insert the following: "See ya later! <exit>"
Verbot 4.0 Tags:
<agent.load agentfile>
<exit>
<learn options>
<load knowledgeBase>
<mem.get variable>
<mem.set variable value>
<quit>
<read filename>
<readprint filename>
<run command>
<send text>
5.4.3.1 agent.load
I need a new look!
During interaction with a user, you may want to change the current agent. Using the <agent.load
agentfile> tag allows you to swap between different installed agent characters.
<agent.load agentfile>
This will change the agent to the one you specify with agentfile.
Example:
Output: I'm going to change to Julia. <agent.load julia2004.acs>
The above scripted output will switch to Julia if she isn't already loaded.
5.4.3.2 exit
How do you close a Verbot®? Tell it to quit or exit!
<exit>
Exits the Verbot program.
Ex: Goodbye.<exit>
Note: <exit> and <quit> behave exactly the same making them interchangeable.
5.4.3.3 learn
A KnowledgeBase is a terrible thing to waste!
The learn tag allows the Verbot to dynamically add to a script. For sample Rules please load
Teacher.vkb into the Verbot Scripting Editor. Below are the tags and their use. Some tags are optional.

Verbot 4.0 Manual95
This section will be expanded as this feature set matures. Please log on to our forums if you have
additional questions.
<learn
#file:filename.vkb (optional)
#name:rule name (optional)
#input:keywords
#output:verbot response
#command:command text (optional)
#childof: rulename (optional)
#vchildof: rulename (optional)
#vparentof: rulename (optional)
>
Notes:
· The Learn command can have tags within it
Example:
#output:<send hello>
For more information on tags see: Verbot Tags
· The Learn command (as of version 4.0.5.4) no longer merges rules with same inputs unless the
rulename specified is the same as the merged rule name.
Learning to Learn.
The following is a break down of the required and optional Learn command attributes. Optional tags
add additional functionality, but are not required for the command to operate.
#file (optional)
The optional #file allows you to specify a file name to append knowledge to.
Note: The default KnowledgeBase is learnedKnowledge.vkb
Format:
<learn
#file: filename.vkb
#input: keywords
#output: verbot response
>
#name (optional)
The optional #name allows you to specify a Rule name to create within the learnedKnowledge.vkb. If a
Rule name is not specified the User input will be used as the Rule name if an existing Rule is not
found.
Note: In most cases you should NOT specify a Rule name to allow the Verbot engine to automatically
merge new Inputs with existing like Rules.
Format:
<learn
#name: rule name
#input: keywords
>
#input
The required #input defines the Input keywords that will be used to create the new Rule within the
learnedKnowledge.vkb
Format:

<learn
#input: keywords
>
#output
The required #output defines the Output that will be used to create the new Rule within the
learnedKnowledge.vkb
Format:
<learn
#input: keywords
>
#command (optional)
The optional #command defines the command to run when the newly created Rule is fired.
For more information on using Command see: Running Applications
Format:
<learn
#input: keywords
#command: command text
>
#childof (optional)
The optional #childof defines a Rule name to allow the newly created Rule to be a child of.
For information on Child Rules see: Creating Child Rules
Format:
<learn
#input: keywords
#childof: rule name
>
#vchildof (optional)
The optional #vchildof adds the newly created rule as a virtual child of the given existing rule.
For more information on Virtual Child Rules see: Using Virtual Child Rules
Format:
<learn
#input: keywords
#vchildof: rule name
>
#vparentof (optional)
The optional #vparentof adds the target Rule as a virtual child to the newly created Rule.
Format:
<learn
#input: keywords

Verbot 4.0 Manual97
#vparentof: rule name
>
Note: you can have as many #vchildof or #vparentof lines as you want (one line for each reference to
add)
For more information on using the learning ability see: The Teaching.vkb KnowledgeBase or visit our
forums online.
5.4.3.4 load
I've changed my mind!
The <load knowledgeBase> tag allows you to load a specified KnowledgeBase file. When used in
conjunction with the <agent.load agentfile> command you can change both the character's look and
knowledge.
<load knowledgeBase>
Example:
Output: I'm gong to change my mind! <load julia.ckb>
This will load and select the given KnowledgeBase File. In this example the julia.ckb
KnowledgeBase from My DocumentsVerbot4 will be loaded.
5.4.3.5 mem.get
I'm like an elephant. I never forget.
The mem.get function allows you to get the value of variable and display it in a response.
Format:
<mem.get variable>
Example:
Rule: My dog's name is [dogname]
Input: My dog's name is [dogname]
Output: <mem.get dogname> is a good name for a dog.
Note: <mem.get variableName> behaves like [variableName] within Outputs and can be used
interchangeably.
Sample Dialog:
User: My dog's name is Jack
Verbot: Jack is a good name for a dog.
5.4.3.6 mem.set
I will remember that!
The mem.set function allows you to set a variable to a string, a captured variable, or an exsisting
variable value.
Format:
<mem.set variable value>

Example:
Rule: My dog's name is [dogname]
Input: My dog's name is [dogname]
Output: [dogname] is a good name for a dog. <mem.set hasDog Yes>
Rule: Do I have a dog?
Input: Do I have a dog?
Output: [hasDog:Not that I'm aware of].
Sample Dialog:
User: Do I have a dog?
Verbot: Not that I am aware of.
User: My dog's name is Jack.
Verbot: Jack is a good name for a dog.
User: Do I have a dog?
Verbot: Yes.
5.4.3.7 quit
How do you close a Verbot®? Tell it to quit or exit!
<quit>
Exits the Verbot program.
Ex: Goodbye.<exit>
Note: <quit> and <exit> behave exactly the same making them interchangeable.
5.4.3.8 read
Tell me a story.
<read filename>
The read command allows the Verbot to load a .txt or .rtf file and read it back.
Ex. Let me read something. <read mytextfile.txt>
5.4.3.9 readprint
Don't just say it, print it too!
<readprint filename>
The readprint command allows the Verbot to load a text file and print its content to the Verbot Output
box.
Ex. Let me read something. <readprint mytextfile.txt>
5.4.3.10 run
Open this! Do that! The Run Command.
<run command>
Runs the given windows command. Note: Command can also be a url of a page to open.
Ex: Now launching notepad.<run notepad>
5.4.3.11 send
How to make a Verbot® fire a Rule without Input.
<send text>

Verbot 4.0 Manual99
Is used to fire a Rule using text as the Input within Output.
Example:
Output: "Your answer was correct on that last question. Get ready here comes the next question.
<send nextquestion>"
"nextquestion" is the Input for another Rule. Once the Verbot speaks the text "Your answer was correct
on that last question. Get ready here comes the next question." It sends the Input "nextquestion" to
itself, and fires the Rule that matches to that Input.
6 Glossary
Glossary Index:
· Child Rules
· Compiled KnowledgeBase Files (ckb)
· Inputs
· KnowledgeBase
· Outputs
· Primary Rule
· Rule
· Synonyms
· Verbot
· Virtual Child Rules
· Verbot KnowledgeBase Files (vkb)
6.1 Child Rules
Child Rules are Rules that become available only after a Primary Rule fires.
Child Rules are useful for branching conversations in which you are expecting a follow up Input from
the User, after the previous Verbot response.
For example, the Verbot asks the question "Do you like sports?" The Verbot would be expecting a
"Yes" or "No" Input from the User. By using Child Rules, the Verbot can respond with the appropriate
Output and attempt to better follow the conversation.
For example You have the following two Rules:
"Goodbye" and "Smile for me"
You'll notice below "Smile for me" has two Rules attached to it. "Yes" and "No"

Glossary 100
The "No" and "Yes" Rules are called Child Rules. Because they are attached to "Smile for me," (which
is the Primary Rule) they cannot fire until after "Smile for me" Rule has fired. In other words, if you were
to type the Input "yes" or "no" into the simulator, the Verbot would return the response "No match
found" because the "Smile for me" Rule has not fired yet and thus, it has not enabled the "Smile for
me" Child Rules to fire.

Verbot 4.0 Manual101
However, if you type in the Input "Smile for me" the Verbot will respond with "You want me to smile for
you?".

Glossary 102
Once the "Smile for me" Rule has fired, you can now type "yes" or "no" as an Input, because the Child
Rules are now enabled to fire.

Note that the "Yes" and "No" Rules are only available to match after the "Smile for me" Rule has fired.
If a "Yes" or "No" Rule does match to the next Input by the user Verbot 4.0 will return to searching the
Primary Rules.
6.2 Comma Separated Value (CSV) files
Comma Separated Value (CSV) files
CSV files are a standard export format for many applications, most notably is Microsoft Excel.
6.3 Compiled KnowledgeBase Files (ckb)
What is a Compiled KnowledgeBase File (ckb)?
Compiled KnowledgeBase Files are compiled KnowledgBases created with the Verbot Scripting
Interface. Compiled KnowledgeBase files can be opened in the Free Verbot Player, or Verbot Standard

Glossary 104
Edition. However, vkb files can only be opened within the Verbot Standard Edition.
Learn more about: How to Compile a KnowledgeBase
Learn more about: Verbot KnowledgeBase Files (vkb)
6.4 Expand
The Expand function is used to create a .vkb file from a KnowledgeBase Template and CSV file.
When a KnowledgeBase Template is Expanded a new .vkb file is created based on the
KnowledgeBase Template Rules and the loaded CSV file. Once the KnowledgeBase is Expanded and
the new .vkb file is created, the new .vkb file can be loaded within the Verbot Scripting Editor for
tweaking or to view the results.
6.5 Inputs
An Input is the text string used to match to an incoming query from a user.
For example:
The Verbots KnowledgeBase contains Rules. The screen shot below shows a loaded KnowledgeBase
which contains the Rule "This is a Hello Rule".
You can see that it contains one "Input" with the text string "Hello".

When a user types in "Hello" the Verbot will respond with the Output "Hello! How are you today?"

Glossary 106
As you can see, Inputs are a very important part of Rules. You can also use synonyms as Inputs. For
example, you might want a Rule that fires when a user types "Hello" or "Hi," To create a Rule like this,
you could add two Inputs for that Rule: one Input as "Hello" and one as "Hi."

Also, you can create a synonym file for "hello" that contains both, "hello" and "hi" in "Tools--
>Synonyms". Once you have created the Synonym file, you can just type in "(hello)" in the
Input box and it should match to both "hello" and "hi."

Glossary 108
For more information on Synonym creation see: Part 3 : Creating Synonyms.
For more information on using Synonyms see: Part 4 : Using Synonyms.
For more information on Synonyms see: Synonyms.
6.6 KnowledgeBase
KnowledgeBases are a collection of Rules which contain Inputs and Outputs. The Verbot can load one
or more KnowledgeBase at a time. The order in which KnowledgeBases appear on the list dictates
which Rules have priority.
Related links:
Creating your First Rule
Loading, Testing, and Talking - Oh my!

6.7 KnowledgeBase Template
What is a KnowledgeBase Template?
A KnowledgeBase Template is used to create data driven KnowledgeBases. You first create Rules
which are setup using special tags. Once your Rules are setup you load a CSV file. You may choose to
then Expand or Compile the KnowledgeBase.
For example, a Template Rule might look like this:
Input: What is #Name's phone number?
Output: #Name's phone number is #PhoneNumber.
Related Topics:
· KnowledgeBase Templates and CSV Files
· Creating a CSV file
6.8 Outputs
Rules are made of Inputs and Outputs.
Outputs (also known as Responses) allow the Verbot to react to users queries.
Outputs can contain commands as well as Animation Tags and other Special tags that tell Verbots to
play animations and load programs.
For more information on Animation Tags see: Animation Tags and More
For more information on Commands and Special Tags see: Special _Inputs
6.9 Primary Rule
A Primary Rule is any Rule which is at the root level.

Glossary 110
As you can see Primary Rules can have Child Rules which in turn can have more Child Rules.
6.10 Rule
KnowledgeBases are created from a collection of Rules. Rules contain Inputs and Outputs.
Rules can be Primary Rules or Child Rules.
A Primary Rule has equality with any other Rule to fire based on its Input.
A Child Rule is only eligible to fire after its Primary or "Parent" Rule has fired.
6.11 Synonyms
Verbot 4.0 KnowledgeBases can use Synonym files you create to interchange a word (or words) within
an Input to match to a user's query.

For example, you can create a synonym named "What is". "What is" can contain "What is" and
"What's". If an Input contains the synonym "What is" a user can type "What is" or "What's" to fire a
response.
For example:
Rule: What is your name?
Input: (What is) your name?
Output: My name is Julia.
The user can then type one of the following Inputs to fire the Rule:
What is your name?
or
What's your name?

Glossary 112
6.12 Synonym Output
Verbot 4.0 KnowledgeBases can use Synonym files you create to interchange a word (or words) within
an Input or an Output.
Synonym Outputs are Synonyms used within a Verbot's Response to interchange text.
For example, you can create a synonym named "VerbotRandomThought". "VerbotRandomThought"
can contain "I'm feeling great today." and "Today seems like a great day to chat."
Once you've added alternate Synonym Outputs you can place the Synonym in an Output and the
Verbot will randomly select a phrase from the Synonym Output's list.
For example:
Rule: Hello
Input: hello
Output: (VerbotRandomThought) What would you like to talk about?
Sample Dialog:
User: Hello
Verbot: I'm feeling great today. What would you like to talk about?
User: Hello
Verbot: Today seems like a great day to chat. What would you like to talk
about?
6.13 Verbot
Verbot®? A Verbal Software Robot! :)
6.14 Virtual Child Rules
Virtual Child Rules are used to link one Rule to one or more Rules which may or may not be directly
linked to the selected Rule.
You can use Virtual Children to activate rules that wouldn't normally be available. Normally, Child rules
can only fire right after their parent fires. Virtual Children let you get around that requirement by
creating a Virtual Parent-Child relationship.
To designate a rule as a Virtual Child select the rule that you want to be the parent, then click the "Add
Virtual Children" button, and then check the boxes next to the rules that you want to be able to fire
immediately after the selected rule.
For more information on see: Using Virtual Child Rules
6.15 Verbot KnowledgeBase Files (vkb)
What is a Verbot KnowledgeBase File (vkb)?
Verbot KnowledgeBase Files are XML based files which store the Verbot's knowledge. Verbot
KnowledgeBase Files can only be opened by the Verbot Scripting Interface, or the Verbot Standard
Edition Player.
Note: The Free Verbot Player does not support vkb files. If you are distributing a KnowledgeBase you

have created, you must compile your KnowledgeBase for friends and family who may then download
the Free Verbot Player to interact with your KnowledgeBase.
Learn more about: Compiled KnowledgeBase Files (ckb)
7 Documentation History
This section covers additions and changes to the Verbot Scripting Interface Online Help (This file).
January 24th 2005
· Added [_lastinput] to Internal Variables
· Added new Tags and Inputs Section which now includes MS Agent Tags, Special _Inputs and
Verbot Tags
· Added Internal Variables and Variables with Alternate Text to Variables Section
· Added information on <mem.get variableName> to Advanced Features --> Tags and Inputs -->
Verbot Tags
· Added information on <mem.set variableName value> to Advanced Features --> Tags and Inputs -->
Verbot Tags
· Broke down Verbot Tags in to seperate topics.
· Moved Verbot Tags section to Advanced Features (It didn't really make sense to have it in the How-
To section)
· Moved Variables section to Advanced Features (It didn't really make sense to have it in the How-To
section)
· Moved Internal Variables section to Advanced Features (It didn't really make sense to have it in the
How-To section)
· Moved Variables with Alternate Text section to Advanced Features (It didn't really make sense to
have it in the How-To section)
· Moved MS Agent Tags section to Advanced Features (It didn't really make sense to have it in the
How-To section)
· Moved Special _Inputs section to Advanced Features (It didn't really make sense to have it in the
How-To section)
January 21st 2005
· Fixed bad example in Verbot Tags. Example: <read mytextfile.txt> should have been:
<readprint mytextfile.txt> (Thanks Topdaryl for the catch)
· Fixed bad link from The Teaching.vkb KnowledgeBase to Verbot Tags
· This help file now has a keyword index available. (Click Keyword Index top left side of online manual)
· Added Synonym Output to Glossary Section.
· Fixed spelling errors here and there...
January 20th 2005
· Added missing [_lastoutput] to Internal Variables section
· Added information on #file:filename.vkb (optional)
· Added information on #name:rule name (optional)
· Added information on #input:keywords
· Added information on #output:verbot response
· Added information on #command:command text (optional)
· Added information on #childof: rulename (optional)
· Added information on #vchildof: rulename (optional)
· Added Using Synonyms within an Output to Using Synonyms section
January 17th 2005
· More that 27 typo's fixed. (Thanks goes out to Brandonjb for your valuable input)

Documentation History 114
September 20th, 2004
· Added <agent.load agentfile> tag to Verbot Tags section.
· Added <load knowledgebase> tag to Verbot Tags section.
· Added note that Multiple CSV files can be used within one KnowledgeBase.
· Added Command Line Options section added.
July 8th, 2004
· Fixed example for <agent.pause ms> tag (Thanks! Treehouse for pointing this out :)
· Added Internal Variable section
· Added information on Time Variables
· Added Variables with Alternate Text section
· Added information on Alternate Text Variables
· Added link to Variables with Alternate Text from How To's section
· Added information on <readprint filename> tag to Verbot Tags section.
· Added link to Internal Variables from How To's section
· Added PDF download link to Verbot section
June 24th, 2004
· Added missing links to new features on the Scripting Interface (VSI) page.
· Added explanation of the Expand KnowledgeBase menu item.
· Added Advanced Features topic
· Added KnowledgeBase Templates and CSV File section to Advanced Features section
· Added Creating a KnowledgeBase Template section to Advanced Features section
· Added Creating a CSV file section to Advanced Features section
· Added Expand or Compile section to Advanced Features section
· Added glossary entry for: KnowledgeBase Template
· Added glossary entry for: Comma Separated Value (CSV) files
· Renamed topic: The Verbot Scripting Interface (VS) to Verbot Scripting Interface (Overview)
· Deleted Welcome topic and moved text to Introduction topic
· Added Getting Started topic
· Added quick links to terms and tutorials to Getting Started topic
· Separated MS Agent Tags from Verbot Tags and created them as new sections.
· deleted Animation and more topic due to tag separation.
June 4th, 2004
· Added Glossary Entry for Compiled KnowledgeBase Files
· Added Glossary Entry for Verbot KnowledgeBase Files
· Added new section: The Teaching.vkb KnowledgeBase for the latest features added
· Added new learning tags to Animation Tags and More section
· Added new section How to Compile a KnowledgeBase
· Reorganized Animation Tags and More section
· Renamed Verbot Scripting Interface to How-to's
· Deleted Verbot Scripting Interface Descriptions
· Reorganized The Verbot Scripting Interface (VSI)
· Various documentation link corrections (let me know if you find bad links or missing pages)
June 1st, 2004
· Added new section on for the latest feature: Merge KnowledgeBase
May 20th, 2004
· Added information about new Variable display on Test KnowledgeBase window.
· Decided to move all changes to one page (this one).

May 19th, 2004
· Added section on new "Print KnowledgeBase" feature
· Fixed more spelling errors...Arg!
· Updated links within online *this* Help document
May 17th, 2004
· Added AutoDate to Introduction page - so I don't have to remember to put the last publish date
manually...
May 10th, 2004
· Skin Editor Section: Added information on Speed Slider and Pitch Slider
· Skin Editor Section: Added images of color schemes.
· Updated Older Screen Shots
May 7th, 2004
· Change Online Help from Javascript Driven to Html links (Mozilla had problems)
· Added link on introduction page to download this help file in an executable format.

verbot-4-manual

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (11)

Semelhante a verbot-4-manual

Semelhante a verbot-4-manual (20)

Último

Último (20)

verbot-4-manual