Compreender os conceitos do bot

As interações de um bot podem estar a utilizar texto, voz, imagens ou vídeo. Processa a entrada do utilizador para compreender o pedido e avalia a entrada para realizar tarefas relevantes. Um bot pode pedir informações ou ativar o acesso aos serviços e responder ao utilizador.

Âmbitos do bot

Os bots no Microsoft Teams podem fazer parte de uma conversa privadas, um chat em grupo ou um canal em uma equipe. Cada escopo fornece oportunidades únicas e desafios para seu bot conversacional.

Em um canal.

Os canais contêm conversações por tópicos entre várias pessoas, até mesmo até 2000. Isso potencialmente dá ao seu bot um alcance enorme, mas as interações individuais devem ser concisas. As interações multifator tradicionais não funcionam. Em vez disso, tem de procurar utilizar cartões ou caixas de diálogo interativos (referidos como módulos de tarefas no TeamsJS v1.x) ou mover a conversação para uma conversação um-para-um para recolher muitas informações. O bot só tem acesso a mensagens em que é @mentioned. Você pode recuperar mensagens adicionais da conversa usando as permissões do Microsoft Graph no nível da organização.

Os bots funcionam melhor em um canal nos seguintes casos:

• Notificações, em que você fornece um cartão interativo para os usuários obterem informações adicionais.
• Comentários cenários como votações e pesquisas.
• Um único ciclo de solicitação ou resposta resolve interações e os resultados são úteis para vários membros da conversa.
• Bots sociais ou divertidos, em que você obtém uma imagem de gato incrível, escolhe aleatoriamente um vencedor e assim por diante.

Em um chat em grupo

Os chats de grupo são conversas não-encadeadas entre três ou mais pessoas. Tendem a ter menos membros do que um canal e são mais temporários. Semelhante a um canal, o bot só tem acesso a mensagens onde está @mentioned diretamente.

Os bots que funcionam melhor num canal também funcionam melhor numa conversa de grupo.

Chat Privado

O chat privado é a maneira tradicional de um bot de conversação interagir com um usuário. Alguns exemplos de bots de chat ptivado são:

• Bots de P e R
• bots que iniciam fluxos de trabalho noutros sistemas.
• bots que contam piadas.
• bots que tiram notas. Antes de criar chatbots um-para-um, considere se uma interface baseada em conversação é a melhor forma de apresentar a sua funcionalidade.

Processador de atividade e lógica do bot

Para criar uma aplicação de bot que satisfaça as suas necessidades, é essencial compreender o processador de atividades do Microsoft Teams e a lógica do bot. Estes dois componentes principais trabalham em conjunto para organizar a lógica de conversação.

• Processador de atividades do Teams: processa eventos e interações específicos do Teams, tais como a criação de canais, adições de membros da equipa e outras ações exclusivas para o ambiente do Teams. No SDK do Teams v2, os processadores são registados diretamente numa App instância e não através da herança de classes.

• Lógica do bot: o App objeto aloja a lógica de conversação do bot e é responsável por tomar decisões com base na entrada do utilizador. As atividades de entrada são encaminhadas para o processador adequado com base no tipo de atividade e na correspondência de padrões opcionais.

Processador de atividades do Teams

O processador de atividade é o núcleo da funcionalidade de um bot, ao gerir e processar as interações do utilizador. No SDK do Teams v2:

