Compartilhar via

Criar com a biblioteca de IA do Teams

  • Artigo

A biblioteca de IA do Teams simplifica a criação de aplicações inteligentes do Microsoft Teams com componentes de IA. Oferece APIs para acesso a dados e criação de IU personalizada. Pode integrar facilmente a gestão de pedidos e a moderação de segurança e criar bots com o OpenAI ou o Azure OpenAI para uma experiência orientada por IA.

Configuração inicial

A biblioteca de IA do Teams baseia-se no SDK do Bot Framework e utiliza as suas noções básicas para oferecer uma extensão às capacidades do SDK do Bot Framework. Como parte da configuração inicial, é importante importar as funcionalidades do SDK do Bot Framework. A classe de adaptador que processa a conectividade com os canais é importada do SDK do Bot Framework.

Referência de código de exemplo

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

Importar biblioteca de IA do Teams

Importe todas as classes de para criar o bot e utilizar as capacidades da biblioteca de IA do @microsoft/teams-ai Teams.

Referência de código de exemplo

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

Criar componentes de IA

Crie componentes de IA numa aplicação de bot existente ou numa nova aplicação do Bot Framework:

  • OpenAIModel: a classe OpenAIModel fornece uma forma de aceder à API OpenAI ou a qualquer outro serviço, que cumpre o formato REST OpenAI. É compatível com os modelos de linguagem OpenAI e Azure OpenAI.

  • Gestor de pedidos: o gestor de pedidos processa a criação de pedidos. Chama funções e injeta do seu código na linha de comandos. Copia o estado da conversação e o estado do utilizador para o pedido automaticamente.

  • ActionPlanner: O ActionPlanner é o componente main que chama o seu Modelo de Linguagem Grande (LLM) e inclui várias funcionalidades para melhorar e personalizar o seu modelo. É responsável por gerar e executar planos com base na entrada do utilizador e nas ações disponíveis.

Referência de código de exemplo.

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

Definir armazenamento e aplicação

O objeto de aplicação gere automaticamente a conversação e o estado do utilizador do bot.

  • Armazenamento: crie um fornecedor de armazenamento para armazenar a conversação e o estado do utilizador do bot.

  • Aplicação: registe ações ou processadores de atividade para a aplicação na Application classe , que tem todas as informações e lógica de bot necessárias para a sua aplicação.

Referência de código de exemplo

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

TurnStateFactory permite-lhe criar uma classe de estado personalizada para a sua aplicação armazenar informações ou lógicas adicionais para o bot. Pode substituir as propriedades predefinidas, como a entrada do utilizador, a saída do bot ou o histórico de conversações. Para utilizá-la, crie uma classe que expanda o estado de viragem predefinido e transmita uma função que cria uma instância da sua classe para o construtor de aplicações.

Registar origens de dados

Uma origem de dados de vetor simplifica a adição de RAG a qualquer pedido. Registe uma origem de dados nomeada com o planeador e especifique-a no ficheiro do config.json pedido para aumentar o pedido. Isto permite que a IA injete informações relevantes de origens externas, como bases de dados de vetores ou pesquisa cognitiva, na linha de comandos.

Referência de código de exemplo

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

Incorporações

Uma Incorporação é um vetor gerado por um LLM que representa texto, capturando o respetivo significado semântico numa forma compacta. É utilizado em tarefas como classificação de textos, análise de sentimentos e pesquisa. O modelo para gerar Incorporações é diferente dos LLMs fundamentais. O modelo de incorporação de texto-ada-002 da OpenAI, por exemplo, devolve uma lista de 1536 números que representam o texto de entrada. Estas incorporações são armazenadas numa base de dados de vetores. Num agente de motor personalizado, o padrão RAG pode ser implementado ao obter dados relevantes da base de dados de vetores e ao aumentar o pedido com estas informações.


Segue-se um exemplo de vectraDataSource e 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 };
    }

}

Prompts

Solicitações são peças de texto utilizadas para criar experiências de conversação, como iniciar conversações, fazer perguntas e gerar respostas. Simplificam o processo de criação de interações envolventes. Um novo sistema de pedidos baseado em objetos divide os pedidos em secções, cada uma com o seu próprio orçamento de token, que pode ser um conjunto fixo ou proporcional aos tokens restantes. Pode gerar pedidos para as APIs de estilo Conclusão de Texto e Conclusão do Chat.

Para criar pedidos eficazes, siga estas diretrizes:

  • Forneça instruções, exemplos ou ambos.
  • Certifique-se de que os dados de qualidade têm exemplos suficientes e os releia. Embora o modelo possa identificar erros ortográficos, pode assumir intencionalidade em erros ortográficos, afetando as respostas.
  • Ajuste as definições de pedido com temperature e top_p para controlar a resposta do modelo. A temperatura mais alta, como 0,8, torna a saída aleatória, enquanto que mais baixa, como 0,2, torna-a focada e determinista.

