摘要
LumaQQ 2005年1月21日的修正中，添加了对聊天机器人的支持。LumaQQ核心层提供了一个简单的接口IRobot来封装机器人功能，同时通过一个配置文件配置机器人的信息。LumaQQ的机器人支持简单，方便，并且支持多种机器人，方便切换。添加新机器人时，只需要拷贝你的jar文件到LumaQQ的lib目录下，重启LumaQQ后即可使用。本文介绍了添加一个机器人的基本步骤，希望对这方面感兴趣的朋友有所帮助。

Luma, 清华大学
更新时间: 2005/01/29

修改历史:
2005-05-24 机器人接口修改

LumaQQ没有提供功能十足的机器人给你用，所以，实现一个机器人需要靠你自己，LumaQQ只为你提供了一个简单的框架，本文就是向你介绍如何在LumaQQ中插入自己的机器人的。

第一步：实现自己的机器人

缺省情况下，LumaQQ提供了一个机器人，但是这个机器人基本上什么也没做，而且，缺省也是没有打开的。这个机器人的代码在edu.tsinghua.lumaqq.qq.robot.DummyRobot.java中，它纯粹是一个演示目的，如果你想看看效果，可以在LumaQQ的xml目录下面找到一个robots.xml文件，这个文件是机器人的配置文件，你可以看到里面我写了一些注释，你把那些注释去掉，保存，然后重启LumaQQ就可以了。使用机器人的方法是打开系统菜单，如果系统配置了至少一个机器人的话，系统菜单中会有一项“聊天机器人”，它的子菜单里面列出了所有存在的机器人，另外包含一个开始/停止菜单，我就不多说了，想来你应该会用。

为了实现一个聊天机器人，你必须实现edu.tsinghua.lumaqq.qq.robot.IRobot接口，这个接口目前相当简单，只包含了一个方法，如下：

public interface IRobot {
	/**
	 * 根据message得到一条回复消息
	 * 
	 * @param packet
	 * 		接受消息包
	 * @return
	 * 		回复的消息，返回null表示不响应这条消息
	 */
	public String getReply(ReceiveIMPacket packet);
}

而DummyRobot的实现则是：

public class DummyRobot implements IRobot {
	/* (non-Javadoc)
	 * @see edu.tsinghua.lumaqq.qq.robot.IRobot#getReply(edu.tsinghua.lumaqq.qq.packets.in.ReceiveIMPacket)
	 */
	public String getReply(ReceiveIMPacket packet) {
		/*
		 * Example:
		 * 1. 如何得到发送者QQ号
		 * packet.header.sender
		 * 
		 * 2. 如何得到消息内容
		 * packet.normalIM.messageBytes是消息的字节数组内容，如果需要得到字符串形式
		 * new String(packet.normalIM.messageBytes, QQ.QQ_CHARSET_DEFAULT)
		 * 对于消息格式，参见edu.tsinghua.lumaqq.qq.beans.NormalIM
		 * 
		 * 3. 如何判断这个消息是一个大消息中的分片？
		 * if(packet.normalIM.totalFragments > 1) {
		 * 		// 做你的处理，怎么处理，你决定，你可以把他缓存起来等待所有分片都收到为止
		 * }
		 * 
		 * 4. 如何知道这个消息的分片序号？
		 * packet.normalIM.fragmentSequence
		 * 
		 * 5. 如何知道这个消息的id？消息id也是用在分片情况时，同一个消息的分片，消息id相同
		 * packet.normalIM.messageId
		 * 
		 * 6. 如何知道一个消息是不是自动回复？
		 * if(packet.normalIM.replyType != QQ.QQ_IM_AUTO_REPLY) {
		 * 		// 做你想做的
		 * }
		 * 
		 * 更多内容和可用字段
		 * 参考edu.tsinghua.lumaqq.qq.beans.NormalIMHeader
		 * 参考edu.tsinghua.lumaqq.qq.beans.ReceiveIMHeader
		 */
		if(packet.normalIM.replyType != QQ.QQ_IM_AUTO_REPLY)
			return "Hello, I am robot";
		else
			return null;
	}
}

