What's new in AIML 2.0

Bot Libre now supports the AIML 2.0 draft specification. AIML 2.0 is the second release of a standard XML specification designed for scripting chat bot responses. The AIML 2.0 draft was released in 2013, and last updated in 2014. AIML is supported by many different chat bot programs and hosting services. BOT libre supports all of the AIML 2.0 draft tags and a few common extensions.

About AIML

AIML defines how a bot should respond to a question using <pattern> and <template> elements. A pattern represents the user's question, and the template defines the bot's response. The pattern and template elements are grouped in a category element, which can be grouped under topic elements.

Here is a simple "Hello World" AIML example:
<aiml> <category> <pattern>HELLO WORLD</pattern> <template>Hello to you too</template> </category> </aiml>
This code will make your bot respond with "Hello to you too" to the question "Hello World".

For more information on AIML 1.0 see Scripting your bot with AIML

What's new in AIML 2.0

AIML 2.0 defines many new template tags, as well as now allowing some tags to be used in patterns. AIML 2.0 also adds new pattern wildcards, and some different element usages.

Here is the list of new AIML 2.0 features.

• category topic tags - The <topic> tag can now be set on a category to make it easier to add categories to topics.
• zero or more wildcards - New ^ and # pattern wildcards that match zero or more words.
• pattern priority - New $ pattern marker to make a pattern word match highest priority.
• attribute tags - Any template tag attribute can now be set using a sub-element.
• sets - New pattern side <set> tag to evaluate a pattern based on words defined in a predefined set.
• maps - New template <map> tag to allow the lookup of the element value in a predefined mapping, returning the mapped value.
• condition patterns - wildcards can now be used in condition values to provide default conditions.
• condition loops - New template <loop> tag to loop a conditional statement.
• local variables - New <var> attribute for variables scoped to a category
• remote requests - New template <sraix> tag to make a remote request of another bot instance, or service.
• normalization and denormalization - New <normalize> and <denormalize> tags to convert special character into words, and back again.
• date formats - New formatting options for dates.
• request - New template <request> tag to return the user's previous input request.
• response - New template <response> tag to return the bot's previous response.
• learning - New template <learn>, <learnf>, and <eval> tags to dynamically train a bot with new responses.
• explode - New template <explode> tag to split a word into its characters.
• mobile tags - New <oob> (out of band) tag to support client and mobile device commands.

AIML 2.0 Patterns

AIML 2.0 adds new wildcards, special characters, and now allows the usage of some tags inside patterns.

Patterns in AIML are normally defined as all uppercase, but Bot Libre automatically ignores case, so patterns can be defined as lowercase or mixed. Bot Libre also allows for special characters in patterns such as +, %, ?, etc.

^ and # Wildcards

New ^ and # pattern wildcards that match zero or more words. This makes it easy to define keyword patterns such as:
<category> <pattern>^ aiml ^</pattern> <template>AIML is cool.</template> </category> <category> <pattern>^ chat bot^</pattern> <template>Yes, I am a chat bot.</template> </category>

$ Priority

The new $ pattern marker can be used to make a pattern word match highest priority. The main purpose of this is to allow patterns to take priority over _ and # wildcards. _ and # have odd semantics and should normally be avoided as they can easily lead to loops and block other patterns. _ and # can be useful for things like profanity filters:
<category> <pattern># sex #</pattern> <template>I'm not that kind of bot.</template> </category> <category> <pattern>$what is your sex</pattern> <template>I am female.</template> </category>

() and [] Lists

List support is not part of AIML 2.0. But Bot Libre now supports some syntax from ChatScript. Brackets can be used in a pattern to define a required set of words, or optional set of words. (round) brackets are used to define an optional set of words, and [square] brackets are used to define a required set of words.
<category> <pattern>do [you u] (really) [like love luv lv] me</pattern> <template>Yes, I love you.</template> </category>

Sets

The new <set> pattern tag can be used to match a word from a predefined set of words. This allows wildcards to be defined for specific types, such as numbers, verbs, places, animals, etc.
<category> <pattern>I am <set>name</set></pattern> <template>Pleased to meet you <star/>.</template> </category> <category> <pattern><set>number</set> + <set>number</set></pattern> <template><srai>addition <star/> <star index="2"/></srai></template> </category>

