次の方法で共有

Teams AI ライブラリを使用したビルド

  • [アーティクル]

Teams AI ライブラリを使用すると、AI コンポーネントを使用してインテリジェントなMicrosoft Teams アプリケーションを簡単に構築できます。 データ アクセスとカスタム UI 作成用の API を提供します。 プロンプト管理と安全モデレーションを簡単に統合し、Ai 主導のエクスペリエンスのために OpenAI または Azure OpenAI を使用してボットを作成できます。

最初のセットアップ

Teams AI ライブラリは Bot Framework SDK の上に構築され、その基礎を使用して Bot Framework SDK 機能の拡張機能を提供します。 初期セットアップの一環として、Bot Framework SDK の機能をインポートすることが重要です。 チャネルとの接続を処理するアダプター クラスは、 Bot Framework SDK からインポートされます。

サンプル コード リファレンス

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 AI ライブラリをインポートする

@microsoft/teams-aiからすべてのクラスをインポートしてボットを構築し、Teams AI ライブラリ機能を使用します。

サンプル コード リファレンス

// import Teams AI library
import {
    AI,
    Application,
    ActionPlanner,
    OpenAIModerator,
    OpenAIModel,
    PromptManager,
    TurnState
} from '@microsoft/teams-ai';
import { addResponseFormatter } from './responseFormatter';
import { VectraDataSource } from './VectraDataSource';

AI コンポーネントを作成する

既存のボット アプリまたは新しい Bot Framework アプリで AI コンポーネントを作成します。

  • OpenAIModel: OpenAIModel クラスは、OpenAI API または OpenAI REST 形式に準拠するその他のサービスにアクセスする方法を提供します。 OpenAI と Azure OpenAI の両方の言語モデルと互換性があります。

  • プロンプト マネージャー: プロンプト マネージャーは、プロンプトの作成を処理します。 関数を呼び出し、コードからプロンプトに挿入します。 メッセージ交換の状態とユーザーの状態が自動的にプロンプトにコピーされます。

  • ActionPlanner: ActionPlanner は、大規模言語モデル (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 を簡単に追加できます。 名前付きデータ ソースを planner に登録し、プロンプトの config.json ファイルで指定してプロンプトを拡張します。 これにより、AI は、ベクター データベースやコグニティブ検索などの外部ソースから関連情報をプロンプトに挿入できます。

サンプル コード リファレンス

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

埋め込み

Embedding は、テキストを表す LLM によって生成されるベクターであり、そのセマンティックな意味をコンパクトな形式でキャプチャします。 これは、テキスト分類、センチメント分析、検索などのタスクで使用されます。 Embeddings を生成するためのモデルは、基本的な LLM とは異なります。 たとえば、OpenAI の text-embedding-ada-002 モデルは、入力テキストを表す 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 使用するモデルの ID。
completion_type モデルに使用する完了の種類。 プロンプトが表示されると、モデルは 1 つ以上の予測完了と、各位置での代替トークンの確率を返します。
サポートされているオプション: chat と text。
既定値: chat。
include_history ブール型 (Boolean) の値 履歴を含める場合。 各プロンプトは、モデルが混乱しないように、独自の個別の会話履歴を取得します。
include_input ブール型 (Boolean) の値 プロンプトにユーザーの入力を含める場合。
max_input_tokens 入力のトークンの最大数。 サポートされる最大トークン数は 4,000 です。
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 がそれ以上のトークンの生成を停止する最大 4 つのシーケンス。 返されたテキストに停止シーケンスは含まれません。
augmentation_type 拡張の種類。 サポートされている値は sequence、monologue、tools です。

プロンプト管理

プロンプト管理は、トークンの予算とデータ ソースに基づいて、プロンプトのサイズと内容を調整します。 4,000 トークンの制限があるボットの場合(入力には 2,800 トークン、出力には 1,000 トークン)、モデルはコンテキスト ウィンドウを 3,800 トークン以内に維持するように管理します。 100 個のテキスト トークンから始まり、データ ソースから 1,200 個のトークンを追加します。 残りの 1,500 個のトークンを会話の履歴と入力に割り当て、モデルが 2,800 トークンを超えないようにします。

プロンプト アクション

プランを使用すると、モデルでアクションを実行したり、ユーザーに応答したりできます。 プランのスキーマを作成し、アクションを実行して引数を渡すためにサポートするアクションの一覧を追加できます。 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}}.

プロンプト テンプレート