所以你也看到了，DummyRobot基本上啥也没干，就是老返回一句相同的话而已，不过它会判断一下是不是自动回复，如果是就不处理了，免得碰到自动回复的时候没完没了。你看到了，DummyRobot里面的有不少注释，应该对你的帮助很直接了。

第二步：部署机器人程序

添加一个机器人并不需要修改LumaQQ的源代码，你只要将你的机器人程序打包成jar文件，然后copy到LumaQQ的lib目录下就可以了，这样的好处自然就是你可以随便添加机器人，而且并不一定需要有LumaQQ的源代码，当然，你在编写你的机器人程序的时候，需要导入lumaqq.jar到工程中，不然找不到IRobot接口定义了。

第三步：修改机器人配置文件

机器人配置文件位于LumaQQ的xml目录下，这个文件自然是新增的，如果不存在这个文件的话，那么LumaQQ就会认为是没有机器人可用，系统菜单中也就不会有机器人的菜单项了。这个文件的格式也很简单，假设我要配置DummyRobot，那么就是下面这个样子：

<?xml version="1.0" encoding="UTF-8"?>
<Robots>
	<Robot>
		<Name>Dummy Robot</Name>
		<Implementation>edu.tsinghua.lumaqq.qq.robot.DummyRobot</Implementation>
	</Robot>
</Robots>

See? 仅仅就是配置一个机器人的名字，另外配置一下IRobot的实现类即可。如果你有多个机器人，你可以随便添加Robot元素

总结

添加一个机器人的工作就结束了，喜欢玩就玩吧。

LumaQQ is a Java QQ client which has a reusable pure Java core and SWT-based GUI

来源：http://lumaqq.linuxsir.org/article/how_to_add_robot.html

前几天利用Smack API(Java XMPP client library)写了一个Google Talk Bot，基本实现了Twitter IM Bot指令，还加了个简单的管理指令，允许指定的管理员查看联系人列表。
不过写完后后悔了，觉得浪费时间，根本不符合国情，用这个Google Talk的人太少了，国内还是QQ和MSN Messenger的天下，甚至还不如写个Skype Bot呢，不过年前时我看Anothr(Skype RSS Bot)好像才1000多个联系人而已，也没啥意思。
写QQ Bot可以利用LumaQQ的Library，写MSN Messenger可以利用Java MSN Messenger Library（都是中国程序员做的，佩服！），不过，我暂时还没有写QQ或MSN Messenger Bot的想法，但那个Google Talk Bot的包结构是这样的：com.terac.talkbot.TalkBotG.java，说不定哪天就有TalkBotQ.java, TalkBotM.java：）
其实IM Bot还是比较容易写的，关键还是看应用，目前比较好的还是国产的小i，Twitter，Renkoo，Imified
顺便说一下维众社区的呻吟（Saying）：虽然它和Twitter的表现形式差不多，但我把呻吟（Saying）设计成是迷你博客与在线博客阅读工具的结合，而不是简单的回答“What are you doing”，也不限于朋友圈内的互动(谢谢foxmachia)。
另外，维众社区的友邻和豆瓣的一样（Mixi更强，包含マイミクシィ和お気に入り两种连接人的方式），是单向的，我加你表示我关注你，比成为朋友关系的成本要低，比朋友圈范围要广。做个假设，如果老徐在维众社区呻吟（Saying），你可以加她为友邻，关注她，但你能期望她也加你为友邻，关注你吗？

来源:http://blog.terac.com/andy/e_1412.html

   我相信大家都看过西游记，但是不知道大家思考过这么一个问题没有：孙悟空为什么不自己搞定妖怪而老是求救？孙悟空号称齐天大圣，72变，本事大是不用置疑，大闹天宫的时候只有如来才可以制服，但是取经路上，碰到几个小妖就搞不定，每次不是求神仙就是求观音求如来！答案只有一个：孙悟空是个自私的老奸巨猾的高手！