In Bot Libre sets are not stored in files like other AIML implementations. AIML is a text processing language, but Bot Libre is object, or knowledge oriented. Each bot has its own object oriented knowledge base that stores all of its responses, and knowledge. Each word is represented by a meaning knowledge object in the bot's knowledge base. Knowledge objects can have relationships to any other knowledge objects, including their classification types. A word's meaning is defined through the #meaning relationship, and a knowledge object's type is defined through the #instantiation relationship.

The set operation in Bot Libre basically checks if the type of the word's knowledge object matches the set value. This allows for a knowledge object to be added to any set through setting its #instantiation relationship. This can be done using Self scripts, the AIML map tag, and is done automatically for numbers, basic types, and words or data loaded from Wiktionary, Wikidata, or Freebase.

Response list script to set a knowledge object's type:
script: associate "dog" to #dog by #meaning script: associate "doggy" to #dog by #meaning script: associate #dog to #animal by #instantiation script: associate "cat" to #cat by #meaning script: associate #cat to #animal by #instantiation

AIML template to set a knowledge object's type:
<category> <pattern>load animals</pattern> <template> <think> <map name="meaning" value="dog">dog</map><map name="instantiation" value="animal"><map name="meaning">dog</map></map> <map name="meaning" value="dog">doggy</map> <map name="meaning" value="cat">cat</map><map name="instantiation" value="animal"><map name="meaning">cat</map></map> </think> </template> </category>

Pattern tags

Tags such as <bot> can now be used in patterns. AIML 2.0 only requires some tags be usable in patterns, but Bot Libre allows most tags to be used. Using tags in patterns lets you define some pretty creative patterns.
<category> <pattern><bot name="name"/></pattern> <template>Yes, that's my name.</template> </category> <category> <pattern>I am <bot name="age"/></pattern> <template>That is my age too.</template> </category> <category> <pattern><request index="2"/></pattern> <template>You are repeating yourself.</template> </category> <category> <pattern><response/></pattern> <template>Please don't repeat me.</template> </category>

AIML 2.0 Templates

AIML 2.0 adds many new tags, and some new semantics that let you do some pretty powerful things.

Attributes as elements

Tag attributes such as name, value or index on tags like bot, get, set, or condition, can now be defined as XML sub-elements instead of XML attributes. This may not seem like a big difference, but it allows for other AIML tags to be evaluated inside the attributes. This is a very powerful feature, and lets you define much more dynamic AIML.
<category> <pattern>My * is *</pattern> <template>I will remember that your <star/> is <star index="2"/><think><set><name><star/></name><star index="2"/></set></think></template> </category> <category> <pattern>What is my *</pattern> <template>Your <star/> is <get><name><star/></name></get></template> </category>

Maps

The new <map> tag can be used to lookup the value for a word in a predefined mapping. This allows for easy mapping between values.
<category> <pattern>what is the capital of <set>country</set></pattern> <template>The capital of <star/> in <map name="capital"><star/></map>.</template> </category>

In Bot Libre maps are not stored in files like other AIML implementations. AIML is a text processing language, but Bot Libre is object, or knowledge oriented. Each bot has its own object oriented knowledge base that stores all of its responses, and knowledge. Each word is represented by a knowledge object in the bot's knowledge base. Knowledge objects can have relationships to any other knowledge objects. The map operation in Bot Libre basically looks up the relationship on the knowledge object.

Bot Libre extends the map operation to also allow setting the map value. This will set the value of a relationship on the knowledge object.

<category> <pattern>the opposite of * is *</pattern> <template>Okay, the opposite of <star/> is <star index="2"/>. <think><map name="opposite"><value><star index="2"/></value><star/></map></think> </template> </category> <category> <pattern>what is the opposite of *</pattern> <template>the opposite of <star/> is <map name="opposite"><star/></map> </template> </category>

Conditions and Loops

Conditions now allows values to use patterns. This makes it easy to define default cases.