Crie uma pasta denominada prompts e defina os seus pedidos aí. Quando o utilizador interage com o bot através de um pedido de texto, responde com uma conclusão de texto. Crie os seguintes ficheiros na pasta de pedidos:

  • skprompt.txt: contém o texto dos pedidos e suporta variáveis e funções de modelo.

  • config.json: contém as definições do modelo de pedido que garantem que as respostas do bot estão alinhadas com os seus requisitos

    Referência de código de exemplo

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

Parâmetros de consulta

A tabela a seguir inclui os parâmetros de consulta:

Valor Descrição
model ID do modelo a utilizar.
completion_type O tipo de conclusão que pretende utilizar para o seu modelo. Tendo em conta um pedido, o modelo devolve uma ou mais conclusões previstas, juntamente com as probabilidades de tokens alternativos em cada posição.
Opções suportadas: chat e text.
Padrão: chat.
include_history Valor booleano. Se quiser incluir o histórico. Cada pedido obtém o seu próprio histórico de conversações separado para garantir que o modelo não fica confuso.
include_input Valor booleano. Se quiser incluir a entrada do utilizador na linha de comandos.
max_input_tokens O número máximo de tokens para entrada. O máximo de tokens suportados é 4000.
max_tokens O número máximo de tokens a gerar na conclusão. A contagem de tokens do pedido mais max_tokens não pode exceder o comprimento de contexto do modelo.
temperature Temperatura de amostragem a utilizar entre 0 e 2. Um valor mais elevado, como 0,8, torna a saída mais aleatória, enquanto um valor mais baixo, como 0,2, torna-a mais focada e determinista.
top_p Uma alternativa à amostragem com temperatura, denominada amostragem de núcleos, em que o modelo considera os resultados dos tokens com top_p densidade de probabilidade. Portanto, 0,1 significa que apenas os tokens que incluem a massa de probabilidade superior de 10% são considerados.
presence_penalty Número entre -2.0 e 2.0. Os valores positivos penalizam os novos tokens com base no facto de estes aparecerem no texto até agora, aumentando a probabilidade de o modelo falar sobre novos tópicos.
frequency_penalty Número entre -2.0 e 2.0. Os valores positivos penalizam os novos tokens com base na respetiva frequência existente no texto até agora, diminuindo a probabilidade de o modelo repetir o mesmo texto literal de linha.
stop_sequences Até quatro sequências em que a API deixa de gerar mais tokens. O texto devolvido não conterá a sequência de paragem.
augmentation_type O tipo de aumento. Os valores suportados são sequence, monologuee tools.

Gestão de pedidos

A gestão de pedidos ajusta o tamanho e o conteúdo dos pedidos com base no orçamento do token e nas origens de dados. Para um bot com um limite de 4000 tokens, em que 2800 tokens são para entrada e 1000 tokens para saída, o modelo gere a janela de contexto para permanecer dentro de 3800 tokens. Começa com 100 tokens de texto e adiciona 1200 tokens de origens de dados. Atribui os restantes 1500 tokens ao histórico de conversações e à entrada e garante que o modelo nunca excede os 2800 tokens.

Ações de pedido

Os planos permitem que o modelo execute ações ou responda ao utilizador. Pode criar um esquema do plano e adicionar uma lista de ações que suporta para executar uma ação e transmitir argumentos. O ponto final OpenAI determina as ações necessárias, extrai as entidades e transmite-as como argumentos para a chamada de ação.

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

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

Modelo de pedido de aviso

Um modelo de linha de comandos é uma forma simples e poderosa de definir e compor funções de IA com texto simples. Pode criar pedidos de linguagem natural, gerar respostas, extrair informações, invocar outros pedidos ou executar qualquer tarefa baseada em texto.

A linguagem suporta funcionalidades que lhe permitem incluir variáveis, chamar funções externas e transmitir parâmetros para funções. Não precisa de escrever código nem importar bibliotecas externas, basta utilizar as chavetas {{...}} para incorporar expressões nos seus pedidos. O Teams analisa o seu modelo e executa a lógica por trás do mesmo. Desta forma, pode integrar facilmente a IA nas suas aplicações com um esforço mínimo e flexibilidade máxima.

  • {{function}}: chama uma função registada e insere a respetiva cadeia de valor devolvido.

  • {{$input}}: insere o texto da mensagem. Obtém o valor de state.temp.input.

  • {{$state.[property]}}: insere as propriedades de estado.

Ações

As ações processam eventos acionados por componentes de IA.

FlaggedInputAction e FlaggedOutputAction são os processadores de ações incorporados para processar os sinalizadores moderadores. Se o moderador sinalizar uma entrada de mensagem recebida, o moderador redireciona para o FlaggedInputAction processador e envia context.sendActivity uma mensagem ao utilizador sobre o sinalizador. Se quiser parar a ação, tem de adicionar AI.StopCommandName.

Referência de código de exemplo

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

Registar Processadores de Ações

Os processadores de ações ajudam os utilizadores a atingir os objetivos, que são partilhados nas intenções do utilizador. Um dos principais aspetos nos processadores de ações é que primeiro tem de registar as ações nos pedidos e, em seguida, registar um processador para cada ação listada na linha de comandos, incluindo as ações desconhecidas.

