O IBM Bluemix é uma oferta de plataforma como serviço (PaaS) baseada em um projeto de código aberto de Cloud Foundry, que promete oferecer funções e serviços em nível empresarial fáceis de integrar aos aplicativos da nuvem.

Trata-se de um leque de sistemas diversos, que vão desde reconhecimento de sentimento, até serviços orientados para deep learning e processamento em grande escala.

Olhando estes serviços mais de perto, existe um deles que é muito trivial, que é o de conversação. Este serviço atende, principalmente, aos chatbots (ou chatterbot), que por sua vez são programas de computador que tentam simular um ser humano na conversação com as pessoas. O objetivo é responder as perguntas de tal forma que as pessoas tenham a impressão de estar conversando com outra pessoa e não com um programa de computador.

Go tem um fit muito bacana para processamento em tempo real, então, este é o casamento perfeito!

Primeiro, vamos nos inspirar nos artigos da própria IBM, que mostra no detalhe como utilizar a ferramenta, desde a criação do Workspace, intenções, entidades e diálogos…

No artigo deste link foi criado na sua versão mais completa uma série de intenções e diálogos com alguns níveis de profundidade.

Por hora, vamos nos focar no básico “Hello Word”. Vamos partir do ponto 0, em que vamos criar um workspace.

Após criar uma conta na ibm bluemix, acesse: https://www.ibmwatsonconversation.com.

Vá em Workspaces -> Create:

Na linguagem escolha português.

Neste exemplo simples de serviço, vamos criar apenas duas intenções:

• Uma para dizer “Olá!”,
• Uma para dizer “Adeus”.

Para o serviço de conversação, uma intenção representa a finalidade da entrada de um usuário. Você pode pensar em intenções como as ações que seus usuários podem querer executar com seu aplicativo.

Verifique se você está na guia “Intents” (você já deve estar lá, se você acabou de criar o workspace). Em seguida, clique em “Create New” e nomeie a intenção como “olaintencao”. Depois digite “Olá” como um exemplo de usuário e pressione “Enter”.

Importante: Esta é a área de treinamento do serviço.

Estes exemplos ensinam ao serviço de conversação que tipos de entrada do usuário você deseja corresponder a esta intenção. Logo, quanto mais exemplos você fornecer, mais preciso será o serviço para reconhecer as intenções do usuário.

Adicione mais alguns exemplos:

• Bom dia
• Boa tarde
• Boa noite
• E aí?

Agora, clique em “Create” para terminar de criar a intenção #olaintencao.

Perfeito! Avance mais um pouco e crie outra intenção chamada #adeusintencao com estes cinco exemplos:

• Adeus
• Até logo
• Tchau
• Fui embora
• Te vejo depois

O resultado deve ser este:

Agora, vamos criar um diálogo para manipular estas intenções.

Uma caixa de diálogo define o fluxo de sua conversação na forma de uma árvore lógica. Cada nó da árvore tem uma condição que aciona com base na entrada do usuário.

Na ferramenta Conversação, clique na guia “Dialog”.

Clique em Criar e você verá um nó:

Digite “conversation_start” no campo “Trigger” deste nó. Em seguida, selecione o início de conversa (Create new condition).

Adicione a resposta, “Bem-vindo a o exemplo de conversação!”. Clique em qualquer lugar fora do nó de diálogo para salvar suas alterações.

Para testar este nó, clique em  no canto superior direito da tela.

Ao abrir o dialogo, você deve ver este nó em ação.

Agora que já ensinamos boas maneiras ao nosso chatbot, vamos adicionar mais nós para fazer com que o diálogo lide com as intenções que o serviço está prevendo tratar, ou seja, #olaintencao e #adeusintencao.

Clique no ícone + abaixo do nó “conversation_start”. Isso cria um nó que é avaliado quando “conversation_start” for falso. Em seguida, no campo “Trigger”, selecione a opção #olaintencao (Create new condition). Depois adicione a resposta: “Bom dia para você.”.

Em seguida, clique no ícone + abaixo do nó “#olaintencao”. Isso cria um nó que é avaliado quando “#olaintencao” for falso. Depois, no campo “Trigger”, selecione a opção #adeusintencao (Create new condition). Adicione a resposta, “OK! Te vejo depois.”.

Devemos ter algo assim:

Para testar este nó, clique em no canto superior direito da tela.

Ao abrir o dialogo, você deve ver estes três nós em ação, digitando “olá”, dando “Enter” e, logo depois, digitando “fui embora”:

Note que o diálogo exibe qual #intenção seu texto digitado foi contextualizado.

Ok, agora vamos ao código…

Vamos utilizar uma biblioteca que facilita a comunicação com as APIs do IBM Watson. Ela é bastante completa e atende quase todos os serviços oferecidos pelo Bluemix.

• Go API documentation @ godoc.org
• Watson Developer Cloud

Vamos utilizar apenas o pacote conversation.

Para criar o nosso chatbot, precisei realizar um pequeno ajuste package conversation, mais precisamente na função Message, no qual existe a necessidade de passar o contexto da mensagem para garantir a continuidade da conversação.

Caso o contexto não seja passado junto a mensagem, a API sempre irá retornar o primeiro nó, não seguindo adiante na conversa.

Caso esta alteração não esteja disponível até o momento da publicação deste artigo, apenas ajuste no seu pacote local “conversation”:

De:

func (c Client) Message(workspace_id string, text string) (MessageResponse, error)

Para:

func (c Client) Message(workspace_id string, text string , ctx map[string]interface{}) (MessageResponse, error)

E mais abaixo:

message := &Message{Input: MessageInput{Text: text}, Context: ctx}

Minha versão está aqui.

Ok, tendo este ajuste, podemos seguir. Primeiro, vamos carregar as credenciais do ambiente Watson:

config := watson.Config{
        Credentials: watson.Credentials{
            Username: "Username",
            Password: "Password",
            Url:      "https://gateway.watsonplatform.net/conversation/api",
        },
    }

Estas credenciais podem ser visualizadas no painel do bluemix clicando em Deploy -> Credentials:

Legal, com as credenciais aplicadas, vamos instanciar o cliente:

client, err := conversation.NewClient(config)
    if err != nil {
        log.Printf("Error: [%s]", err)
    }

Vamos criar uma estrutura que representa o retorno da mensagem recebida pela API durante a conversação:

var messageResponse conversation.MessageResponse

Vamos iniciar a conversa com o chatbot, do mesmo modo que começamos no dialogo do painel, ou seja, não vamos passar mensagem alguma, apenas chamar o serviço para conversar:

messageResponse, err = client.Message("Workspace ID", "", nil)

Bacana, agora vamos criar um simples loop de entrada do terminal para capturar o texto digitado, enviá-lo ao nosso serviço e imprimir na tela o que o serviço retornou de acordo com seu treinamento e com o fluxo do dialogo que estabelecemos.

reader := bufio.NewReader(os.Stdin)
for {

        // lendo entrada do terminal
        texto, _ := reader.ReadString('\n')
        log.Printf("You: %s", texto)

        texto = strings.Replace(texto, "\n", "", -1)
        messageResponse, err = client.Message("Workspace ID", texto, messageResponse.Context)
        if err != nil {
            log.Printf("Error: [%s]", err)
        }

        // escrevendo a resposta do bot no terminal
        log.Printf("Dropabot:  %s", messageResponse.Output)
    }

Pronto, simples e sem mistérios! go run main.go e devemos ter isso no terminal:

Massa, né?! Então, Go é muito divertido; mas com machine learning e IBM Watson é muito mais!

Git: https://github.com/edwardmartinsjr/iMasters-Go/tree/master/go-watson-conversation