The new <loop> tag can be used to loop a conditional block. This allows for programmatic scripts to be defined similar to a programming language. This lets you do some pretty powerful things, even mathematics. However, XML is not an ideal programming language, on Bot Libre if you are using complex conditions and loops, it is normally better to use Self scripting, instead of AIML, as Self has similar syntax to other programming languages.
<category> <pattern>count down from <set>number</set></pattern> <template> <think><set var="count"><star/></set></think> <condition var="count"> <li value="5"><think><set var="count">4</set></think>5 <loop/></li> <li value="4"><think><set var="count">3</set></think>4 <loop/></li> <li value="3"><think><set var="count">2</set></think>3 <loop/></li> <li value="2"><think><set var="count">1</set></think>2 <loop/></li> <li value="1"><think><set var="count">0</set></think>1 </li> </condition> </template> </category> <category> <pattern>what is <set>number</set> + <set>number</set></pattern> <template> <think> <set var="result"><star/></set> <set var="count">0</set> </think> <condition var="count"> <li><value><star index="2"/></value></li> <li> <think> <set var="result"><map name="word"><map name="next"><map name="meaning"><get var="result"/></map></map></map></set> <set var="count"><map name="word"><map name="next"><map name="meaning"><get var="count"/></map></map></map></set> </think> <loop/> </li> </condition> The answer is <get var="result"/> </template> </category>

Learning

The new <learn> and <learnf> tags allow the bot to learn new response. The difference between the two is that for learn the new response is only remembered for the conversation, and for learnf the new response will be remembered persistently. However, in Bot Libre everything is always persistent, so both tag will learn persistently.

The learn tag takes a new <category> element as its content. The category can contain a <pattern>, <template>, <that>, and <topic> element. learn uses the <eval> tag to distinguish between tags that should be evaluated, and tags that should be part of the new category elements.
<category> <pattern>learn question * answer *</pattern> <template> <think> <learn> <category> <pattern><eval><star/></eval></pattern> <template><eval><star index="2"/></eval></template> </category> </learn> </think> Okay, I will answer "<star index="2"/>" to "<star/>" next time </template> </category> <category> <pattern>wrong</pattern> <template>What should I have said?</template> </category> <category> <pattern>*</pattern> <that>what should I have said</that> <template> <think> <learn> <category> <pattern><eval><input index="3"/></eval></pattern> <template><eval><star/></eval></template> </category> </learn> </think> Okay, I will answer "<star/>" to "<input index="3"/>" next time </template> </category>

Remote requests

The new <sraix> tags allow the bot perform a remote request of another bot or service. sraix is similar to the srai tag that recursively evaluates the element text as if it were a question. However, sraix does not have the bot evaluate the question locally, but instead asks another bot or service the question. This is probably the coolest new feature of AIML 2.0, and opens up the whole chat bot world. Bots can now talk to other bots, and find things through web services.

sraix is a very cool feature, but not very useful on its own, as you need other bots to talk to, and services to make use of. Unfortunately AIML only defines the tag, it does not define a standard web API for requests, or define a standard set of services. Fortunately Program AB the AIML 2.0 reference implementation does define a sraix web API. Bot Libre supports both calling this API, and supports this API on our servers. So you can now sraix any Program AB web API compatible bot or service, and any Program AB web API compatible bot or service can request any Bot Libre bot.

AIML 2.0 defines the Pannous service as being the default for any sraix request. Pannous is a virtual assistant service that can answer a wide variety of questions, such as weather, definitions, math, and much more.

Bot Libre also provides several other services:

• freebase - Lookup definitions and data on Freebase an online knowledge base from Google.
• wikidata - Lookup definitions and data on Wikidata an online knowledge base from Wikimedia.
• wiktionary - Lookup words and definitions on Wiktionary an online dictionary.

sraix supports several attributes to define the bot or service request:

• bot - The name of the bot to access (normally it is better to access a bot by its ID).
• botname - Bot Libre also supports botname in place of bot, as bot is already a tag, so botname is better to use as a sub-element.
• botid - The ID of the bot to access.
• server - The domain name, or IP address of the server to access (default is "www.botlibre.com").
• service - The service to access ("pannous", "freebase", "wikidata", "wiktionary"). Not used if accessing a bot.
• apikey - Some services or servers may require an API key to access the service. For Bot Libre, use you user API key.
• hint - Some services may support a hint. For Wikidata and Freebase the hint can be used to lookup a data element, such as a country's capital, or person's parents.
• default - If the service request fails, the default response can be used.

