Compartir a través de

Compilación con la biblioteca de inteligencia artificial de Teams

  • Artículo

La biblioteca de inteligencia artificial de Teams simplifica la creación de aplicaciones inteligentes de Microsoft Teams con componentes de inteligencia artificial. Ofrece API para el acceso a datos y la creación personalizada de la interfaz de usuario. Puede integrar fácilmente la administración de mensajes y la moderación de seguridad, y crear bots mediante OpenAI o Azure OpenAI para una experiencia basada en la inteligencia artificial.

Configuración inicial

La biblioteca de inteligencia artificial de Teams se basa en bot framework SDK y usa sus aspectos básicos para ofrecer una extensión a las funcionalidades del SDK de Bot Framework. Como parte de la configuración inicial, es importante importar las funcionalidades del SDK de Bot Framework. La clase de adaptador que controla la conectividad con los canales se importa desde Bot Framework SDK.

Referencia de código de ejemplo

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 de Teams

Importe todas las clases de @microsoft/teams-ai para compilar el bot y use las funcionalidades de la biblioteca de inteligencia artificial de Teams.

Referencia de código de ejemplo

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

Creación de componentes de inteligencia artificial

Cree componentes de inteligencia artificial en una aplicación de bot existente o en una nueva aplicación de Bot Framework:

  • OpenAIModel: la clase OpenAIModel proporciona una manera de acceder a la API de OpenAI o a cualquier otro servicio, que se adhiere al formato REST de OpenAI. Es compatible con los modelos de lenguaje OpenAI y Azure OpenAI.

  • Administrador de mensajes: el administrador de mensajes controla la creación de mensajes. Llama a funciones e inserta desde el código en el símbolo del sistema. Copia el estado de la conversación y el estado de usuario en el símbolo del sistema automáticamente.

  • ActionPlanner: ActionPlanner es el componente principal que llama al modelo de lenguaje grande (LLM) e incluye varias características para mejorar y personalizar el modelo. Es responsable de generar y ejecutar planes en función de la entrada del usuario y las acciones disponibles.

Referencia de código de ejemplo.

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

Definición del almacenamiento y la aplicación

El objeto de aplicación administra automáticamente la conversación y el estado del usuario del bot.

  • Almacenamiento: cree un proveedor de almacenamiento para almacenar la conversación y el estado del usuario del bot.

  • Aplicación: registre acciones o controladores de actividad para la aplicación en la Application clase , que tiene toda la información y la lógica del bot necesarias para la aplicación.

Referencia de código de ejemplo

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

TurnStateFactory permite crear una clase de estado personalizada para que la aplicación almacene información adicional o lógica para el bot. Puede invalidar las propiedades predeterminadas, como la entrada del usuario, la salida del bot o el historial de conversaciones. Para usarlo, cree una clase que extienda el estado de turno predeterminado y pase una función que cree una instancia de la clase al constructor de la aplicación.

Registro de orígenes de datos

Un origen de datos vectorial simplifica la adición de RAG a cualquier símbolo del sistema. Registre un origen de datos con nombre con el planificador y especifíquelo en el archivo del símbolo del config.json sistema para aumentar el símbolo del sistema. Esto permite a la inteligencia artificial insertar información relevante de orígenes externos, como bases de datos vectoriales o búsqueda cognitiva, en el símbolo del sistema.

Referencia de código de ejemplo

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

Incrustaciones

Una inserción es un vector generado por un LLM que representa texto, capturando su significado semántico en un formato compacto. Se usa en tareas como la clasificación de texto, el análisis de sentimiento y la búsqueda. El modelo para generar incrustaciones es diferente de los LLM fundamentales. El modelo de openAI text-embedding-ada-002 , por ejemplo, devuelve una lista de 1536 números que representan el texto de entrada. Estas incrustaciones se almacenan en una base de datos vectorial. En un agente de motor personalizado, el patrón RAG se puede implementar mediante la recuperación de datos pertinentes de la base de datos vectorial y el aumento del símbolo del sistema con esta información.