• Instancia um App objeto e regista processadores no mesmo.
• Os processadores recebem um objeto de contexto escrito (IActivityContext em TypeScript, IContext<TActivity> em C#, ActivityContext[TActivity] em Python).
• As respostas e as mensagens proativas são enviadas através de ctx.reply() ou ctx.send().

Quando um bot do Teams recebe uma atividade, o SDK encaminha-a através do processador registado. Os eventos específicos do Teams (ciclo de vida do canal, alterações de membros, etc.) são apresentados como eventos nomeados distintos, pelo que não precisa de inspecionar channelData.eventType manualmente.

Fragmentos de código do processador de atividades

Os fragmentos seguintes mostram os processadores de atividade do Teams para eventos de ciclo de vida do canal e da equipa.

import { App } from '@microsoft/teams.apps';

const app = new App();

app.on('channelCreated', async ({ activity }) => {
  const channel = activity.channelData.channel; // { id, name }
  const team    = activity.channelData.team;    // { id, name }
  // Code logic here
});

app.on('channelDeleted', async ({ activity }) => {
  // Code logic here
});

app.on('channelRenamed', async ({ activity }) => {
  // Code logic here
});

app.on('teamRenamed', async ({ activity }) => {
  // Code logic here
});

app.on('membersAdded', async ({ activity, send }) => {
  for (const member of activity.membersAdded) {
    await send(`Welcome, ${member.name}!`);
  }
});

app.on('membersRemoved', async ({ activity }) => {
  // Code logic here
});

app.on('messageUpdate', async ({ activity }) => {
  // Code logic here
});

app.on('messageDelete', async ({ activity }) => {
  // activity.channelData.eventType === 'softDeleteMessage' for soft deletes
  // Code logic here
});

using Microsoft.Teams.Apps;

var app = new App();

app.OnChannelCreated(async context => {
    var channel = context.Activity.ChannelData.Channel;
    var team    = context.Activity.ChannelData.Team;
    // Code logic here
});

app.OnChannelDeleted(async context => {
    // Code logic here
});

app.OnChannelRenamed(async context => {
    // Code logic here
});

app.OnTeamRenamed(async context => {
    // Code logic here
});

app.OnMembersAdded(async context => {
    foreach (var member in context.Activity.MembersAdded) {
        // Code logic here
    }
});

app.OnMembersRemoved(async context => {
    foreach (var member in context.Activity.MembersRemoved) {
        // Code logic here
    }
});

app.OnMessageUpdate(async context => {
    // Code logic here
});

app.OnMessageDelete(async context => {
    // Code logic here
});

from microsoft_teams.apps import App, ActivityContext
from microsoft_teams.api.activities import ConversationUpdateActivity

app = App()

@app.on_channel_created
async def handle_channel_created(ctx: ActivityContext[ConversationUpdateActivity]):
    channel = ctx.activity.channel_data.channel
    team    = ctx.activity.channel_data.team
    # Code logic here

@app.on_channel_deleted
async def handle_channel_deleted(ctx: ActivityContext[ConversationUpdateActivity]):
    # Code logic here

@app.on_channel_renamed
async def handle_channel_renamed(ctx: ActivityContext[ConversationUpdateActivity]):
    # Code logic here

@app.on_team_renamed
async def handle_team_renamed(ctx: ActivityContext[ConversationUpdateActivity]):
    # Code logic here

@app.on_conversation_update
async def handle_conversation_update(ctx: ActivityContext[ConversationUpdateActivity]):
    if ctx.activity.members_added:
        for member in ctx.activity.members_added:
            await ctx.send(f"Welcome, {member.name}!")
    if ctx.activity.members_removed:
        # Code logic here

@app.on_edit_message
async def handle_edit_message(ctx: ActivityContext):
    # Code logic here

@app.on_soft_delete_message
async def handle_soft_delete_message(ctx: ActivityContext):
    # Code logic here

@app.on_undelete_message
async def handle_undelete_message(ctx: ActivityContext):
    # Code logic here

Exemplo de processador de atividade de bot

O código seguinte fornece um exemplo de uma atividade de bot:

import { App } from '@microsoft/teams.apps';

const app = new App();

app.on('message', async ({ activity, reply }) => {
  const senderName = activity.from.name;
  await send(`Hello <at>${senderName}</at>.`);
});

app.start().catch(console.error);

using Microsoft.Teams.Apps.Activities;
using Microsoft.Teams.Apps.Extensions;
using Microsoft.Teams.Plugins.AspNetCore.DevTools.Extensions;
using Microsoft.Teams.Plugins.AspNetCore.Extensions;

var builder = WebApplication.CreateBuilder(args);
builder.AddTeams().AddTeamsDevTools();
var app = builder.Build();
var teams = app.UseTeams();

teams.OnMessage(async (context, cancellationToken) =>
{
    var senderName = context.Activity.From.Name;
    await context.Send($"Hello <at>{senderName}</at>.", cancellationToken);
});

app.Run();

import asyncio
from microsoft_teams.apps import App, ActivityContext
from microsoft_teams.api import MessageActivity

app = App()

@app.on_message
async def handle_message(ctx: ActivityContext[MessageActivity]):
    sender_name = ctx.activity.from_property.name
    await ctx.send(f"Hello <at>{sender_name}</at>.")

if __name__ == "__main__":
    asyncio.run(app.start())

Lógica do bot

A lógica do bot incorpora as regras fundamentais e as estruturas de tomada de decisões que ditam as ações e interações de um bot. Descreve como o bot interpreta a entrada do utilizador, formula respostas e participa em conversações.

No SDK v2 do Teams, a lógica do bot processa as atividades recebidas de um ou mais canais de bot e gera atividades de saída. Todo o App encaminhamento de atividade é processado pela instância – regista os processadores e o SDK envia atividades para os mesmos automaticamente.

Agora que se familiarizou com os processadores de atividade de bots, deixe-nos ver como os bots se comportam de forma diferente consoante a conversação e as mensagens que recebe ou envia.

Recomendações

Uma caixa de diálogo extensa entre o bot e o usuário é uma maneira lenta e complexa de concluir uma tarefa. Um bot que suporta comandos excessivos, especialmente uma vasta gama de comandos, não é bem-sucedido ou visto positivamente pelos utilizadores.

• Evitar experiências multi-turn no chat Uma caixa de diálogo extensa requer que o programador mantenha o estado. Para sair deste estado, um utilizador tem de exceder o limite de tempo ou selecionar Cancelar. Além disso, o processo é entediante. Por exemplo, consulte o seguinte cenário de conversa:

  USER: Agende uma reunião com Sara.

  BOT: Encontrei 200 resultados, incluindo o nome próprio e o apelido.

  USER: Agende uma reunião com Sara Melo.

  BOT: OK, a que hora você gostaria de se encontrar com Sara Melo?

  USUÁRIO: 13h.

  BOT: Em qual dia?

• Suportar seis ou menos comandos frequentes Uma vez que existem apenas seis comandos visíveis no menu de bot atual, é pouco provável que sejam utilizados com qualquer frequência. Bots que se aprofundam em uma área específica em vez de tentar ser um amplo trabalho de assistente funcionam melhor.

• Otimizar o tamanho do base de dados de conhecimento para uma interação mais rápida Uma das desvantagens dos bots é que é difícil manter uma grande base de dados de conhecimento de obtenção com respostas não classificadas. Os bots são mais adequados para interações rápidas e curtas e não passam por listas longas em busca de uma resposta.

Explorar outras funcionalidades do bot

Além das funcionalidades de bot convencionais, também pode explorar funcionalidades avançadas disponíveis numa aplicação de bot do Teams:

• Obtenha contexto específico do Teams para o seu bot.
• Bots de chamadas e reuniões online.
• Ative o SSO para a sua aplicação.

Exemplo de código