　　其中道理我慢慢说来：

　　1、先说自私。大闹天宫的时候，孙悟空是为个人争权力争名号争福利，闹的真是不亦乐乎，那个惊天地泣鬼神，最后还好如来收服了他，要不然估计就要霸占天宫了。有句话说“会哭的孩子有奶吃”，但是哭过头了自然只有吃苦头了，孙悟空大闹天宫的时候还年轻不懂事，就是吃了这个亏，但是还好购聪明，在以后的日子里及时吸取教训，变得异常老奸巨猾，不愧为知错就改的楷模。说远了，大闹天宫是为自己争福利，所以竭尽全力拼了小命地争；但是后来保唐僧去西天取经，这个属于工作性质，所以他就没有那么积极了，没有下血本拼老命了，所以才会求这求那。

 
　　2、为什么要求这求那呢？其实是孙悟空深明关系的作用！不是打不过，实在是不能打不好打，而且还有更好的解决办法。你想想，那些妖怪不是这个神仙的宝贝就是那个菩萨的坐骑，妖怪们手上的独门宝贝其实就是和神仙菩萨门的关系啊，所以威力巨大！关系复杂啊，俗话说“打狗也要看主人”，那个时候天庭就好比政府权力机构和统治阶层啊，孙悟空就是深明这一点，所以才不下手啊，求他们呢，一来给了那些神仙面子，本来没关联，现在联系上了，还攀了点关系，以后好办事啊；二来呢那些神仙也欠他个人情，因为是神仙们的失误，被孙悟空抓住把柄了；三来呢跑一趟动动嘴皮子就可以解决，当然比拼命好多了，而点还可以不时捞点外块，比如吃的啊宝贝啊，这利害关系一对比，就知道其中得失了吧，可见孙悟空不是一般的老奸巨猾。

　　3、未知对方虚实，稳妥为主。孙悟空被压了500年，500年啊，30岁一代也有十七代了，时代变迁，也不知道那些天兵天将啊妖怪啊500年能力提升了多少，不好贸然开打，所以每次看到孙悟空都只是开始的时候装模作样的打打妖怪小兵，一碰到妖怪头就蔫了逃跑了，跑去找管妖怪的神仙去了。所以孙悟空他是深明“不怕官只怕管”这个道理，不是一般的奸诈啊。

　　4、一下就把妖怪头打死，不但会惹恼上头关系，还会造成大群小妖失业，把领导们放在外面的创收机构整没了，这个问题可严重，所以有时候还是要从广大基层小妖考虑，为了不被小妖狗急跳墙惹来不必要的麻烦，为了“群众利益”，所以还是去求吧，还可以获得小妖们的好感，再说还有上面那么多好处等着呢。

　　5、其实最私心的呢是，你唐僧不是没事好坏不分会念紧箍咒整我对吧，我让你也吃吃苦头慢慢来，我去慢慢求啊求，叫你没事念加威胁。而且，万一唐僧挂了，那就更爽了，自己又没事不痛的，还少了个念咒的，还可以回花果山当大王消遥自在，多好啊。

　　从另一个角度来说，制度害死人啊，500年前，无后顾之忧，无拘无束，大闹天宫，能力超水平发挥。500年后，多了一个唐僧累赘，凡事束手束脚，一个小妖小困难就难倒了当年的英雄好汗，再换个角度，官僚形式主义害死人啊。所以创业要趁早，要置之死地而后生，要没有心理负担。

　　这里面，不是教大家奸诈之道，而是有很多可以学习的正面的处世之道和管理之道。

  ※原帖来自于：来福岛爆笑娱乐网http://www.laifu.org

今天看到WLW，测试下好不好用。

AIML Overview

By Dr. Richard S. Wallace

AIML, or Artificial Intelligence Mark-up Language enables people to input knowledge into chat-bots based on the A.L.I.C.E free software technology.