No exemplo seguinte de um bot claro, temos a ação LightsOn, LightsOffe Pause . Sempre que uma ação é chamada, devolve um string. Se precisar que o bot devolva tempo, não precisa de analisar a hora e convertê-la num número. A PauseParameters propriedade garante que devolve tempo no formato de número sem colocar o pedido em pausa.

Referência de código de exemplo

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

A utilização de sequências, monólogos ou ferramentas de aumento impede o modelo de alucinar nomes de funções inválidos, nomes de ações ou parâmetros. Crie um ficheiro de ações para:

  • Definir ações para aumento de pedidos.
  • Indique quando deve executar ações.

O aumento de sequências é ideal para tarefas complexas ou de vários passos, enquanto o aumento do monólogo se adequa a tarefas que precisam de compreensão, flexibilidade e criatividade em linguagem natural.

No exemplo seguinte de um bot claro, o actions.json ficheiro tem uma lista de todas as ações que o bot pode realizar:

[
    {
        "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: nome da ação. Obrigatório.
  • description: descrição da ação. Opcional.
  • parameters: adicione um objeto de esquema JSON dos parâmetros necessários.

O ciclo de comentários é a resposta de um modelo para validar, corrigir ou refinar a resposta à sua pergunta. Se estiver a utilizar um sequence aumento, pode desativar o ciclo para proteger contra qualquer ciclo acidental das seguintes formas:

  • Pode definir allow_looping? como false na AIOptions definição.
  • Pode definir max_repair_attempts como 0 no index.ts ficheiro.

Gerir histórico

Pode utilizar os MaxHistoryMessages argumentos e MaxConversationHistoryTokens para permitir que a biblioteca de IA faça a gestão automática do seu histórico.

Ciclo de comentários

Um ciclo de comentários ajuda a monitorizar e melhorar as interações do bot, o que leva a aplicações mais eficazes e fáceis de utilizar. O feedback é utilizado para ajustar e melhorar o bot para satisfazer as necessidades e expectativas dos utilizadores. Um ciclo de comentários inclui:

  • Reparar Loop: aciona se a resposta do modelo for inadequada. Os forks do histórico de conversações permitem que o sistema experimente soluções diferentes sem afetar o main conversação.
  • Validação: verifica a resposta corrigida e reinseri-a na conversação main se a resposta for validada com êxito.
  • Saiba mais com os Erros: o modelo aprende com exemplos de comportamento corretos para evitar erros semelhantes no futuro.
  • Processar Comandos Complexos: o modelo torna-se capaz de processar comandos mais complexos depois de aprender com os seus erros.

Elevar o bot convencional para utilizar IA

Pode elevar o bot convencional existente para ser alimentado pela IA. Depois de criar o bot, pode adicionar uma camada de IA para ativar as funcionalidades com tecnologia de IA para o bot.

O fragmento de código seguinte demonstra como pode adicionar componentes de IA a um bot. Neste exemplo, o bot utiliza o adaptador bot framework para processar pedidos recebidos e, em seguida, executa a camada de IA com o app objeto .

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

Migrar o bot para utilizar a biblioteca de IA do Teams

Se tiver criado a aplicação bot com o SDK do Bot Framework, pode mudar para a biblioteca de IA do Teams para utilizar as funcionalidades avançadas de IA. Esta migração fornece as seguintes vantagens:

  • Sistema avançado de IA para criar aplicações complexas do Teams com tecnologia LLM.
  • A autenticação do utilizador está integrada na biblioteca, facilitando a configuração.
  • Criado com base em ferramentas e conceitos do SDK do Bot Framework, permitindo que os conhecimentos existentes sejam transferíveis.
  • Suporta as ferramentas e APIs mais recentes no espaço LLM.

Na biblioteca de IA do Teams, o Application objeto substitui o objeto tradicional ActivityHandler , suportando um estilo mais simples e fluente de criação de bots em comparação com a classe baseada na ActivityHandler herança. Inclui suporte incorporado para:

  • Chamar o sistema da biblioteca de IA do Teams para criar bots que utilizam LLM e outras capacidades de IA.
  • Configurar a autenticação de utilizador para aceder a dados de utilizadores de terceiros.

Utilize um dos seguintes procedimentos para migrar a sua aplicação de bot para utilizar a biblioteca de IA do Teams:

Migrar uma aplicação do SDK do Bot Framework... Para utilizar a biblioteca de IA do Teams...
Uma aplicação de bot criada com JavaScript Migrar
Uma aplicação de bot criada com C# Migrar
Uma aplicação de bot com Python Migrar

Exemplo de código

Nome de exemplo Descrição .NET Node.js
Lightbot de mapeamento de ação Este exemplo mostra como o LightBot compreende a intenção do utilizador, interpretando com precisão comandos para controlar facilmente o bot de luz. View View

Próxima etapa

Compreender a biblioteca de IA do Teams