Compartir a través de

Compilación con la biblioteca de inteligencia artificial de Teams

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, la creación de interfaz de usuario personalizada, la administración de mensajes y la moderación de seguridad. Puede crear fácilmente bots mediante OpenAI o Azure OpenAI para ofrecer una experiencia basada en la inteligencia artificial.

Configuración inicial

La biblioteca de inteligencia artificial de Teams se basa en el SDK de Bot Framework. Amplía las funcionalidades de Bot Framework mediante la importación de funcionalidades básicas. Como parte de la configuración inicial, importe los componentes 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

Código .NET: configuración inicial y configuración del adaptador

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

Código JavaScript: Importación de la biblioteca de inteligencia artificial de 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';

Creación de componentes de inteligencia artificial

Puede crear componentes de inteligencia artificial en una aplicación de bot existente o en una nueva aplicación de Bot Framework. Los componentes principales incluyen:

  • OpenAIModel: proporciona acceso a la API de OpenAI o a cualquier servicio que siga el formato REST de OpenAI. Funciona con los modelos de lenguaje OpenAI y Azure OpenAI.
  • Administrador de mensajes: administra la creación de mensajes. Inserta funciones, estado de conversación y estado de usuario en el símbolo del sistema automáticamente.
  • ActionPlanner: llama al modelo de lenguaje grande (LLM) e incluye características para mejorar y personalizar el modelo. Este componente genera y ejecuta planes en función de la entrada del usuario y las acciones disponibles.

Referencia de código de ejemplo.

Código de .NET: creación de componentes de inteligencia artificial

    // 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. Incluye:

  • Almacenamiento: un proveedor de almacenamiento almacena la conversación y el estado del usuario.
  • Aplicación: la Application clase registra acciones o controladores de actividad para la aplicación. Contiene toda la información necesaria y la lógica del bot.

Referencia de código de ejemplo

Código .NET: definición del almacenamiento y la aplicación

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

La TurnStateFactory propiedad permite crear una clase de estado personalizada para almacenar información o lógica adicionales. Amplíe el estado de turno predeterminado mediante la creación de una clase que incluya propiedades adicionales (como la entrada del usuario, la salida del bot o el historial de conversaciones) y pase una función que crea 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 Retrieval-Augmented Generation (RAG) a cualquier solicitud. 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

Código JavaScript: Registro de un origen de datos con el Planner

// 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 para representar texto, capturando su significado semántico. Las incrustaciones se usan en la clasificación de texto, el análisis de sentimiento, la búsqueda y mucho más. Por ejemplo, el modelo de text-embedding-ada-002 OpenAI 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 puede recuperar datos pertinentes de la base de datos vectorial y aumentar el símbolo del sistema.


Ejemplo: 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 doc to output
            output += doc;
            length += docLength;
            connector = '\n\n';
        }

        return { output, length, tooLong: length > maxTokens };
    }

}

Peticiones de credenciales

Consultas son segmentos de texto que se usan para crear experiencias conversacionales, como iniciar conversaciones, formular preguntas y generar respuestas. El nuevo sistema de solicitud basado en objetos divide las solicitudes en secciones, cada una con su propio presupuesto de tokens (ya sea fijo o proporcional a los tokens restantes). Consultas se pueden generar para las API de estilo Finalización de texto y Finalización de chat.

Siga estas directrices para crear mensajes efectivos:

  • Proporcione instrucciones y ejemplos claros.
  • Asegúrese de datos de alta calidad y revisión con ejemplos suficientes.
  • Ajuste la configuración del símbolo del sistema mediante temperature y top_p para controlar la salida del modelo. Los valores más altos (por ejemplo, 0,8) producen salidas aleatorias; valores inferiores (por ejemplo, 0,2) crean respuestas centradas y deterministas.

Para implementar mensajes:

  1. Cree una carpeta denominada prompts.
  2. Defina las plantillas de aviso y la configuración en archivos dedicados:
    • skprompt.txt: contiene el texto del símbolo del sistema con compatibilidad con las funciones y variables de plantilla.
    • config.json: contiene la configuración del modelo de aviso que garantiza que las respuestas del bot cumplan los requisitos.

Referencia de código de ejemplo