A continuación se muestra un ejemplo de VectraDataSource y 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 };
    }

}

Peticiones de credenciales

Consultas son fragmentos de texto que se usan para crear experiencias conversacionales, como iniciar conversaciones, formular preguntas y generar respuestas. Simplifican el proceso de creación de interacciones atractivas. Un nuevo sistema de solicitud basado en objetos divide los mensajes en secciones, cada una con su propio presupuesto de tokens, que puede ser un conjunto fijo o proporcional a los tokens restantes. Puede generar mensajes para las API de estilo Finalización de texto y Finalización de chat.

Para crear mensajes efectivos, siga estas directrices:

  • Proporcione instrucciones, ejemplos o ambos.
  • Garantizar datos de calidad con suficientes ejemplos y revisarlos. Aunque el modelo puede identificar errores ortográficos, puede suponer intencionadamente errores ortográficos, lo que afecta a las respuestas.
  • Ajuste la configuración del símbolo del sistema mediante temperature y top_p para controlar la respuesta del modelo. Una temperatura más alta, como 0,8, hace que la salida sea aleatoria, mientras que una menor, como 0,2, la hace centrada y determinista.

Cree una carpeta denominada prompts y defina las solicitudes allí. Cuando el usuario interactúa con el bot mediante un mensaje de texto, responde con una finalización de texto. Cree los siguientes archivos en la carpeta prompts:

  • skprompt.txt: contiene el texto de las solicitudes y admite funciones y variables de plantilla.

  • config.json: contiene la configuración del modelo de aviso que garantiza que las respuestas del bot se alineen con sus requisitos.

    Referencia de código de ejemplo

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

En la tabla siguiente se incluyen los parámetros de consulta:

Valor Descripción
model Identificador del modelo que se va a usar.
completion_type Tipo de finalización que desea usar para el modelo. Dado un aviso, el modelo devuelve una o varias finalizaciones previstas junto con las probabilidades de tokens alternativos en cada posición.
Opciones admitidas: chat y text.
Valor predeterminado: chat.
include_history Valor Boolean. Si desea incluir el historial. Cada símbolo del sistema obtiene su propio historial de conversaciones independiente para asegurarse de que el modelo no se confunde.
include_input Valor Boolean. Si desea incluir la entrada del usuario en el símbolo del sistema.
max_input_tokens Número máximo de tokens para la entrada. El número máximo de tokens admitidos es 4000.
max_tokens Número máximo de tokens que se generarán durante la finalización. El recuento de tokens del símbolo del sistema más max_tokens no puede superar la longitud del contexto del modelo.
temperature Temperatura de muestreo para usar entre 0 y 2. Un valor mayor, como 0,8, hace que la salida sea más aleatoria, mientras que un valor inferior como 0,2 hace que sea más centrado y determinista.
top_p Alternativa al muestreo con temperatura, denominada muestreo de núcleo, donde el modelo tiene en cuenta los resultados de los tokens con top_p masa de probabilidad. Por lo tanto, 0,1 significa que solo se tienen en cuenta los tokens que componen la masa de probabilidad del 10 % superior.
presence_penalty Número entre -2.0 y 2.0. Los valores positivos penalizan los nuevos tokens en función de si aparecen en el texto hasta ahora, lo que aumenta la probabilidad del modelo de hablar de nuevos temas.
frequency_penalty Número entre -2.0 y 2.0. Los valores positivos penalizan los nuevos tokens en función de su frecuencia existente en el texto hasta ahora, lo que reduce la probabilidad de que el modelo repita la misma línea textualmente.
stop_sequences Hasta cuatro secuencias en las que la API deja de generar más tokens. El texto devuelto no contendrá la secuencia de detención.
augmentation_type Tipo de aumento. Los valores admitidos son sequence, monologuey tools.