AIML was developed by the Alicebot free software community and I during 1995-2000. It was originally adapted from a non-XML grammar also called AIML, and formed the basis for the first Alicebot, A.L.I.C.E., the Artificial Linguistic Internet Computer Entity.

AIML, describes a class of data objects called AIML objects and partially describes the behavior of computer programs that process them. AIML objects are made up of units called topics and categories, which contain either parsed or unparsed data.

Parsed data is made up of characters, some of which form character data, and some of which form AIML elements. AIML elements encapsulate the stimulus-response knowledge contained in the document. Character data within these elements is sometimes parsed by an AIML interpreter, and sometimes left unparsed for later processing by a Responder.

CATEGORIES

The basic unit of knowledge in AIML is called a category. Each category consists of an input question,an output answer, and an optional context. The question, or stimulus, is called the pattern. Theanswer, or response, is called the template. The two types of optional context are called "that" and"topic." The AIML pattern language is simple, consisting only of words, spaces, and the wildcard symbols _ and *. The words may consist of letters and numerals, but no other characters. The pattern language is case invariant. Words are separated by a single space, and the wildcard characters function like words.

The first versions of AIML allowed only one wild card character per pattern. The AIML 1.01 standard permits multiple wildcards in each pattern, but the language is designed to be as simple as possible for the task at hand, simpler even than regular expressions. The template is the AIML respons or reply. In its simplest form, the template consists of only plain, unmarked text.

More generally, AIML tags transform the reply into a mini computer program which can save data, activate other programs, give conditional responses, and recursively call the pattern matcher to insert the responses from other categories. Most AIML tags in fact belong to this template side sublanguage.

AIML currently supports two ways to interface other languages and systems. The <system> tag executes any program accessible as an operating system shell command, and inserts the results in the reply. Similarly, the <javascript> tag allows arbitrary scripting inside the templates. The optional context portion of the category consists of two variants, called <that> and <topic>. The <that> tag appears inside the category, and its pattern must match the robot’s last utterance. Remembering one last utterance is important if the robot asks a question. The <topic> tag appears outside the category, and collects a group of categories together. The topic may be set inside any template.

AIML is not exactly the same as a simple database of questions and answers. The pattern matching "query" language is much simpler than something like SQL. But a category template may contain the recursive <srai> tag, so that the output depends not only on one matched category, but also any others recursively reached through <srai>.

RECURSION

AIML implements recursion with the <srai> operator. No agreement exists about the meaning of the acronym. The "A.I." stands for artificial intelligence, but "S.R." may mean "stimulus-response," "syntactic rewrite," "symbolic reduction," "simple recursion," or "synonym resolution." The disagreement over the acronym reflects the variety of applications for <srai> in AIML. Each of these is described in more detail in a subsection below:

    (1). Symbolic Reduction: Reduce complex grammatic forms to simpler ones.

    (2). Divide and Conquer: Split an input into two or more subparts, and combine the responses to each.

    (3). Synonyms: Map different ways of saying the same thing to the same reply.

    (4). Spelling or grammar corrections.

    (5). Detecting keywords anywhere in the input.

    (6). Conditionals: Certain forms of branching may be implemented with <srai>.

    (7). Any combination of (1)-(6).

The danger of <srai> is that it permits the botmaster to create infinite loops. Though posing some risk to novice programmers, we surmised that including <srai> was much simpler than any of the iterative block structured control tags which might have replaced it.

(1). Symbolic Reduction

Symbolic reduction refers to the process of simplifying complex grammatical forms into simpler ones. Usually, the atomic patterns in categories storing robot knowledge are stated in the simplest possible terms, for example we tend to prefer patterns like "WHO IS SOCRATES" to ones like "DO YOU KNOW WHO SOCRATES IS" when storing biographical information about Socrates.

Many of the more complex forms reduce to simpler forms using AIML categories designed for symbolic reduction:

<category>
<pattern>DO YOU KNOW WHO * IS</pattern>
<template><srai>WHO IS <star/></srai></template>
</category>

