Поделиться через

Сборка с помощью библиотеки ИИ Teams

  • Статья

Библиотека ИИ Teams упрощает создание интеллектуальных приложений Microsoft Teams с помощью компонентов ИИ. Он предлагает API для доступа к данным и создания пользовательского интерфейса. Вы можете легко интегрировать управление запросами и модерацию безопасности, а также создавать ботов с помощью OpenAI или Azure OpenAI для работы на основе ИИ.

Первоначальная настройка

Библиотека ИИ Teams основана на пакете SDK Bot Framework и использует ее основы для предоставления расширения возможностей пакета SDK Bot Framework. В рамках начальной настройки важно импортировать функции пакета SDK Bot Framework. Класс адаптера, обрабатывающий подключение к каналам, импортируется из пакета 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>());

Импорт библиотеки ИИ Teams

Импортируйте все классы из для @microsoft/teams-ai создания бота и использования возможностей библиотеки ИИ 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';

Создание компонентов ИИ

Создание компонентов ИИ в существующем приложении бота или в новом приложении Bot Framework:

  • OpenAIModel. Класс OpenAIModel предоставляет способ доступа к API OpenAI или любой другой службе, которая соответствует формату REST OpenAI. Он совместим с языковыми моделями OpenAI и Azure OpenAI.

  • Диспетчер запросов. Диспетчер запросов обрабатывает создание запросов. Он вызывает функции и внедряет из кода в запрос. Он автоматически копирует состояние беседы и пользователя в запрос.

  • ActionPlanner: ActionPlanner — это компонент main, вызывающий модель большого языка (LLM) и включающий несколько функций для улучшения и настройки модели. Он отвечает за создание и выполнение планов на основе входных данных пользователя и доступных действий.

Пример справочника по коду.

    // 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
    );

Определение хранилища и приложения

Объект приложения автоматически управляет диалогом и пользовательским состоянием бота.

  • Хранилище. Создайте поставщика хранилища для хранения беседы и пользовательского состояния бота.

  • Приложение: зарегистрируйте действия или обработчики действий для приложения в Application классе , который содержит все сведения и логику бота, необходимые для приложения.

Пример справочника по коду

 return new TeamsLightBot(new()
    {
        Storage = sp.GetService<IStorage>(),
        AI = new(planner),
        LoggerFactory = loggerFactory,
        TurnStateFactory = () =>
        {
            return new AppState();
        }
    });

TurnStateFactory позволяет создать пользовательский класс состояния для приложения для хранения дополнительных сведений или логики для бота. Вы можете переопределить свойства по умолчанию, такие как входные данные пользователя, выходные данные бота или журнал бесед. Чтобы использовать его, создайте класс, который расширяет состояние поворота по умолчанию и передайте функцию, создающую экземпляр класса, в конструктор приложения.

Регистрация источников данных

Источник векторных данных упрощает добавление RAG в любой запрос. Зарегистрируйте именованный источник данных в планировщике и укажите его в файле запроса config.json , чтобы дополнить запрос. Это позволяет ИИ внедрять в запрос соответствующую информацию из внешних источников, таких как векторные базы данных или когнитивный поиск.

Пример справочника по коду

// 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'),
}));

Внедрение

Внедрение — это вектор, создаваемый LLM, который представляет текст, фиксируя его семантический смысл в компактной форме. Он используется в таких задачах, как классификация текста, анализ тональности и поиск. Модель создания внедрения отличается от базовых LLM. Например, модель text-embedding-ada-002 в OpenAI возвращает список из 1536 чисел, представляющих входной текст. Эти внедрения хранятся в векторной базе данных. В пользовательском агенте обработчика шаблон RAG можно реализовать путем получения соответствующих данных из векторной базы данных и дополнения запроса с помощью этих сведений.


Ниже приведен пример VectraDataSource и 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 };
    }

}

Запросы

Запросы — это текстовые фрагменты, используемые для создания взаимодействия с беседами, таких как начало беседы, постановка вопросов и создание ответов. Они упрощают процесс создания привлекательных взаимодействий. Новая система запросов на основе объектов делит запросы на разделы, каждый из которых имеет собственный бюджет маркеров, который может быть фиксированным или пропорциональным остальным маркерам. Вы можете создавать запросы как для API-интерфейсов завершения текста, так и для стилей завершения чата.

Чтобы создать эффективные запросы, следуйте приведенным ниже рекомендациям.

  • Предоставьте инструкции, примеры или и то, и другое.
  • Обеспечьте качество данных с достаточным количеством примеров и вычитайте их. Хотя модель может выявлять орфографические ошибки, она может предполагать преднамеренность орфографических ошибок, влияя на ответы.
  • Настройте параметры запроса с помощью temperature и top_p для управления ответом модели. Более высокая температура, такая как 0,8, делает вывод случайным, а более низкая, например 0,2, делает его сфокусированным и детерминированным.