プロンプト テンプレートは、プレーン テキストを使用して AI 関数を定義および作成するためのシンプルで強力な方法です。 自然言語プロンプトの作成、応答の生成、情報の抽出、その他のプロンプトの呼び出し、テキストベースのタスクの実行を行うことができます。

この言語では、変数の含め、外部関数の呼び出し、関数へのパラメーターの渡しを可能にする機能がサポートされています。 コードを記述したり外部ライブラリをインポートしたりする必要はありません。中かっこ {{...}} を使用するだけです。 をクリックして、プロンプトに式を埋め込みます。 Teams はテンプレートを解析し、その背後にあるロジックを実行します。 これにより、最小限の労力と最大限の柔軟性で AI をアプリに簡単に統合できます。

  • {{function}}: 登録済み関数を呼び出し、その戻り値の文字列を挿入します。

  • {{$input}}: メッセージ テキストを挿入します。 state.temp.input から値を取得します。

  • {{$state.[property]}}: 状態プロパティを挿入します。

アクション

アクションは、AI コンポーネントによってトリガーされるイベントを処理します。

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

アクション ハンドラーの登録

アクション ハンドラーは、ユーザーの意図で共有される目標をユーザーが達成するのに役立ちます。 アクション ハンドラーの重要な側面の 1 つは、最初にプロンプトにアクションを登録してから、不明なアクションを含む、プロンプトに表示される各アクションのハンドラーを登録する必要があるということです。

次のライト ボットの例では、 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_attemptsを index.ts ファイル内の0に設定できます。

履歴の管理

MaxHistoryMessages引数とMaxConversationHistoryTokens引数を使用すると、AI ライブラリで履歴を自動的に管理できます。

フィードバック ループ

フィードバック ループを使用すると、ボットの相互作用を監視および改善し、より効果的で使いやすいアプリケーションが実現します。 フィードバックは、ユーザーのニーズと期待に合わせてボットを調整および強化するために使用されます。 フィードバック ループには、次のものが含まれます。

  • 修復Loop: モデルの応答が不十分な場合にトリガーされます。 会話履歴はフォークされ、システムはメイン会話に影響を与えずにさまざまなソリューションを試すことができます。
  • 検証: 修正された応答を検証し、応答が正常に検証された場合にメイン会話に再挿入します。
  • 間違いから学ぶ: モデルは、将来同様の間違いを避けるために、正しい動作の例から学習します。
  • 複雑なコマンドを処理する: モデルは、その間違いから学習した後、より複雑なコマンドを処理できるようになります。

AI を使用するように従来のボットを昇格させる

既存の従来のボットを AI を利用するように昇格させることができます。 ボットを構築したら、AI レイヤーを追加して、ボットの AI を利用する機能を有効にすることができます。

次のコード スニペットは、AI コンポーネントをボットに追加する方法を示しています。 この例では、ボットは Bot Framework アダプターを使用して受信要求を処理し、 app オブジェクトを使用して AI レイヤーを実行します。

// 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 AI ライブラリを使用するようにボットを移行する

Bot Framework SDK を使用してボット アプリを作成した場合は、Teams AI ライブラリに切り替えて高度な AI 機能を使用できます。 この移行には、次の利点があります。

  • LLM を利用した複雑な Teams アプリケーションを作成するための高度な AI システム。
  • ユーザー認証はライブラリに統合されているため、セットアップが容易になります。
  • Bot Framework SDK のツールと概念に基づいて構築され、既存の知識を転送可能にします。
  • LLM 領域の最新のツールと API をサポートします。

Teams AI ライブラリでは、 Application オブジェクトが従来の ActivityHandler オブジェクトに置き換えられ、継承ベースの ActivityHandler クラスと比較して、よりシンプルで流暢なボット作成スタイルがサポートされます。 これには、次の組み込みのサポートが含まれています。

  • LLM やその他の AI 機能を使用するボットを作成するための Teams AI ライブラリのシステムへの呼び出し。
  • サード パーティのユーザー データにアクセスするためのユーザー認証の構成。

Teams AI ライブラリを使用するようにボット アプリを移行するには、次のいずれかを使用します。

Bot Framework SDK アプリを移行する ... Teams AI ライブラリを使用するには ...
JavaScript を使用して構築されたボット アプリ 移行
C を使用して構築されたボット アプリ# 移行
Python を使用したボット アプリ 移行

コード サンプル

サンプルの名前 説明 .NET Node.js
アクション マッピングライトボット この例では、LightBot がユーザーの意図を理解し、ライト ボットを簡単に制御するためのコマンドを正確に解釈する方法を示します。 表示 表示

次の手順

Teams AI ライブラリについて