Whatever input matched this pattern, the portion bound to the wildcard * may be inserted into the reply with the markup <star/>. This category reduces any input of the form "Do you know who X is?" to "Who is X?"

(2). Divide and Conquer

Many individual sentences may be reduced to two or more subsentences, and the reply formed by combining the replies to each. A sentence beginning with the word "Yes" for example, if it has more than one word, may be treated as the subsentence "Yes." plus whatever follows it.

<category>
<pattern>YES *</pattern>
<template><srai>YES</srai> <sr/></template>
</category>

The markup <sr/> is simply an abbreviation for <srai><star/></srai>.

(3). Synonyms

The AIML 1.01 standard does not permit more than one pattern per category. Synonyms are perhaps the most common application of <srai>. Many ways to say the same thing reduce to one category, which contains the reply:

<category>
<pattern>HELLO</pattern>
<template>Hi there!</template>
</category>

<category>
<pattern>HI</pattern>
<template><srai>HELLO</srai></template>
</category>

<category>
<pattern>HI THERE</pattern>
<template><srai>HELLO</srai></template>
</category>

<category>
<pattern>HOWDY</pattern>
<template><srai>HELLO</srai></template>
</category>

<category>
<pattern>HOLA</pattern>
<template><srai>HELLO</srai></template>
</category>

(4). Spelling and Grammar correction

The single most common client spelling mistake is the use of "your" when "you’re" or "you are" is intended. Not every occurrence of "your" however should be turned into "you’re." A small amount of grammatical context is usually necessary to catch this error:

<category>
<pattern>YOUR A *</pattern>
<template>I think you mean "you’re" or "you are" not "your."
<srai>YOU ARE A <star/></srai>
</template>
</category>

Here the bot both corrects the client input and acts as a language tutor.

(5). Keywords

Frequently we would like to write an AIML template which is activated by the appearance of a keyword anywhere in the input sentence. The general format of four AIML categories is illustrated by this example borrowed from ELIZA:

<category>
<pattern>MOTHER</pattern>
<template> Tell me more about your family. </template>
</category>

<category>
<pattern>_ MOTHER</pattern>
<template><srai>MOTHER</srai></template>
</category>

<category>
<pattern>MOTHER _</pattern>
<template><srai>MOTHER</srai></template>
</category>

<category>
<pattern>_ MOTHER *</pattern>
<template><srai>MOTHER</srai></template>
</category>

The first category both detects the keyword when it appears by itself, and provides the generic response. The second category detects the keyword as the suffix of a sentence. The third detects it as the prefix of an input sentence, and finally the last category detects the keyword as an infix. Each of the last three categories uses <srai> to link to the first, so that all four cases produce the same reply, but it needs to be written and stored only once.

(6). Conditionals

It is possible to write conditional branches in AIML, using only the <srai> tag. Consider three categories:

<category>
<pattern>WHO IS HE</pattern>
<template><srai>WHOISHE <get name="he"/></srai></template>
</category>

<category>
<pattern>WHOISHE *</pattern>
<template>He is <get name="he"/>.</template>
</category>

<category>
<pattern>WHOISHE UNKNOWN</pattern>
<template>I don’t know who he is.</template>
</category>

Provided that the predicate "he" is initialized to "Unknown," the categories execute a conditional branch depending on whether "he" has been set. As a convenience to the botmaster, AIML also provides the equivalent function through the <condition> tag.

TARGETING

Bot personalities are created and shaped through a cyclical process of supervised learning called Targeting. Targeting is a cycle incorporating client, bot, and botmaster, wherein client inputs that find no complete match among the categories are logged by the bot and delivered as Targets the botmaster, who then creates suitable responses, starting with the most common queries. The Targeting cycle produces a progressively more refined bot personality.

The art of AIML writing is most apparent in creating default categories, which provide noncommittal replies to a wide range of inputs. Here is a very nice example provided found on the alicebot-general mailing list:

