Générer avec la bibliothèque d’IA Teams
La bibliothèque d’IA Teams simplifie la création d’applications Microsoft Teams intelligentes avec des composants IA. Il propose des API pour l’accès aux données et la création d’une interface utilisateur personnalisée. Vous pouvez facilement intégrer la gestion des invites et la modération de la sécurité, et créer des bots à l’aide d’OpenAI ou d’Azure OpenAI pour une expérience pilotée par l’IA.
Configuration initiale
La bibliothèque d’IA Teams repose sur le Kit de développement logiciel (SDK) Bot Framework et utilise ses principes fondamentaux pour offrir une extension aux fonctionnalités du Kit de développement logiciel (SDK) Bot Framework. Dans le cadre de la configuration initiale, il est important d’importer les fonctionnalités du Kit de développement logiciel (SDK) Bot Framework. La classe d’adaptateur qui gère la connectivité avec les canaux est importée à partir du Kit de développement logiciel (SDK) Bot Framework.
using Microsoft.Teams.AI;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Builder.Integration.AspNet.Core;
using Microsoft.Bot.Connector.Authentication;
using Microsoft.TeamsFx.Conversation;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddHttpClient("WebClient", client => client.Timeout = TimeSpan.FromSeconds(600));
builder.Services.AddHttpContextAccessor();
// Prepare Configuration for ConfigurationBotFrameworkAuthentication
var config = builder.Configuration.Get<ConfigOptions>();
builder.Configuration["MicrosoftAppType"] = "MultiTenant";
builder.Configuration["MicrosoftAppId"] = config.BOT_ID;
builder.Configuration["MicrosoftAppPassword"] = config.BOT_PASSWORD;
// Create the Bot Framework Authentication to be used with the Bot Adapter.
builder.Services.AddSingleton<BotFrameworkAuthentication, ConfigurationBotFrameworkAuthentication>();
// Create the Cloud Adapter with error handling enabled.
// Note: some classes expect a BotAdapter and some expect a BotFrameworkHttpAdapter, so
// register the same adapter instance for all types.
builder.Services.AddSingleton<CloudAdapter, AdapterWithErrorHandler>();
builder.Services.AddSingleton<IBotFrameworkHttpAdapter>(sp => sp.GetService<CloudAdapter>());
builder.Services.AddSingleton<BotAdapter>(sp => sp.GetService<CloudAdapter>());
Importer la bibliothèque IA Teams
Importez toutes les classes de pour créer votre bot et utilisez les fonctionnalités de @microsoft/teams-ai bibliothèque d’IA Teams.
// import Teams AI library
import {
AI,
Application,
ActionPlanner,
OpenAIModerator,
OpenAIModel,
PromptManager,
TurnState
} from '@microsoft/teams-ai';
import { addResponseFormatter } from './responseFormatter';
import { VectraDataSource } from './VectraDataSource';
Créer des composants IA
Créez des composants IA dans une application bot existante ou dans une nouvelle application Bot Framework :
OpenAIModel : la classe OpenAIModel permet d’accéder à l’API OpenAI ou à tout autre service, qui respecte le format REST OpenAI. Il est compatible avec les modèles de langage OpenAI et Azure OpenAI.
Gestionnaire d’invites : le gestionnaire d’invites gère la création de l’invite. Il appelle des fonctions et injecte à partir de votre code dans l’invite. Il copie automatiquement l’état de la conversation et l’état utilisateur dans l’invite.
ActionPlanner : ActionPlanner est le composant main qui appelle votre modèle LLM (Large Language Model) et inclut plusieurs fonctionnalités pour améliorer et personnaliser votre modèle. Il est responsable de la génération et de l’exécution des plans en fonction de l’entrée de l’utilisateur et des actions disponibles.
// Create model
OpenAIModel? model = null;
if (!string.IsNullOrEmpty(config.OpenAI?.ApiKey))
{
model = new(new OpenAIModelOptions(config.OpenAI.ApiKey, "gpt-3.5-turbo"));
}
else if (!string.IsNullOrEmpty(config.Azure?.OpenAIApiKey) && !string.IsNullOrEmpty(config.Azure.OpenAIEndpoint))
{
model = new(new AzureOpenAIModelOptions(
config.Azure.OpenAIApiKey,
"gpt-35-turbo",
config.Azure.OpenAIEndpoint
));
}
if (model == null)
{
throw new Exception("please configure settings for either OpenAI or Azure");
}
// Create prompt manager
PromptManager prompts = new(new()
{
PromptFolder = "./Prompts",
});
// Add function to be referenced in the prompt template
prompts.AddFunction("getLightStatus", async (context, memory, functions, tokenizer, args) =>
{
bool lightsOn = (bool)(memory.GetValue("conversation.lightsOn") ?? false);
return await Task.FromResult(lightsOn ? "on" : "off");
});
// Create ActionPlanner
ActionPlanner<AppState> planner = new(
options: new(
model: model,
prompts: prompts,
defaultPrompt: async (context, state, planner) =>
{
PromptTemplate template = prompts.GetPrompt("sequence");
return await Task.FromResult(template);
}
)
{ LogRepairs = true },
loggerFactory: loggerFactory
);
Définir le stockage et l’application
L’objet d’application gère automatiquement la conversation et l’état utilisateur de votre bot.
Stockage : créez un fournisseur de stockage pour stocker la conversation et l’état utilisateur de votre bot.
Application : inscrivez des actions ou des gestionnaires d’activités pour l’application dans la
Applicationclasse , qui contient toutes les informations et la logique de bot requises pour votre application.
return new TeamsLightBot(new()
{
Storage = sp.GetService<IStorage>(),
AI = new(planner),
LoggerFactory = loggerFactory,
TurnStateFactory = () =>
{
return new AppState();
}
});
TurnStateFactory vous permet de créer une classe d’état personnalisée pour votre application afin de stocker des informations ou une logique supplémentaires pour votre bot. Vous pouvez remplacer les propriétés par défaut telles que l’entrée utilisateur, la sortie du bot ou l’historique des conversations. Pour l’utiliser, créez une classe qui étend l’état de tour par défaut et passez une fonction qui crée un instance de votre classe au constructeur d’application.
Inscrire des sources de données
Une source de données vectorielle simplifie l’ajout de RAG à n’importe quelle invite. Inscrivez une source de données nommée auprès du planificateur et spécifiez-la dans le fichier de config.json l’invite pour compléter l’invite. Cela permet à l’IA d’injecter des informations pertinentes à partir de sources externes telles que des bases de données vectorielles ou la recherche cognitive dans l’invite.
// Register your data source with planner
planner.prompts.addDataSource(new VectraDataSource({
name: 'teams-ai',
apiKey: process.env.OPENAI_API_KEY!,
indexFolder: path.join(__dirname, '../index'),
}));
Incorporations
Un incorporation est un vecteur généré par un LLM qui représente du texte, capturant sa signification sémantique sous une forme compacte. Il est utilisé dans des tâches telles que la classification de texte, l’analyse des sentiments et la recherche. Le modèle de génération d’incorporations est différent des llms de base. Le modèle text-embedding-ada-002 d’OpenAI, par exemple, retourne une liste de 1 536 nombres représentant le texte d’entrée. Ces incorporations sont stockées dans une base de données vectorielle. Dans un agent de moteur personnalisé, le modèle RAG peut être implémenté en récupérant les données pertinentes de la base de données vectorielle et en augmentant l’invite avec ces informations.
Voici un exemple de VectraDataSource et OpenAIEmbeddings :
import { DataSource, Memory, RenderedPromptSection, Tokenizer } from '@microsoft/teams-ai';
import { OpenAIEmbeddings, LocalDocumentIndex } from 'vectra';
import * as path from 'path';
import { TurnContext } from 'botbuilder';
/**
* Options for creating a `VectraDataSource`.
*/
export interface VectraDataSourceOptions {
/**
* Name of the data source and local index.
*/
name: string;
/**
* OpenAI API key to use for generating embeddings.
*/
apiKey: string;
/**
* Path to the folder containing the local index.
* @remarks
* This should be the root folder for all local indexes and the index itself
* needs to be in a subfolder under this folder.
*/
indexFolder: string;
/**
* Optional. Maximum number of documents to return.
* @remarks
* Defaults to `5`.
*/
maxDocuments?: number;
/**
* Optional. Maximum number of chunks to return per document.
* @remarks
* Defaults to `50`.
*/
maxChunks?: number;
/**
* Optional. Maximum number of tokens to return per document.
* @remarks
* Defaults to `600`.
*/
maxTokensPerDocument?: number;
}
/**
* A data source that uses a local Vectra index to inject text snippets into a prompt.
*/
export class VectraDataSource implements DataSource {
private readonly _options: VectraDataSourceOptions;
private readonly _index: LocalDocumentIndex;
/**
* Name of the data source.
* @remarks
* This is also the name of the local Vectra index.
*/
public readonly name: string;
/**
* Creates a new `VectraDataSource` instance.
* @param options Options for creating the data source.
*/
public constructor(options: VectraDataSourceOptions) {
this._options = options;
this.name = options.name;
// Create embeddings model
const embeddings = new OpenAIEmbeddings({
model: 'text-embedding-ada-002',
apiKey: options.apiKey,
});
// Create local index
this._index = new LocalDocumentIndex({
embeddings,
folderPath: path.join(options.indexFolder, options.name),
});
}
/**
* Renders the data source as a string of text.
* @param context Turn context for the current turn of conversation with the user.
* @param memory An interface for accessing state values.
* @param tokenizer Tokenizer to use when rendering the data source.
* @param maxTokens Maximum number of tokens allowed to be rendered.
*/
public async renderData(context: TurnContext, memory: Memory, tokenizer: Tokenizer, maxTokens: number): Promise<RenderedPromptSection<string>> {
// Query index
const query = memory.getValue('temp.input') as string;
const results = await this._index.queryDocuments(query, {
maxDocuments: this._options.maxDocuments ?? 5,
maxChunks: this._options.maxChunks ?? 50,
});
// Add documents until you run out of tokens
let length = 0;
let output = '';
let connector = '';
for (const result of results) {
// Start a new doc
let doc = `${connector}url: ${result.uri}\n`;
let docLength = tokenizer.encode(doc).length;
const remainingTokens = maxTokens - (length + docLength);
if (remainingTokens <= 0) {
break;
}
// Render document section
const sections = await result.renderSections(Math.min(remainingTokens, this._options.maxTokensPerDocument ?? 600), 1);
docLength += sections[0].tokenCount;
doc += sections[0].text;
// Append do to output
output += doc;
length += docLength;
connector = '\n\n';
}
return { output, length, tooLong: length > maxTokens };
}
}
Requêtes
Requêtes sont des éléments de texte utilisés pour créer des expériences de conversation, comme démarrer des conversations, poser des questions et générer des réponses. Ils simplifient le processus de création d’interactions attrayantes. Un nouveau système d’invite basée sur un objet divise les invites en sections, chacune avec son propre budget de jeton, qui peut être un ensemble fixe ou proportionnel aux jetons restants. Vous pouvez générer des invites pour les API de style Saisie semi-automatique de texte et De saisie semi-automatique de conversation.
Pour créer des invites effectives, suivez ces instructions :
- Fournissez des instructions, des exemples ou les deux.
- Assurez-vous que les données sont de qualité avec suffisamment d’exemples et que vous les relisez. Bien que le modèle puisse identifier les fautes d’orthographe, il peut supposer l’intentionnalité des fautes d’orthographe, ce qui affecte les réponses.
- Ajustez les paramètres d’invite à l’aide
temperaturede ettop_ppour contrôler la réponse du modèle. Une température plus élevée, telle que 0,8, rend la sortie aléatoire, tandis qu’une température inférieure telle que 0,2 la rend concentrée et déterministe.
Créez un dossier appelé invites et définissez-y vos invites. Lorsque l’utilisateur interagit avec le bot à l’aide d’une invite de texte, il répond avec une saisie semi-automatique. Créez les fichiers suivants dans le dossier invites :
skprompt.txt: contient le texte d’invite et prend en charge les variables et fonctions de modèle.config.json: contient les paramètres de modèle d’invite qui garantissent que les réponses du bot correspondent à vos besoins{ "schema": 1.1, "description": "A bot that can turn the lights on and off", "type": "completion", "completion": { "model": "gpt-3.5-turbo", "completion_type": "chat", "include_history": true, "include_input": true, "max_input_tokens": 2800, "max_tokens": 1000, "temperature": 0.2, "top_p": 0.0, "presence_penalty": 0.6, "frequency_penalty": 0.0, "stop_sequences": [] }, "augmentation": { "augmentation_type": "sequence" "data_sources": { "teams-ai": 1200 } } }
Paramètres de requête
Le tableau ci-dessous décrit chaque paramètre de chaîne de requête.
| Valeur | Description |
|---|---|
model |
ID du modèle à utiliser. |
completion_type |
Type de saisie semi-automatique que vous souhaitez utiliser pour votre modèle. À l’invite, le modèle retourne une ou plusieurs achèvements prédits, ainsi que les probabilités de jetons alternatifs à chaque position. Options prises en charge : chat et text. La valeur par défaut est chat. |
include_history |
Valeur booléenne Si vous souhaitez inclure l’historique. Chaque invite obtient son propre historique des conversations distinct pour s’assurer que le modèle n’est pas confus. |
include_input |
Valeur booléenne Si vous souhaitez inclure l’entrée de l’utilisateur dans l’invite. |
max_input_tokens |
Nombre maximal de jetons pour l’entrée. Le nombre maximal de jetons pris en charge est de 4 000. |
max_tokens |
Nombre maximal de jetons à générer dans la saisie semi-automatique. Le nombre de jetons de votre invite plus max_tokens ne peut pas dépasser la longueur du contexte du modèle. |
temperature |
Température d’échantillonnage à utiliser entre 0 et 2. Une valeur plus élevée, telle que 0,8, rend la sortie plus aléatoire, tandis qu’une valeur inférieure telle que 0,2 la rend plus ciblée et déterministe. |
top_p |
Alternative à l’échantillonnage avec température, appelé échantillonnage de noyau, où le modèle considère les résultats des jetons avec top_p une masse de probabilité. Par conséquent, 0,1 signifie que seuls les jetons comprenant la masse de probabilité de 10 % supérieure sont pris en compte. |
presence_penalty |
Nombre compris entre -2.0 et 2.0. Les valeurs positives pénalisent les nouveaux jetons selon qu’ils apparaissent ou non dans le texte jusqu’à présent, ce qui augmente la probabilité que le modèle parle de nouveaux sujets. |
frequency_penalty |
Nombre compris entre -2.0 et 2.0. Les valeurs positives pénalisent les nouveaux jetons en fonction de leur fréquence existante dans le texte jusqu’à présent, ce qui réduit la probabilité du modèle de répéter la même ligne textuellement. |
stop_sequences |
Jusqu’à quatre séquences où l’API cesse de générer d’autres jetons. Le texte retourné ne contient pas la séquence d’arrêt. |
augmentation_type |
Type d’augmentation. Les valeurs prises en charge sont sequence, monologueet tools. |
Gestion des invites
La gestion des invites ajuste la taille et le contenu des invites en fonction du budget des jetons et des sources de données. Pour un bot avec une limite de 4 000 jetons, où 2 800 jetons sont pour l’entrée et 1 000 jetons pour la sortie, le modèle gère la fenêtre de contexte pour rester dans 3 800 jetons. Il commence par 100 jetons de texte et ajoute 1 200 jetons à partir de sources de données. Il alloue les 1 500 jetons restants à l’historique des conversations et aux entrées et garantit que le modèle ne dépasse jamais 2 800 jetons.
Actions d’invite
Les plans permettent au modèle d’effectuer des actions ou de répondre à l’utilisateur. Vous pouvez créer un schéma du plan et ajouter une liste d’actions que vous prenez en charge pour effectuer une action et passer des arguments. Le point de terminaison OpenAI détermine les actions nécessaires, extrait les entités et les transmet en tant qu’arguments à l’appel d’action.
The following is a conversation with an AI assistant.
The assistant can turn a light on or off.
context:
The lights are currently {{getLightStatus}}.
Modèle d’invite
Un modèle d’invite est un moyen simple et puissant de définir et de composer des fonctions IA à l’aide de texte brut. Vous pouvez créer des invites en langage naturel, générer des réponses, extraire des informations, appeler d’autres invites ou effectuer n’importe quelle tâche textuelle.
Le langage prend en charge les fonctionnalités qui vous permettent d’inclure des variables, d’appeler des fonctions externes et de passer des paramètres à des fonctions. Vous n’avez pas besoin d’écrire de code ou d’importer des bibliothèques externes, il vous suffit d’utiliser les accolades {{...}} pour incorporer des expressions dans vos invites. Teams analyse votre modèle et exécute la logique qui le sous-tend. De cette façon, vous pouvez facilement intégrer l’IA dans vos applications avec un minimum d’effort et une flexibilité maximale.
{{function}}: appelle une fonction inscrite et insère sa chaîne de valeur de retour.{{$input}}: insère le texte du message. Il obtient sa valeur à partir de state.temp.input.{{$state.[property]}}: insère les propriétés d’état.
Actions
Les actions gèrent les événements déclenchés par des composants IA.
FlaggedInputAction et FlaggedOutputAction sont les gestionnaires d’actions intégrés pour gérer les indicateurs de modérateur. Si le modérateur signale une entrée de message entrant, le modérateur redirige vers le FlaggedInputAction gestionnaire et envoie context.sendActivity un message à l’utilisateur sur l’indicateur. Si vous souhaitez arrêter l’action, vous devez ajouter AI.StopCommandName.
// Register other AI actions
app.ai.action(
AI.FlaggedInputActionName,
async (context: TurnContext, state: ApplicationTurnState, data: Record<string, any>) => {
await context.sendActivity(`I'm sorry your message was flagged: ${JSON.stringify(data)}`);
return AI.StopCommandName;
}
);
app.ai.action(AI.FlaggedOutputActionName, async (context: TurnContext, state: ApplicationTurnState, data: any) => {
await context.sendActivity(`I'm not allowed to talk about such things.`);
return AI.StopCommandName;
});
Inscrire des gestionnaires d’actions
Les gestionnaires d’actions aident les utilisateurs à atteindre les objectifs, qui sont partagés dans les intentions de l’utilisateur. L’un des principaux aspects des gestionnaires d’actions est que vous devez d’abord inscrire les actions dans les invites, puis inscrire un gestionnaire pour chaque action répertoriée dans l’invite, y compris les actions inconnues.
Dans l’exemple suivant d’un bot léger, nous avons l’action LightsOn, LightsOffet Pause . Chaque fois qu’une action est appelée, vous retournez un string. Si vous avez besoin que le bot retourne l’heure, vous n’avez pas besoin d’analyser l’heure et de la convertir en nombre. La PauseParameters propriété garantit qu’elle retourne l’heure au format numérique sans interrompre l’invite.
public class LightBotActions
{
[Action("LightsOn")]
public async Task<string> LightsOn([ActionTurnContext] ITurnContext turnContext, [ActionTurnState] AppState turnState)
{
turnState.Conversation!.LightsOn = true;
await turnContext.SendActivityAsync(MessageFactory.Text("[lights on]"));
return "the lights are now on";
}
[Action("LightsOff")]
public async Task<string> LightsOff([ActionTurnContext] ITurnContext turnContext, [ActionTurnState] AppState turnState)
{
turnState.Conversation!.LightsOn = false;
await turnContext.SendActivityAsync(MessageFactory.Text("[lights off]"));
return "the lights are now off";
}
[Action("Pause")]
public async Task<string> LightsOff([ActionTurnContext] ITurnContext turnContext, [ActionParameters] Dictionary<string, object> args)
{
// Try to parse entities returned by the model.
// Expecting "time" to be a number of milliseconds to pause.
if (args.TryGetValue("time", out object? time))
{
if (time != null && time is string timeString)
{
if (int.TryParse(timeString, out int timeInt))
{
await turnContext.SendActivityAsync(MessageFactory.Text($"[pausing for {timeInt / 1000} seconds]"));
await Task.Delay(timeInt);
}
}
}
return "done pausing";
}
[Action("LightStatus")]
public async Task<string> LightStatus([ActionTurnContext] ITurnContext turnContext, [ActionTurnState] AppState turnState)
{
await turnContext.SendActivityAsync(ResponseGenerator.LightStatus(turnState.Conversation!.LightsOn));
return turnState.Conversation!.LightsOn ? "the lights are on" : "the lights are off";
}
[Action(AIConstants.UnknownActionName)]
public async Task<string> UnknownAction([ActionTurnContext] TurnContext turnContext, [ActionName] string action)
{
await turnContext.SendActivityAsync(ResponseGenerator.UnknownAction(action ?? "Unknown"));
return "unknown action";
}
}
}
L’utilisation de l’augmentation de séquence, de monologue ou d’outils empêche le modèle d’halluciner des noms de fonction, des noms d’action ou des paramètres non valides. Créez un fichier d’actions pour :
- Définissez des actions pour l’augmentation de l’invite.
- Indiquez quand effectuer des actions.
L’augmentation séquentielle est idéale pour les tâches complexes ou multiétapes, tandis que l’augmentation monologue convient aux tâches nécessitant une compréhension, une flexibilité et une créativité du langage naturel.
Dans l’exemple suivant d’un bot léger, le actions.json fichier contient une liste de toutes les actions que le bot peut effectuer :
[
{
"name": "LightsOn",
"description": "Turns on the lights"
},
{
"name": "LightsOff",
"description": "Turns off the lights"
},
{
"name": "Pause",
"description": "Delays for a period of time",
"parameters": {
"type": "object",
"properties": {
"time": {
"type": "number",
"description": "The amount of time to delay in milliseconds"
}
},
"required": [
"time"
]
}
}
]
-
name: nom de l’action. Obligatoire. -
description: description de l’action. Optional. -
parameters: ajoutez un objet de schéma JSON des paramètres requis.
La boucle de commentaires est la réponse d’un modèle pour valider, corriger ou affiner la réponse à votre question. Si vous utilisez une sequence augmentation, vous pouvez désactiver la boucle pour vous protéger contre tout bouclage accidentel des manières suivantes :
- Vous pouvez définir sur
allow_looping?falsedans laAIOptionsdéfinition. - Vous pouvez définir sur
max_repair_attempts0dans leindex.tsfichier.
Gérer l’historique
Vous pouvez utiliser les MaxHistoryMessages arguments et MaxConversationHistoryTokens pour permettre à la bibliothèque IA de gérer automatiquement votre historique.
Boucle de commentaires
Une boucle de commentaires permet de surveiller et d’améliorer les interactions du bot, ce qui aboutit à des applications plus efficaces et plus conviviales. Les commentaires sont utilisés pour ajuster et améliorer le bot afin de répondre aux besoins et aux attentes des utilisateurs. Une boucle de commentaires comprend :
- Réparer Loop : se déclenche si la réponse du modèle est inadéquate. L’historique des conversations duplique, ce qui permet au système d’essayer différentes solutions sans affecter la main conversation.
- Validation : vérifie la réponse corrigée et la réinséte dans la conversation main si la réponse est validée avec succès.
- Apprendre des erreurs : le modèle apprend à partir d’exemples de comportement corrects pour éviter des erreurs similaires à l’avenir.
- Gérer des commandes complexes : le modèle devient capable de gérer des commandes plus complexes après avoir appris de ses erreurs.
Élever votre bot conventionnel pour utiliser l’IA
Vous pouvez élever votre bot conventionnel existant pour qu’il soit alimenté par l’IA. Après avoir créé votre bot, vous pouvez ajouter une couche IA pour activer les fonctionnalités basées sur l’IA pour votre bot.
L’extrait de code suivant montre comment ajouter des composants IA à un bot. Dans cet exemple, le bot utilise l’adaptateur Bot Framework pour gérer les demandes entrantes, puis exécute la couche IA à l’aide de l’objet app .
// Create AI components
const model = new OpenAIModel({
// OpenAI Support
apiKey: process.env.OPENAI_KEY!,
defaultModel: 'gpt-4o',
// Azure OpenAI Support
azureApiKey: process.env.AZURE_OPENAI_KEY!,
azureDefaultDeployment: 'gpt-4o',
azureEndpoint: process.env.AZURE_OPENAI_ENDPOINT!,
azureApiVersion: '2023-03-15-preview',
// Request logging
logRequests: true
});
const prompts = new PromptManager({
promptsFolder: path.join(__dirname, '../src/prompts')
});
// Define a prompt function for getting the current status of the lights
prompts.addFunction('getLightStatus', async (context: TurnContext, memory: Memory) => {
return memory.getValue('conversation.lightsOn') ? 'on' : 'off';
});
const planner = new ActionPlanner({
model,
prompts,
defaultPrompt: 'tools'
});
// Define storage and application
const storage = new MemoryStorage();
const app = new Application<ApplicationTurnState>({
storage,
ai: {
planner
}
});
app.ai.action('LightStatus', async (context: TurnContext, state: ApplicationTurnState) => {
const status = state.conversation.lightsOn ? 'on' : 'off';
return `the lights are ${status}`;
});
// Register action handlers
app.ai.action('LightsOn', async (context: TurnContext, state: ApplicationTurnState) => {
state.conversation.lightsOn = true;
await context.sendActivity(`[lights on]`);
return `the lights are now on`;
});
app.ai.action('LightsOff', async (context: TurnContext, state: ApplicationTurnState) => {
state.conversation.lightsOn = false;
await context.sendActivity(`[lights off]`);
return `the lights are now off`;
});
interface PauseParameters {
time: number;
}
app.ai.action('Pause', async (context: TurnContext, state: ApplicationTurnState, parameters: PauseParameters) => {
await context.sendActivity(`[pausing for ${parameters.time / 1000} seconds]`);
await new Promise((resolve) => setTimeout(resolve, parameters.time));
return `done pausing`;
});
// Listen for incoming server requests.
server.post('/api/messages', async (req, res) => {
// Route received a request to adapter for processing
await adapter.process(req, res as any, async (context) => {
// Dispatch to application for routing
await app.run(context);
});
});
Migrer votre bot pour utiliser la bibliothèque IA Teams
Si vous avez créé votre application bot avec le Kit de développement logiciel (SDK) Bot Framework, vous pouvez basculer vers la bibliothèque IA Teams pour utiliser ses fonctionnalités IA avancées. Cette migration offre les avantages suivants :
- Système IA avancé pour la création d’applications Teams complexes alimentées par LLM.
- L’authentification utilisateur est intégrée à la bibliothèque, ce qui facilite la configuration.
- Basé sur les outils et concepts du Kit de développement logiciel (SDK) Bot Framework, ce qui permet aux connaissances existantes d’être transférables.
- Prend en charge les derniers outils et API dans l’espace LLM.
Dans la bibliothèque IA Teams, l’objet Application remplace l’objet traditionnel ActivityHandler , en prenant en charge un style de création de bot plus simple et fluide par rapport à la classe basée sur ActivityHandler l’héritage. Il inclut la prise en charge intégrée des éléments suivants :
- Appel du système de la bibliothèque d’IA Teams pour créer des bots qui utilisent LLM et d’autres fonctionnalités d’IA.
- Configuration de l’authentification utilisateur pour l’accès aux données utilisateur tierces.
Utilisez l’une des options suivantes pour migrer votre application bot afin d’utiliser la bibliothèque d’IA Teams :
| Migrer une application du Kit de développement logiciel (SDK) Bot Framework ... | Pour utiliser la bibliothèque IA Teams ... |
|---|---|
| Une application bot créée à l’aide de JavaScript | Migration |
| Une application bot créée à l’aide de C# | Migration |
| Une application de bot utilisant Python | Migration |
Exemple de code
| Exemple de nom | Description | .NET | Node.js |
|---|---|---|---|
| Lightbot de mappage d’actions | Cet exemple montre comment LightBot comprend l’intention de l’utilisateur, en interprétant avec précision les commandes pour contrôler facilement le bot léger. | View | View |