Administración de mensajes

La administración de mensajes ajusta el tamaño y el contenido de las solicitudes en función del presupuesto del token y los orígenes de datos. En el caso de un bot con un límite de 4000 tokens, donde 2800 tokens son para entrada y 1000 tokens para salida, el modelo administra la ventana de contexto para permanecer dentro de 3 800 tokens. Comienza con 100 tokens de texto y agrega 1200 tokens de orígenes de datos. Asigna los 1500 tokens restantes al historial de conversaciones y la entrada y garantiza que el modelo nunca supere los 2.800 tokens.

Acciones de solicitud

Los planes permiten al modelo realizar acciones o responder al usuario. Puede crear un esquema del plan y agregar una lista de acciones que admita para realizar una acción y pasar argumentos. El punto de conexión de OpenAI determina las acciones necesarias, extrae entidades y las pasa como argumentos a la llamada a la acción.

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

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

Plantilla de solicitud

Una plantilla de aviso es una manera sencilla y eficaz de definir y redactar funciones de inteligencia artificial mediante texto sin formato. Puede crear mensajes de lenguaje natural, generar respuestas, extraer información, invocar otros mensajes o realizar cualquier tarea basada en texto.

El lenguaje admite características que permiten incluir variables, llamar a funciones externas y pasar parámetros a las funciones. No es necesario escribir ningún código ni importar ninguna biblioteca externa, solo tiene que usar las llaves {{...}} para insertar expresiones en los mensajes. Teams analiza la plantilla y ejecuta la lógica subyacente. De este modo, puede integrar fácilmente la inteligencia artificial en sus aplicaciones con un esfuerzo mínimo y la máxima flexibilidad.

  • {{function}}: llama a una función registrada e inserta su cadena de valor devuelto.

  • {{$input}}: inserta el texto del mensaje. Obtiene su valor de state.temp.input.

  • {{$state.[property]}}: inserta propiedades de estado.

Acciones

Las acciones controlan los eventos desencadenados por los componentes de IA.

FlaggedInputAction y FlaggedOutputAction son los controladores de acción integrados para controlar las marcas de moderador. Si el moderador marca una entrada de mensaje entrante, el moderador redirige al FlaggedInputAction controlador y context.sendActivity envía un mensaje al usuario sobre la marca. Si desea detener la acción, debe agregar AI.StopCommandName.

Referencia de código de ejemplo

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

Registrar controladores de acciones

Los controladores de acciones ayudan a los usuarios a lograr los objetivos, que se comparten en las intenciones del usuario. Uno de los aspectos clave de los controladores de acciones es que primero debe registrar las acciones en los mensajes y, a continuación, registrar un controlador para cada acción que aparece en el símbolo del sistema, incluidas las acciones desconocidas.

En el ejemplo siguiente de un bot ligero, tenemos la LightsOnacción , LightsOffy Pause . Cada vez que se llama a una acción, se devuelve .string Si necesita que el bot devuelva el tiempo, no es necesario analizar la hora y convertirla en un número. La PauseParameters propiedad garantiza que devuelve el tiempo en formato de número sin pausar el aviso.

Referencia de código de ejemplo

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

El uso del aumento de secuencias, monólogos o herramientas impide que el modelo halle nombres de función, nombres de acción o parámetros no válidos. Cree un archivo de acciones para:

  • Defina acciones para el aumento de solicitudes.
  • Indique cuándo realizar acciones.

El aumento de secuencias es ideal para tareas complejas o de varios pasos, mientras que el aumento de monólogos se adapta a las tareas que necesitan comprensión del lenguaje natural, flexibilidad y creatividad.

En el ejemplo siguiente de un bot ligero, el actions.json archivo tiene una lista de todas las acciones que el bot puede 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: nombre de la acción. Obligatorio.
  • description: descripción de la acción. Opcional.
  • parameters: agregue un objeto de esquema JSON de los parámetros necesarios.