User: Where do I find the webpage with Australopithecus?

Alice: Where do you want to find it?

User: Bad Answer Alice, time to Learn a new Line

Alice: How would you answer "Where do I find the webpage with Australopithecus?"

User: I would say: "http://www.ancientskulls.net/australopithecus.html"

Alice: Thanks, human. Try asking me again.

User: Where do I find the webpage with Australopithecus?

Alice: http://www.ancientskulls.net/australopithecus.html

This is a very nice example. This is exactly the same as targeting when the botmaster is the teacher. Or I should say, it is an AIML interface to targeting. Of course this scenario raises many problems, such as how to weed out hackers and other garbage givers, which might mean only turning on the Learn function while in a restricted sandbox, though it is the free labor of many chatters the web that could help the bot grow wise quickly.

That is the crux of the learning problem in a nutshell. It all comes down to editing. Either the botmaster edits good quality replies to begin with, or if the bot is "open to the public" then the teacher has to edit out all the crappy answers supplied by all that "free" labor. My personal view is that, compared with a hypothetical learning machine capable of learning language like a child, the AIML targeting approach is more efficient.

CONTEXT

The keyword "that" in AIML refers to the robot’s previous utterance. Specifically, if the robot responds with a multiple sentence paragraph, the value of that is set to the last sentence in the sequence. The choice of the keyword "that" is motivated by its use in ordinary language:

R: Today is yesterday.

C: That makes no sense.

R: The answer is 3.1412926 approximately.

C: That is cool.

In AIML the syntax <that>...</that> encloses a pattern that matches the robot’s previous utterance. A common application of <that> is found in yes-no questions:

<category>
<pattern>YES</pattern>
<that>DO YOU LIKE MOVIES</that>
<template>What is your favorite movie?</template>
</category>

This category is activated when the client says YES. The robot must find out what is he saying "yes" to. If the robot asked, "Do you like movies?," this category matches, and the response, "What is your favorite movie?," continues the conversation along the same lines.

One interesting application of <that> are categories that enable the robot to respond to knock-knock jokes. The categories:

<category>
<pattern>KNOCK KNOCK</pattern>
<template>Who is there?</template>
</category>

<category>
<pattern>*</pattern>
<that>WHO IS THERE</that>
<template><person/> who?</template>
</category>

<category>
<pattern>*</pattern>
<that>* WHO</that>
<template>Ha ha very funny, <get name="name"/>.</template>
</category>

produce the following dialogue:

C: Knock knock.

R: Who’s there?

C: Banana.

R: Banana who?

C: Knock knock.

R: Who’s there?

C: Banana.

R: Banana who?

C: Knock knock.

R: Who’s there?

C: Orange.

R: Orange who?

C: Orange you glad I didn’t say banana.

R: Ha ha very funny, Nancy.

Internally the AIML interpreter stores the input pattern, that pattern and topic pattern along a single path, like: INPUT <that> THAT <topic> TOPIC.  When the values of <that> or <topic> are not specified, the program implicitly sets the values of the corresponding THAT or TOPIC pattern to the wildcard *.

The first part of the path to match is the input. If more than one category have the same input pattern, the program may distinguish between them depending on the value of <that>. If two or more categories have the same <pattern> and <that>, the final step is to choose the reply based on the <topic>.

This structure suggests a design rule: never use <that> unless you have written two categories with the same <pattern>, and never use <topic> unless you write two categories with the same <pattern> and <that>. Still, one of the most useful applications for <topic> is to create subject-dependent "pickup lines," like:

<topic name="CARS">

<category>
<pattern>*</pattern>
<template>
<random>
<li>What’s your favorite car?</li>
<li>What kind of car do you drive?</li>
<li>Do you get a lot of parking tickets?</li>
<li>My favorite car is one with a driver.</li>
</random>
</template>