sraix opens the door to the world, but be careful with your usage. Do not spam another bot with requests, or make use of any service that violates it terms of service, and use an API key when required.
<category> <pattern>ask * about *</pattern> <template><star/> says "<sraix default="Timeout or max anonymous API calls exceeded"><botname><star/></botname><star index="2"/></sraix>"</template> </category> <category> <pattern>ask pandorabot * about *</pattern> <template><star/> says "<sraix server="http://www.pandorabots.com" default="Timeout or max anonymous API calls exceeded"><botid><star/></botid><star index="2"/></sraix>"</template> </category> <category> <pattern>ask pandorabot chomsky about *</pattern> <template>He says "<sraix server="http://www.pandorabots.com" botid="b0dafd24ee35a477" default="Timeout or max anonymous API calls exceeded"><star/></sraix>"</template> </category> <category> <pattern>wikidata *</pattern> <template><sraix service="wikidata" default="Timeout or missing data"><star/></sraix></template> </category> <category> <pattern>wikidata * hint *</pattern> <template><sraix service="wikidata" default="Timeout or missing data"><hint><star index="2"/></hint><star/></sraix></template> </category> <category> <pattern>freebase *</pattern> <template><sraix service="freebase" default="Timeout or missing data"><star/></sraix></template> </category> <category> <pattern>freebase * hint *</pattern> <template><sraix service="freebase" default="Timeout or missing data"><hint><star index="2"/></hint><star/></sraix></template> </category> <category> <pattern>wiktionary *</pattern> <template><sraix service="wiktionary" default="Timeout or missing data"><star/></sraix></template> </category>

Out of bound tags

Out of band tags let you pass tags or commands to the bot client. The client could make use of the tags to control its avatar, or execute services on a phone or mobile device.

Bot Libre's web and mobile SDKs do not currently support oob tags, so oob tags are not currently supported.

Category Reference

For reference, here is the complete set of AIML category tags.

• <pattern> - question pattern
• <template> - response template
• <topic> - category topic
• <that> - previous response pattern

Pattern Reference

For reference, here is the complete set of AIML patterns tags and characters.

• * - matches one or more words
• _ - matches one or more words, takes priority over all other words and wildcards, except $
• ^ - matches zero or more words
• # - matches zero or more words, takes priority over all other words and wildcards, except $
• $ - marks word as taking priority over all other words and wildcards including _ and #
• <set> - matches a set of words
• <bot name="XXX"/> - replaced by the value of the bot specific variable
• template tags - Bot Libre supports most template tags inside a pattern (Bot Libre extension)
• () - optional set of words (Bot Libre extension)
• [] - required set of words (Bot Libre extension)
• {} - Self code (Bot Libre extension)

Template Reference

For reference, here is the complete set of AIML template tags.