Создайте папку с именем prompts и определите в ней свои запросы. Когда пользователь взаимодействует с ботом с помощью текстового запроса, он отвечает заполнением текста. Создайте следующие файлы в папке prompts:

  • skprompt.txt: содержит текст запросов и поддерживает переменные и функции шаблона.

  • config.json: содержит параметры модели запроса, которые гарантируют, что ответы бота соответствуют вашим требованиям.

    Пример справочника по коду

     {
    "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
     }
    }
  }

Параметры запроса

В следующей таблице приведены параметры запроса:

Значение Описание
model Идентификатор используемой модели.
completion_type Тип завершения, который вы хотите использовать для модели. При появлении запроса модель возвращает одно или несколько прогнозируемых завершений вместе с вероятностью альтернативных маркеров в каждой позиции.
Поддерживаемые параметры: chat и text.
Значение по умолчанию: chat.
include_history Логическое значение. Если вы хотите включить журнал. Каждый запрос получает собственный отдельный журнал бесед, чтобы убедиться, что модель не запуталась.
include_input Логическое значение. Если вы хотите включить входные данные пользователя в запрос.
max_input_tokens Максимальное количество маркеров для ввода. Максимальное число поддерживаемых маркеров — 4000.
max_tokens Максимальное количество маркеров для создания при завершении. Количество маркеров запроса и max_tokens не может превышать длину контекста модели.
temperature Температура выборки для использования в диапазоне от 0 до 2. Более высокое значение, например 0,8, делает выходные данные более случайными, а более низкое значение, например 0,2, делает его более целенаправленным и детерминированным.
top_p Альтернатива выборке с температурой, называемая выборкой ядра, когда модель рассматривает результаты маркеров с top_p вероятностью. Таким образом, 0.1 означает, что учитываются только маркеры, составляющие верхнюю массу вероятности 10 %.
presence_penalty Число от -2.0 до 2.0. Положительные значения наказывают новые маркеры в зависимости от того, появляются ли они в тексте до сих пор, что повышает вероятность того, что модель будет говорить о новых темах.
frequency_penalty Число от -2.0 до 2.0. Положительные значения наказывают новые маркеры на основе их существующей частоты в тексте до сих пор, уменьшая вероятность повторения модели той же строки дословно.
stop_sequences До четырех последовательностей, в которых API перестает создавать дополнительные маркеры. Возвращаемый текст не будет содержать стоп-последовательность.
augmentation_type Тип расширения. Поддерживаемые значения: sequence, monologueи tools.

Управление запросами

Управление запросами корректирует размер и содержимое запросов на основе бюджета маркеров и источников данных. Для бота с ограничением в 4000 маркеров, где 2800 маркеров предназначены для входных данных, а 1000 маркеров — для вывода, модель управляет окном контекста, чтобы оставаться в пределах 3800 маркеров. Он начинается с 100 маркеров текста и добавляет 1200 маркеров из источников данных. Он выделяет оставшиеся 1500 токенов для журнала бесед и входных данных и гарантирует, что модель никогда не превышает 2800 маркеров.

Запрос действий

Планы позволяют модели выполнять действия или отвечать пользователю. Можно создать схему плана и добавить список действий, которые поддерживаются для выполнения действия и передачи аргументов. Конечная точка OpenAI определяет необходимые действия, извлекает сущности и передает их в качестве аргументов в вызов действия.

The following is a conversation with an AI assistant.
The assistant can turn a light on or off.

context:
The lights are currently {{getLightStatus}}.

Шаблон запроса

Шаблон запроса — это простой и эффективный способ определения и создания функций ИИ с помощью обычного текста. Вы можете создавать запросы на естественном языке, создавать ответы, извлекать сведения, вызывать другие запросы или выполнять любые текстовые задачи.

Язык поддерживает функции, позволяющие включать переменные, вызывать внешние функции и передавать параметры в функции. Вам не нужно писать код или импортировать внешние библиотеки, просто используйте фигурные скобки {{...}} для внедрения выражений в запросы. Teams анализирует шаблон и выполняет его логику. Таким образом, вы можете легко интегрировать ИИ в приложения с минимальными усилиями и максимальной гибкостью.

  • {{function}}: вызывает зарегистрированную функцию и вставляет ее возвращаемую строку значения.

  • {{$input}}: вставляет текст сообщения. Он получает свое значение из state.temp.input.

  • {{$state.[property]}}: вставляет свойства состояния.

Действия

Действия обрабатывают события, инициируемые компонентами ИИ.

FlaggedInputAction и FlaggedOutputAction — это встроенные обработчики действий для обработки флагов модератора. Если модератор помечает входные данные сообщения, модератор перенаправляется на FlaggedInputAction обработчик и context.sendActivity отправляет пользователю сообщение о флаге. Если вы хотите остановить действие, необходимо добавить 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;
});