Considering the vast size of the set of things people could say that are grammatically correct or semantically meaningful, the number of things people actually do say is surprisingly small. Steven Pinker,in his book How the Mind Works wrote, "Say you have ten choices for the first word to begin a sentence, ten choices for the second word (yielding 100 two-word beginnings), ten choices for the third word (yielding a thousand three-word beginnings), and so on. (Ten is in fact the approximate geometric mean of the number of word choices available at each point in assembling a grammatical and sensible sentence). A little arithmetic shows that the number of sentences of 20 words or less (not an unusual length) is about 1020."

Fortunately for chat robot programmers, Pinker’s calculations are way off. Our experiments with A.L.I.C.E. indicate that the number of choices for the "first word" is more than ten, but it is only about two thousand. Specifically, about 2000 words covers 95% of all the first words input to A.L.I.C.E.. The number of choices for the second word is only about two. To be sure, there are some first words ("I" and "You" for example) that have many possible second words, but the overall average is just under two words. The average branching factor decreases with each successive word.

We have plotted some beautiful images of the A.L.I.C.E. brain contents represented by this graph (http://alice.sunlitsurf.com/documentation/gallery/). More than just elegant pictures of the A.L.I.C.E. brain, these spiral images (see more) outline a territory of language that has been effectively "conquered" by A.L.I.C.E. and AIML.

No other theory of natural language processing can better explain or reproduce the results within our territory. You don’t need a complex theory of learning, neural nets, or cognitive models to explain how to chat within the limits of A.L.I.C.E.’s 25,000 categories. Our stimulus-response model is as good a theory as any other for these cases, and certainly the simplest. If there is any room left for "higher" natural language theories, it lies outside the map of the A.L.I.C.E. brain.

Academics are fond of concocting riddles and linguistic paradoxes that supposedly show how difficult the natural language problem is. "John saw the mountains flying over Zurich" or "Fruit flies like a banana" reveal the ambiguity of language and the limits of an A.L.I.C.E.-style approach (though not these particular examples, of course, A.L.I.C.E. already knows about them). In the years to come we will only advance the frontier further. The basic outline of the spiral graph may look much the same, for we have found all of the "big trees" from "A *" to "YOUR *". These trees may become bigger, but unless language itself changes we won’t find any more big trees (except of course in foreign languages). The work of those seeking to explain natural language in terms of something more complex than stimulus response will take place beyond our frontier, increasingly in the hinterlands occupied by only the rarest forms of language. Our territory of language already contains the highest population of sentences that people use. Expanding the borders even more we will continue to absorb the stragglers outside, until the very last human critic cannot think of one sentence to "fool" A.L.I.C.E..

04/02/2006: Blobsy 2 RC 6 released! Grab it here: Blobsy2 RC6

18/11/2005: This site is under (re)construction. Sections may offer insufficient information or maybe incomplete. Please bear with us while the site is brought up-to-date.

Blobsy is an Open Source MSN Messenger bot, designed for easy setup, flexibility and ease of use. It is highly customizable and adding more functionality is extremely easy. It is freely distributable under the GNU General Public License (GPL).

The current version of Blobsy currently supports the following features:

• Easy setup and configuration
• Runs on Linux and Windows
• MSNP12 support
• Extendable with PHP scripts

Requirements:

• PHP 4.3.0 / 5
• Linux / Windows

　　微软这两个聊天机器人是参考微软的Encarta百科全书和BBC的电视列表来回答问题的。用户可以用这项自动化的服务通过说“hello”并且按照提示进行会话。那些有兴趣的用户可以把encarta@conversagent.com和 bbcbackstage@hotmail.com添加到他们的联系人列表中，这样就可以测试这两个聊天机器人了。

　　BBC的电视列表机器人好像对国内用户用处不大，笔者添加了encarta@conversagent.com，问它：who is michael jordan?它居然回答：目前对这个问题的答案不可用，请给它点时间。不过如果问它某个地方的话，它会在聊天窗口右边用地图显示出这个地方来，以下是笔者问它广州在哪里的答案：

来源：huazi817的BLOG http://blog.sina.com.cn/u/45788636010000v2