Grundlegendes zu Botkonzepten

Die Interaktionen eines Bots können Text, Sprache, Bilder oder Videos verwenden. Es verarbeitet die Eingaben des Benutzers, um seine Anforderung zu verstehen, und wertet die Eingabe aus, um relevante Aufgaben auszuführen. Ein Bot kann Informationen anfordern oder den Zugriff auf Dienste ermöglichen und dem Benutzer antworten.

Botbereiche

Bots in Microsoft Teams können Teil einer 1:1-Unterhaltung, eines Gruppenchats oder eines Kanals in einem Team sein. Jeder Bereich bietet für Ihren Unterhaltungs-Bot besondere Chancen und Herausforderungen.

In einem Kanal

Kanäle enthalten Threadunterhaltungen zwischen mehreren Personen, sogar bis zu 2000. Dadurch erhält Ihr Bot potenziell eine enorme Reichweite, die einzelnen Interaktionen müssen aber präzise sein. Herkömmliche Multi-Turn-Interaktionen funktionieren nicht. Stattdessen müssen Sie interaktive Karten oder Dialoge (in TeamsJS v1.x als Aufgabenmodule bezeichnet) verwenden oder die Unterhaltung in eine 1:1-Unterhaltung verschieben, um viele Informationen zu sammeln. Ihr Bot hat nur Zugriff auf Nachrichten, bei denen es sich um handelt @mentioned. Mithilfe von Microsoft Graph und Berechtigungen auf Organisationsebene können Sie zusätzliche Nachrichten aus der Unterhaltung abrufen.

Bots funktionieren in einem Kanal in den folgenden Fällen besser:

• Benachrichtigungen, wenn Sie eine interaktive Karte für die Benutzer bereitstellen, die weitere Informationen aufnimmt.
• Feedbackszenarien wie Abstimmungen und Umfragen.
• Ein einzelner Anforderungs- oder Antwortzyklus löst Interaktionen auf, und die Ergebnisse sind für mehrere Mitglieder der Unterhaltung nützlich.
• Soziale/Spaß-Bots, bei denen Sie tolle Katzenbilder erhalten, zufällig einen Gewinner auswählen, usw.

In einem Gruppenchat

Gruppenchats sind Unterhaltungen ohne Threading zwischen drei oder mehr Personen. Sie weisen tendenziell weniger Mitglieder auf als ein Kanal und sind kurzlebiger. Ähnlich wie bei einem Kanal hat Ihr Bot nur Zugriff auf Nachrichten, bei denen er sich direkt befindet @mentioned .

Bots, die in einem Kanal besser funktionieren, funktionieren auch in einem Gruppenchat besser.

In einem 1:1-Chat.

Ein 1:1-Chat ist ein herkömmliches Interaktionsverfahren eines Unterhaltungs-Bots mit einem Benutzer. Einige Beispiele für 1:1-Unterhaltungs-Bots sind:

• F&A-Bots
• Bots, die Workflows in anderen Systemen initiieren.
• Bots, die Witze erzählen.
• Bots, die Notizen erstellen. Überlegen Sie vor dem Erstellen von 1:1-Chatbots, ob eine konversationsbasierte Schnittstelle die beste Möglichkeit ist, Ihre Funktionalität darzustellen.

Aktivitätshandler und Botlogik

Um eine Bot-App zu erstellen, die Ihren Anforderungen entspricht, ist es wichtig, den Microsoft Teams-Aktivitätshandler und die Botlogik zu verstehen. Diese beiden Schlüsselkomponenten arbeiten zusammen, um die Konversationslogik zu organisieren.

• Teams-Aktivitätshandler: Verarbeitet Teams-spezifische Ereignisse und Interaktionen wie Kanalerstellung, Ergänzungen von Teammitgliedern und andere Aktionen, die nur für die Teams-Umgebung gelten. Im Teams SDK v2 werden Handler direkt auf einem App instance registriert und nicht über die Klassenvererbung.

• Botlogik: Das App Objekt enthält die Konversationslogik des Bots und ist dafür verantwortlich, Entscheidungen basierend auf Benutzereingaben zu treffen. Eingehende Aktivitäten werden basierend auf dem Aktivitätstyp und dem optionalen Musterabgleich an den entsprechenden Handler weitergeleitet.

Teams-Aktivitätshandler

Der Aktivitätshandler ist der Kern der Funktionalität eines Bots, der Benutzerinteraktionen verwaltet und verarbeitet. Im Teams SDK v2:

• Sie instanziieren ein App Objekt und registrieren Handler dafür.
• Handler empfangen ein typisiertes Kontextobjekt (IActivityContext in TypeScript, IContext<TActivity> in C#, ActivityContext[TActivity] in Python).
• Antworten und proaktive Nachrichten werden über ctx.reply() oder ctx.send()gesendet.

Wenn ein Teams-Bot eine Aktivität empfängt, leitet das SDK diese über den registrierten Handler weiter. Teams-spezifische Ereignisse (Kanallebenszyklus, Mitgliedsänderungen usw.) werden als eindeutige benannte Ereignisse angezeigt, sodass Sie keine manuelle Überprüfung durchführen channelData.eventType müssen.

Codeausschnitte für Aktivitätshandler

Die folgenden Codeausschnitte zeigen Teams-Aktivitätshandler für Kanal- und Teamlebenszyklusereignisse.

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

Beispiel für bot-Aktivitätshandler

Der folgende Code enthält ein Beispiel für eine Botaktivität:

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())

Botlogik

Botlogik umfasst die grundlegenden Regeln und Entscheidungsframeworks, die die Aktionen und Interaktionen eines Bots diktieren. Es wird beschrieben, wie der Bot Benutzereingaben interpretiert, Antworten formuliert und an Unterhaltungen teilnimmt.

Im Teams SDK v2 verarbeitet die Botlogik eingehende Aktivitäten von einem oder mehreren Botkanälen und generiert ausgehende Aktivitäten. Das gesamte Aktivitätsrouting wird vom App instance behandelt. Sie registrieren die Handler, und das SDK verteilt Aktivitäten automatisch an sie.

Nachdem Sie sich nun mit Botaktivitätshandlern vertraut gemacht haben, lassen Sie uns sehen, wie sich Bots je nach Konversation und den empfangenen oder gesendeten Nachrichten unterschiedlich verhalten.

Empfehlungen

Ein umfangreicher Dialog zwischen Ihrem Bot und dem Benutzer ist ein langsamer und übermäßig komplexer Weg, um eine Aufgabe zu erledigen. Ein Bot, der übermäßige Befehle unterstützt, insbesondere eine breite Palette von Befehlen, wird von Benutzern nicht erfolgreich oder positiv angesehen.

• Vermeiden von Multi-Turn-Erfahrungen im Chat Für einen umfangreichen Dialog muss der Entwickler den Zustand beibehalten. Um diesen Zustand zu beenden, muss ein Benutzer entweder ein Timeout ausführen oder Abbrechen auswählen. Auch der Prozess ist mühsam. Sehen Sie sich beispielsweise das folgende Unterhaltungsszenario an:

  BENUTZER: Plane eine Besprechung mit Marie.

  BOT: Ich habe 200 Ergebnisse gefunden, einschließlich eines Vor- und Nachnamens.

  BENUTZER: Plane eine Besprechung mit Marie Krause.

  BOT: OK, Wann möchten Sie sich mit Marie Krause treffen?

  BENUTZER: um 13:00 Uhr.

  BOT: An welchem Tag?

• Unterstützung von sechs oder weniger häufigen Befehlen Da es nur sechs sichtbare Befehle im aktuellen Botmenü gibt, ist es unwahrscheinlich, dass weitere Befehle in irgendeiner Häufigkeit verwendet werden. Bots, die detailliert auf einen bestimmten Bereich eingehen, anstatt zu versuchen, ein allgemeiner Assistent zu sein, werden besser funktionieren und besser abschneiden.

• Optimieren der Größe von Wissensdatenbank für eine schnellere Interaktion Einer der Nachteile von Bots besteht darin, dass es schwierig ist, einen großen Abruf Wissensdatenbank mit antworten ohne Rang zu verwalten. Bots sind am besten für kurze, schnelle Interaktionen geeignet, nicht für das Durchsuchen langer Listen auf der Suche nach einer Antwort.

Erkunden anderer Botfeatures

Zusätzlich zu herkömmlichen Botfeatures können Sie auch erweiterte Features erkunden, die in einer Teams-Bot-App verfügbar sind:

• Rufen Sie Teams-spezifischen Kontext für Ihren Bot ab.
• Bots für Anrufe und Onlinebesprechungen.
• Aktivieren Sie SSO für Ihre App.

Codebeispiel