Регистрация обработчиков действий

Обработчики действий помогают пользователям достичь целей, которые совместно используются в намерениях пользователя. Одним из ключевых аспектов в обработчиках действий является то, что необходимо сначала зарегистрировать действия в запросах, а затем зарегистрировать обработчик для каждого действия, указанного в запросе, включая неизвестные действия.

В следующем примере светового бота мы имеем LightsOnдействие , LightsOffи Pause . При каждом вызове действия возвращается string. Если требуется, чтобы бот возвращал время, не нужно анализировать время и преобразовывать его в число. Свойство PauseParameters гарантирует, что возвращает время в числовом формате без приостановки запроса.

Пример справочника по коду

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";
        }
    }
}

Использование последовательности, монолога или расширения инструментов предотвращает галлюцинацию недопустимых имен функций, имен действий или параметров в модели. Создайте файл действий, чтобы:

  • Определите действия для расширения запроса.
  • Укажите, когда следует выполнять действия.

Расширение последовательности идеально подходит для многоэтапных или сложных задач, в то время как расширение монолога подходит для задач, требующих понимания естественного языка, гибкости и творчества.

В следующем примере легкого бота файл actions.json содержит список всех действий, которые может выполнять бот:

[
    {
        "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: имя действия. Обязательно.
  • description: описание действия. Необязательный параметр.
  • parameters: добавьте объект схемы JSON необходимых параметров.

Цикл обратной связи — это ответ модели для проверки, исправления или уточнения ответа на ваш вопрос. Если вы используете sequence расширение, вы можете отключить циклы, чтобы защититься от любых случайных циклов следующими способами:

  • В определении AIOptions можно задать значение .allow_looping?false
  • В файле можно задать значение max_repair_attempts0index.ts .

Управление журналом

Аргументы и MaxConversationHistoryTokens можно использоватьMaxHistoryMessages, чтобы позволить библиотеке ИИ автоматически управлять журналом.

Цикл обратной связи

Цикл обратной связи помогает отслеживать и улучшать взаимодействие бота, что позволяет создавать более эффективные и удобные приложения. Обратная связь используется для настройки и улучшения бота в соответствии с потребностями и ожиданиями пользователей. Цикл обратной связи включает:

  • Исправление Loop: активирует, если ответ модели неадекватен. Вилки журнала бесед, позволяющие системе пробовать различные решения, не затрагивая main беседы.
  • Проверка. Проверяет исправленный ответ и повторно вводит его в main беседу, если ответ успешно проверен.
  • Учиться на ошибках. Модель учится на правильных примерах поведения, чтобы избежать подобных ошибок в будущем.
  • Обработка сложных команд. Модель становится способной обрабатывать более сложные команды после обучения на своих ошибках.

Повышение уровня обычного бота для использования ИИ

Вы можете повысить уровень существующего обычного бота на базе ИИ. После создания бота можно добавить уровень ИИ, чтобы включить функции на основе ИИ для бота.

В следующем фрагменте кода показано, как добавить компоненты ИИ в бот. В этом примере бот использует адаптер платформы Bot для обработки входящих запросов, а затем запускает уровень ИИ с помощью 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);
    });
});

Перенос бота на использование библиотеки ИИ Teams

Если вы создали приложение бота с помощью пакета SDK Bot Framework, вы можете переключиться на библиотеку ИИ Teams, чтобы использовать ее расширенные функции ИИ. Эта миграция обеспечивает следующие преимущества:

  • Расширенная система ИИ для создания сложных приложений Teams на основе LLM.
  • Проверка подлинности пользователей интегрирована в библиотеку, что упрощает настройку.
  • Создано на основе средств и концепций пакета SDK Bot Framework, что позволяет передавать существующие знания.
  • Поддерживает новейшие средства и API в пространстве LLM.

В библиотеке Application ИИ Teams объект заменяет традиционный ActivityHandler объект, поддерживая более простой и текучий стиль разработки ботов по сравнению с классом на основе ActivityHandler наследования. Она включает встроенную поддержку:

  • Вызов в систему библиотеки ИИ Teams для создания ботов, использующих LLM и другие возможности ИИ.
  • Настройка проверки подлинности пользователей для доступа к данным сторонних пользователей.

Используйте один из следующих способов, чтобы перенести приложение бота на использование библиотеки ИИ Teams:

Перенос приложения пакета SDK Bot Framework ... Чтобы использовать библиотеку ИИ Teams ...
Приложение бота, созданное с помощью JavaScript Миграция
Приложение бота, созданное с помощью C# Миграция
Приложение бота, использующий Python Миграция

Пример кода

Название примера Описание .NET Node.js
Лайтбот сопоставления действий В этом примере показано, как LightBot понимает намерения пользователей, точно интерпретируя команды для легкого управления световым ботом. Просмотр Просмотр

Следующий этап

Общие сведения о библиотеке ИИ Teams