• <star index="N"/> - replaced with value of * in pattern (or Nth *)
• <that index="M,N"/> - replaced with value of bot's previous response (or Mth previous response, and N sentence of the response)
• <input index="N"/> - replaced with value of users's input (or Nth *)
• <request index="N"> - replaced with value of user's input request (or Nth *)
• <response> - replaced with value of bot's previous response (or Nth *)
• <thatstar index="N"/> - replaced with value of * in "that" (or Nth *)
• <topicstar index="N"/> - replaced with value of * in topic (or Nth *)
• <get name="XXX"/> - replaced by the value of the conversation specific variable
• <set name="XXX"> - set the value of a variable
• <get var="XXX"/> - replaced by the value of the local variable
• <set var="XXX"> - set the value of a local variable
• <bot name="XXX"/> - replaced by the value of the bot specific variable
• <map name="XXX"> - lookup element value in a predefined mapping, returning the mapped value
• <map name="XXX" value="XXX"> - set the map value (Bot Libre extension)
• <person2/> - converts the text (or <star/>) between 1st and 2nd person (I <-> he, etc.)
• <person/> - converts the text (or <star/>) between 1st and 3rd person (I <-> you, etc.)
• <gender/> - converts the text (or <star/>) between male and female (he <-> she)
• <date/> - replaced with the current date and time, "format", and "jformat" attributes are also supported
• <id/> - replaced by the client id
• <size/> - replaced with the size of bot's memory
• <version/> - replaced with the AI engine version
• <uppercase> - converts the text to uppercase
• <lowercase> - converts the text to lowercase
• <formal> - converts all words in the text to be capitalized
• <sentence> - converts the first word in the text to be capitalized
• <normalize> - convert special character into words
• <denormalize> - convert special character words back to characters
• <explode> - split a word into its characters
• <condition name="X" value="Y"> - defines an "if" condition based on comparing the value of a variable to a pattern
• <condition name="X"> - case statement
• <condition var="X"> - local variable case statement
• <condition> - multi-valued if/else statement
• <random> - choose on of the nested <li> values at random
• <li name="X" value="Y"> - used in random and condition tags
• <li value="Y"> - used in random and condition tags
• <li> - used in random and condition tags
• <gossip> - logs the text
• <srai> - recursively evaluates the text and replaces it with the response
• <sr/> - short form for <srai><star/><srai> (replaced with response to value of * from pattern)
• <sraix bot="name" botid="id" server="url" service="name" apikey="key" limit="int" default="response" > - remote bot or service request
• <think> - evaluates the nested statements but does not output any result
• <learn>, <learnf> - learn a new response
• <eval> - evaluate the element inside a learn category element
• <system> - executes a OS command (Bot Libre does not allow this)
• <javascript> - executes JavaScript code
• <oob> - out of band tags (Bot Libre does not currently support this)
• HTML - various HTML tags are also allowed (<b>, <a>, <i>, <ul>, <li>, <p>, <br>)
• {} - Self code (Bot Libre extension)

AIML in Bot Libre

BOT libre supports both importing and exporting AIML. AIML can be imported in two different ways, either as a program script, or as a chat log.

Importing AIML as a program script is done from the Scripts page. You can import and order the script with respect to your other scripts files. Scripts can be defined in either AIML or Self.

When you import an AIML file, it will be converted to Self code, and stored in your bot's brain along with all of its other information. The Self syntax for AIML is a hybrid syntax that uses AIML terminology, but with the Self scripting structure. Self is an object/knowledge/state oriented language. Self is very different than AIML, but can process any AIML code similar to any other AIML interpreter. AIML imported as a program script will be executed similar to any other AIML interpreter.

Here is the Self code for an imported AIML script:
State:OrExample { pattern Pattern:"* or *" template Formula:"{srai :star} and {srai (get #word from :star at 2)}"; pattern Pattern:"do you like *" template Formula:"I love {:star}"; }

Importing AIML as a chat log allows the AIML categories to be integrated into the bot's knowledgebase. The pattern/template categories from the AIML file will be merged along with the bot's other question/response pairs that it has learned through training, conversation, correction, or importing.

The bot will not run the AIML script as a script, it will decide for itself when to use the response using a heuristic algorithm. The bot will choose its response based on how well the question matches the responses question, the responses correctness, and the context. Even without a * in a pattern it still may be matched to a similar question, if it is the best match available. This frees you from having to write a pattern for every possible phrase, by just letting the bot figure it out.

Using AIML in Twitter, Facebook, Email, and IRC Bots

AIML can be used to script Twitter, Facebook, Email, or IRC bots, the same as bots trained through other mechanisms. AIML templates and patterns can be used anywhere other response are. AIML can be used from the Training page, used in correction in the Chat Logs page, or used for autotweets in the Twitter page.

Self 2.0

Bot Libre's AIML 2.0 support is implemented by translating AIML into Self. Self 2.0 provides many new extensions to support the AIML 2.0 feature set, as well as a lot more functionality than is not available in AIML.

AIML Resources

One of the main benefits of the AIML standard, is that there are a lot of AIML resources on the Internet. The are resources for both learning AIML, and there are many freely available AIML scripts for many domains, and in many different languages.

• AIML - Wikipedia
• AIML - ALICE Foundation
• AIML 1.0.1 Spec
• AIML 2.0 Draft Spec
• Scripting your bot with AIML - Bot Libre
• AIML Documentation - ALICE Foundation
• AIML scripts - Bot Libre
• AIML scripts - ALICE Foundation
• ALICE AIML - Google code

AIML 2 Demo

To see what AIML 2.0 is capable of, try out the AIML 2 Bot on BOT libre.

• AIML2 Bot