El bucle de comentarios es la respuesta de un modelo para validar, corregir o refinar la respuesta a la pregunta. Si usa un sequence aumento, puede deshabilitar el bucle para protegerse contra cualquier bucle accidental de las siguientes maneras:

  • Puede establecer en allow_looping?false en la AIOptions definición.
  • Puede establecer en max_repair_attempts0 en el index.ts archivo.

Administrar historial

Puede usar los MaxHistoryMessages argumentos y MaxConversationHistoryTokens para permitir que la biblioteca de inteligencia artificial administre automáticamente el historial.

Retroalimentación

Un bucle de comentarios ayuda a supervisar y mejorar las interacciones del bot, lo que conduce a aplicaciones más eficaces y fáciles de usar. Los comentarios se usan para ajustar y mejorar el bot para satisfacer las necesidades y expectativas del usuario. Un bucle de comentarios incluye:

  • Reparar Loop: se desencadena si la respuesta del modelo es inadecuada. El historial de conversaciones bifurca, lo que permite al sistema probar diferentes soluciones sin afectar a la conversación principal.
  • Validación: comprueba la respuesta corregida y la vuelve a insertar en la conversación principal si la respuesta se valida correctamente.
  • Aprender de errores: el modelo aprende de ejemplos de comportamiento correctos para evitar errores similares en el futuro.
  • Controlar comandos complejos: el modelo es capaz de controlar comandos más complejos después de aprender de sus errores.

Elevación del bot convencional para usar la inteligencia artificial

Puede elevar el bot convencional existente para que tenga tecnología de inteligencia artificial. Después de compilar el bot, puede agregar una capa de inteligencia artificial para habilitar las características con tecnología de inteligencia artificial para el bot.

El siguiente fragmento de código muestra cómo puede agregar componentes de inteligencia artificial a un bot. En este ejemplo, el bot usa el adaptador de Bot Framework para controlar las solicitudes entrantes y, a continuación, ejecuta la capa de IA mediante el 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);
    });
});

Migración del bot para usar la biblioteca de inteligencia artificial de Teams

Si ha creado la aplicación de bot con bot Framework SDK, puede cambiar a la biblioteca de inteligencia artificial de Teams para usar sus características avanzadas de inteligencia artificial. Esta migración proporciona las siguientes ventajas:

  • Sistema de inteligencia artificial avanzado para crear aplicaciones complejas de Teams con tecnología LLM.
  • La autenticación de usuario se integra en la biblioteca, lo que facilita la configuración.
  • Se basa en las herramientas y los conceptos del SDK de Bot Framework, lo que permite transferir los conocimientos existentes.
  • Admite las herramientas y API más recientes en el espacio LLM.

En la biblioteca de IA de Teams, el Application objeto reemplaza al objeto tradicional ActivityHandler , lo que admite un estilo más sencillo y fluido de creación de bots en comparación con la clase basada en ActivityHandler herencia. Incluye compatibilidad integrada para:

  • Llamar al sistema de la biblioteca de inteligencia artificial de Teams para crear bots que usen LLM y otras funcionalidades de inteligencia artificial.
  • Configuración de la autenticación de usuario para acceder a datos de usuario de terceros.

Use una de las siguientes opciones para migrar la aplicación de bot para usar la biblioteca de inteligencia artificial de Teams:

Migración de una aplicación del SDK de Bot Framework... Para usar la biblioteca de IA de Teams...
Una aplicación de bot compilada con JavaScript Migrar
Una aplicación de bot compilada con C# Migrar
Una aplicación de bot con Python Migrar

Ejemplo de código

Ejemplo de nombre Descripción .NET Node.js
Bot de luz de asignación de acciones En este ejemplo se muestra cómo LightBot entiende la intención del usuario, interpretando con precisión los comandos para controlar sin esfuerzo el bot ligero. View View

Paso siguiente

Descripción de la biblioteca de inteligencia artificial de Teams