Ejemplo: config.json para la configuración del símbolo del sistema

 {
    "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 detallan los parámetros de consulta:

Valor Descripción
model Identificador del modelo que se va a usar.
completion_type Tipo de finalización que se va a usar. El modelo devuelve una o varias finalizaciones previstas y la probabilidad de tokens alternativos. Opciones admitidas: chat y text. Valor predeterminado: chat.
include_history Valor Boolean. Indica si se debe incluir el historial. Cada mensaje obtiene su propio historial de conversaciones para evitar confusiones.
include_input Valor Boolean. Si se establece en true, la entrada del usuario se incluye en el símbolo del sistema.
max_input_tokens Número máximo de tokens permitidos para la entrada. (Número máximo de tokens admitidos: 4000)
max_tokens Número máximo de tokens que se van a generar. La suma de tokens de solicitud y max_tokens no debe superar la longitud del contexto del modelo.
temperature Temperatura de muestreo (intervalo: 0 a 2). Los valores más altos (por ejemplo, 0,8) producen una salida más aleatoria; valores inferiores (por ejemplo, 0,2) generan una salida centrada.
top_p Alternativa para el muestreo con temperatura, conocida como muestreo de núcleos. Por ejemplo, un valor de 0,1 significa que solo se tienen en cuenta los tokens de 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, lo que fomenta la discusión de nuevos temas.
frequency_penalty Número entre -2.0 y 2.0. Los valores positivos penalizan los tokens en función de su frecuencia, lo que reduce la probabilidad de repetición.
stop_sequences Hasta cuatro secuencias donde la API deja de generar tokens. El texto devuelto no incluye las secuencias 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 dinámicamente el tamaño de la solicitud y el contenido en función del presupuesto del token y de los orígenes de datos disponibles. Por ejemplo, para un bot con un límite de 4000 tokens (2.800 para entrada y 1.000 para salida), el modelo reserva tokens para el historial de conversaciones, la entrada y los datos aumentados de orígenes externos.

Acciones de solicitud

Las acciones de solicitud permiten al modelo realizar acciones o responder a la entrada del usuario. Puede crear un esquema que muestre las acciones admitidas con los parámetros correspondientes. El punto de conexión de OpenAI extrae entidades y las pasa como argumentos al controlador de acciones.

Por ejemplo:

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 define y crea funciones de inteligencia artificial mediante texto sin formato. Le permite:

  • Cree mensajes de lenguaje natural.
  • Generar respuestas.
  • Extraer información.
  • Invoque otras solicitudes.

El lenguaje admite la inserción de variables y funciones mediante llaves {{...}}. Algunas expresiones clave incluyen:

  • {{function}}: llama a una función registrada e inserta su valor devuelto.
  • {{$input}}: inserta el texto del mensaje del usuario, obtenido de state.temp.input.
  • {{$state.[property]}}: inserta propiedades de estado.

Acciones

Las acciones controlan los eventos desencadenados por los componentes de IA. Marcas de moderador integradas FlaggedInputAction y FlaggedOutputAction de control. Cuando se marca un mensaje, el bot notifica al usuario a través de context.sendActivity. Para detener la acción, devuelva AI.StopCommandName.

Referencia de código de ejemplo

Código JavaScript: Registrar acciones de entrada y salida marcadas

// 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 al bot a realizar tareas específicas. En primer lugar, registre las acciones en el símbolo del sistema e implemente un controlador para cada acción, incluidas las acciones desconocidas.

En el siguiente ejemplo de bot ligero, las acciones incluyen LightsOn, LightsOffy Pause. Cada controlador de acciones devuelve un stringobjeto . En el caso de las acciones que devuelven tiempo (por ejemplo, la duración de la pausa), la PauseParameters propiedad garantiza que el tiempo esté en formato de número.

Referencia de código de ejemplo

Código .NET: controladores de acciones para LightBot

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.

Por ejemplo, en un bot ligero, el actions.json archivo podría enumerar acciones como esta:

[
    {
        "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: esquema JSON que define los parámetros necesarios.

Un bucle de comentarios ayuda a validar, corregir y refinar las interacciones del bot. Para sequence el aumento, deshabilite el bucle si establece allow_looping?false en AIOptions o establece 0max_repair_attempts en en la implementación.

Administrar historial

Use la MaxHistoryMessages configuración y MaxConversationHistoryTokens para permitir que la biblioteca de inteligencia artificial administre automáticamente el historial de conversaciones.

Retroalimentación

Un bucle de comentarios supervisa y mejora las interacciones del bot. Incluye:

  • Reparar Loop: bifurca el historial de conversaciones cuando una respuesta no es adecuada para probar soluciones alternativas.
  • Validación: comprueba la respuesta corregida antes de volver a combinarla en la conversación.
  • Aprendizaje: ajusta el rendimiento del bot en función de ejemplos de comportamiento correctos.
  • Control de comandos complejos: mejora la capacidad del modelo para procesar comandos complejos a lo largo del tiempo.

Actualización del bot convencional al agente de motor personalizado

Si ya tiene un bot en Teams, puede actualizarlo a un agente de motor personalizado que admita streaming, citas y etiquetas de inteligencia artificial. Esta actualización alinea el bot con el paradigma de experiencia de usuario de IA conversacional y proporciona una experiencia coherente con los agentes declarativos.

Nota:

El agente de motor personalizado no se admite en Python.

Pasos de actualización:

lista de To-Do Documentos auxiliares
Actualización de las versiones del SDK de IA • Para JavaScript, actualice a la versión 1.6.1.
• Para C#, actualice a la versión 1.8.1.
Habilite el streaming para el bot. Stream mensajes de bot
Use etiquetas de IA para indicar mensajes generados por IA. Etiquetas de IA
Use citas para las referencias de origen. Citas

Agregar compatibilidad con Microsoft 365 Copilot Chat

Puede agregar compatibilidad con agentes de motor personalizados en Microsoft 365 Copilot Chat. Esto incluye compatibilidad con patrones asincrónicos, como mensajes de seguimiento y tareas de larga duración. Para obtener más información, consulte patrones asincrónicos.

Para admitir Microsoft 365 Copilot Chat, actualice el manifiesto de la aplicación:

  1. Agregue la copilotAgents propiedad con una subpropiedad customEngineAgents al manifiesto de la aplicación:

    "copilotAgents": { 
    "customEngineAgents": [ 
      { 
        "type": "bot", 
        "id": "<Bot-Id-Guid>" 
      } 
    ] 
  }

  2. Establezca en para bots y commandLists en el scopespersonal manifiesto de la aplicación:

    "bots": [ 
    { 
      "botId": "<Bot-Id-Guid>", 
      "scopes": [
          "personal",
          "team",
          "groupChat"
      ], 
      "commandLists": [ 
        { 
          "scopes": ["personal"], 
          "commands": [ 
            { 
              "title": "Sample prompt title", 
              "description": "Description of sample prompt" 
            } 
          ] 
        }, 
        { 
          "scopes": ["personal"], 
          "commands": [ 
            { 
              "title": "Sample prompt title", 
              "description": "Description of sample prompt" 
            } 
          ] 
        } 
      ], 
    } 
  ],

Nota:

  • Microsoft 365 Copilot Chat agrega una etiqueta generada por inteligencia artificial a cada respuesta del agente de motor personalizado.
  • Para los bots creados con Microsoft 365 Agents Toolkit (anteriormente Teams Toolkit) que desean admitir Microsoft 365 Copilot Chat, siga la guía paso a paso.
  • El inicio de sesión único (SSO) para agentes de motor personalizados está disponible pero no se admite para el cliente de Outlook. Consulte Actualización Microsoft Entra registro de aplicaciones para el inicio de sesión único.

Elevación del bot convencional para usar la inteligencia artificial

Puede actualizar el bot convencional existente para que tenga tecnología de inteligencia artificial. Agregar una capa de inteligencia artificial mejora el bot con características controladas por LLM. A continuación se muestra un ejemplo de integración de la capa de inteligencia artificial mediante el adaptador de Bot Framework y el app objeto .

Código JavaScript: Elevación de un bot convencional para usar la inteligencia artificial

// 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 el bot con el SDK de Bot Framework, puede migrar a la biblioteca de inteligencia artificial de Teams para desbloquear las características avanzadas de IA. La migración ofrece estas ventajas:

  • Sistema de inteligencia artificial avanzado para crear aplicaciones complejas de Teams con tecnología LLM.
  • Autenticación de usuario integrada para acceder a datos de usuario de terceros.
  • Aprovecha las conocidas herramientas y conceptos del SDK de Bot Framework.
  • Admite las api y herramientas llm más recientes.

Elija la guía de migración pertinente para el lenguaje del bot:

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 Muestra cómo LightBot entiende la intención del usuario y controla el bot ligero en función de los comandos. View View

Paso siguiente

Si desea intentar crear un agente de motor personalizado basado en escenarios mediante el kit de herramientas de agentes y la biblioteca de inteligencia artificial de Teams, seleccione lo siguiente:
Guía paso a paso avanzada

Si desea obtener información sobre las funcionalidades básicas de la biblioteca de inteligencia artificial de Teams, seleccione lo siguiente:
Descripción de la biblioteca de inteligencia artificial de Teams