Freigeben über

Erstellen mit der Teams KI-Bibliothek

  • Artikel

Die KI-Bibliothek von Teams vereinfacht das Erstellen intelligenter Microsoft Teams-Anwendungen mit KI-Komponenten. Es bietet APIs für den Datenzugriff und die erstellung benutzerdefinierter Ui. Sie können die Eingabeaufforderungsverwaltung und die Sicherheitsmoderation problemlos integrieren und Bots mit OpenAI oder Azure OpenAI für eine KI-gesteuerte Erfahrung erstellen.

Ersteinrichtung

Die KI-Bibliothek von Teams basiert auf dem Bot Framework SDK und nutzt dessen Grundlagen, um eine Erweiterung der Bot Framework SDK-Funktionen anzubieten. Im Rahmen der ersteinrichtung ist es wichtig, die Funktionen des Bot Framework SDK zu importieren. Die Adapterklasse, die die Konnektivität mit den Kanälen verarbeitet, wird aus dem Bot Framework SDK importiert.

Beispielcodereferenz

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

Importieren der Teams KI-Bibliothek

Importieren Sie alle Klassen aus, um Ihren Bot zu erstellen und die Ki-Bibliotheksfunktionen von @microsoft/teams-ai Teams zu verwenden.

Beispielcodereferenz

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

Erstellen von KI-Komponenten

Erstellen von KI-Komponenten in einer vorhandenen Bot-App oder in einer neuen Bot Framework-App:

  • OpenAIModel: Die OpenAIModel-Klasse bietet eine Möglichkeit, auf die OpenAI-API oder einen anderen Dienst zuzugreifen, der dem OpenAI-REST-Format entspricht. Es ist sowohl mit OpenAI- als auch mit Azure OpenAI-Sprachmodellen kompatibel.

  • Eingabeaufforderungs-Manager: Der Eingabeaufforderungs-Manager übernimmt die Eingabeaufforderungserstellung. Es ruft Funktionen auf und fügt aus Ihrem Code in die Eingabeaufforderung ein. Der Konversationszustand und der Benutzerzustand werden automatisch in die Eingabeaufforderung kopiert.

  • ActionPlanner: Der ActionPlanner ist die Standard Komponente, die Ihr LLM (Large Language Model) aufruft und mehrere Features zum Verbessern und Anpassen Ihres Modells enthält. Er ist für das Generieren und Ausführen von Plänen verantwortlich, die auf der Eingabe des Benutzers und den verfügbaren Aktionen basieren.

Beispielcodereferenz.

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

Definieren von Speicher und Anwendung

Das Anwendungsobjekt verwaltet automatisch den Konversations- und Benutzerzustand Ihres Bots.

  • Speicher: Erstellen Sie einen Speicheranbieter, um die Konversation und den Benutzerstatus für Ihren Bot zu speichern.

  • Anwendung: Registrieren Sie Aktionen oder Aktivitätshandler für die App in der Application -Klasse, die alle informationen und botlogik enthält, die für Ihre App erforderlich sind.

Beispielcodereferenz

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

TurnStateFactory ermöglicht es Ihnen, eine benutzerdefinierte Zustandsklasse für Ihre App zu erstellen, um zusätzliche Informationen oder Logik für Ihren Bot zu speichern. Sie können Standardeigenschaften wie Benutzereingaben, Botausgaben oder Unterhaltungsverlauf überschreiben. Um sie zu verwenden, erstellen Sie eine Klasse, die den Standarddurchlaufzustand erweitert, und übergeben Sie eine Funktion, die eine instance Ihrer Klasse an den App-Konstruktor erstellt.

Registrieren von Datenquellen

Eine Vektordatenquelle vereinfacht das Hinzufügen von RAG zu jeder Eingabeaufforderung. Registrieren Sie eine benannte Datenquelle beim Planner, und geben Sie sie in der Datei der Eingabeaufforderung config.json an, um die Eingabeaufforderung zu erweitern. Dadurch kann KI relevante Informationen aus externen Quellen wie Vektordatenbanken oder kognitiver Suche in die Eingabeaufforderung einfügen.

Beispielcodereferenz

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

Einbettungen

Eine Einbettung ist ein von einem LLM generierter Vektor, der Text darstellt und dessen semantische Bedeutung in einer kompakten Form erfasst. Es wird in Aufgaben wie Textklassifizierung, Stimmungsanalyse und Suche verwendet. Das Modell zum Generieren von Einbettungen unterscheidet sich von den grundlegenden LLMs. Das OpenAI-Modell text-embedding-ada-002 gibt beispielsweise eine Liste von 1536 Zahlen zurück, die den Eingabetext darstellen. Diese Einbettungen werden in einer Vektordatenbank gespeichert. In einem benutzerdefinierten Engine-Agent kann das RAG-Muster implementiert werden, indem relevante Daten aus der Vektordatenbank abgerufen und die Eingabeaufforderung um diese Informationen erweitert wird.


Im Folgenden finden Sie ein Beispiel für VectraDataSource und 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 };
    }

}

Eingabeaufforderungen

Prompts sind Textelemente, die zum Erstellen von Konversationserfahrungen verwendet werden, z. B. das Starten von Unterhaltungen, das Stellen von Fragen und das Generieren von Antworten. Sie vereinfachen den Prozess der Erstellung ansprechender Interaktionen. Ein neues objektbasiertes Eingabeaufforderungssystem unterteilt Eingabeaufforderungen in Abschnitte mit jeweils einem eigenen Tokenbudget, das entweder ein fester Satz oder proportional zu den verbleibenden Token sein kann. Sie können Eingabeaufforderungen sowohl für die APIs im Textvervollständigungs- als auch für die Chatvervollständigungs-APIs generieren.

Befolgen Sie die folgenden Richtlinien, um effektive Eingabeaufforderungen zu erstellen:

  • Stellen Sie Anweisungen, Beispiele oder beides bereit.
  • Stellen Sie qualitativ hochwertige Daten mit ausreichendEn Beispielen sicher, und lesen Sie sie korrektur. Während das Modell Rechtschreibfehler identifizieren kann, kann es von Absichtlichkeit bei Rechtschreibfehlern ausgehen, was sich auf Die Antworten auswirkt.
  • Passen Sie die Eingabeaufforderungseinstellungen mit temperature und top_p an, um die Antwort des Modells zu steuern. Eine höhere Temperatur wie 0,8 macht die Ausgabe zufällig, während niedriger wie 0,2 die Ausgabe fokussiert und deterministisch macht.

Erstellen Sie einen Ordner namens prompts, und definieren Sie dort Ihre Eingabeaufforderungen. Wenn der Benutzer mit dem Bot über eine Texteingabeaufforderung interagiert, antwortet er mit einer Textvollständigung. Erstellen Sie die folgenden Dateien im Ordner "prompts":

  • skprompt.txt: Enthält den Eingabeaufforderungstext und unterstützt Vorlagenvariablen und -funktionen.

  • config.json: Enthält die Einstellungen des Eingabeaufforderungsmodells, mit denen sichergestellt wird, dass bot-Antworten Ihren Anforderungen entsprechen.

    Beispielcodereferenz

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

Abfrageparameter

Die folgende Tabelle enthält die Abfrageparameter:

Wert Beschreibung
model ID des zu verwendenden Modells.
completion_type Der Typ der Vervollständigung, die Sie für Ihr Modell verwenden möchten. Bei einer Eingabeaufforderung gibt das Modell einen oder mehrere vorhergesagte Vervollständigungen zusammen mit den Wahrscheinlichkeiten alternativer Token an jeder Position zurück.
Unterstützte Optionen: chat und text.
Standard: chat.
include_history Boolescher Wert Wenn Sie den Verlauf einschließen möchten. Jede Eingabeaufforderung erhält einen eigenen separaten Konversationsverlauf, um sicherzustellen, dass das Modell nicht verwechselt wird.
include_input Boolescher Wert Wenn Sie die Eingabe des Benutzers in die Eingabeaufforderung einschließen möchten.
max_input_tokens Die maximale Anzahl von Token für die Eingabe. Die maximale Anzahl unterstützter Token beträgt 4000.
max_tokens Die maximale Anzahl von Token, die beim Abschluss generiert werden sollen. Die Tokenanzahl Ihrer Eingabeaufforderung plus max_tokens darf die Kontextlänge des Modells nicht überschreiten.
temperature Die Temperatur der Stichprobenentnahme kann zwischen 0 und 2 verwendet werden. Ein höherer Wert wie 0,8 macht die Ausgabe zufälliger, während ein niedrigerer Wert wie 0,2 sie fokussierter und deterministischer macht.
top_p Eine Alternative zur Stichprobenentnahme mit Temperatur, die als Kernstichprobe bezeichnet wird, bei der das Modell die Ergebnisse der Token mit top_p der Wahrscheinlichkeitsmasse berücksichtigt. Daher bedeutet 0,1, dass nur die Token berücksichtigt werden, die die höchste Wahrscheinlichkeitsmasse von 10 % enthalten.
presence_penalty Zahl zwischen -2,0 und 2,0. Positive Werte benachteiligen neue Token basierend darauf, ob sie bisher im Text angezeigt werden, wodurch die Wahrscheinlichkeit des Modells erhöht wird, über neue Themen zu sprechen.
frequency_penalty Zahl zwischen -2,0 und 2,0. Positive Werte benachteiligen neue Token basierend auf ihrer bisherigen Häufigkeit im Text und verringern die Wahrscheinlichkeit, dass das Modell dieselbe Zeile wortwörtlich wiederholt.
stop_sequences Bis zu vier Sequenzen, in denen die API keine weiteren Token mehr generiert. Der zurückgegebene Text enthält nicht die Stoppsequenz.
augmentation_type Der Typ der Erweiterung. Unterstützte Werte sind sequence, monologueund tools.

Eingabeaufforderungsverwaltung

Die Eingabeaufforderungsverwaltung passt die Größe und den Inhalt von Eingabeaufforderungen basierend auf dem Tokenbudget und den Datenquellen an. Für einen Bot mit einem Grenzwert von 4.000 Token, bei dem 2.800 Token für die Eingabe und 1.000 Token für die Ausgabe vorgesehen sind, verwaltet das Modell das Kontextfenster, um innerhalb von 3.800 Token zu bleiben. Sie beginnt mit 100 Texttoken und fügt 1.200 Token aus Datenquellen hinzu. Es ordnet die verbleibenden 1.500 Token dem Unterhaltungsverlauf und der Eingabe zu und stellt sicher, dass das Modell niemals 2.800 Token überschreitet.

Eingabeaufforderungsaktionen

Pläne ermöglichen es dem Modell, Aktionen auszuführen oder auf den Benutzer zu reagieren. Sie können ein Schema des Plans erstellen und eine Liste von Aktionen hinzufügen, die Sie unterstützen, um eine Aktion auszuführen und Argumente zu übergeben. Der OpenAI-Endpunkt bestimmt die erforderlichen Aktionen, extrahiert Entitäten und übergibt sie als Argumente an den Aktionsaufruf.

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

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

Eingabeaufforderungsvorlage

Eine Eingabeaufforderungsvorlage ist eine einfache und leistungsstarke Möglichkeit zum Definieren und Zusammenstellen von KI-Funktionen mithilfe von Nur-Text. Sie können Eingabeaufforderungen in natürlicher Sprache erstellen, Antworten generieren, Informationen extrahieren, andere Eingabeaufforderungen aufrufen oder textbasierte Aufgaben ausführen.

Die Sprache unterstützt Features, mit denen Sie Variablen einschließen, externe Funktionen aufrufen und Parameter an Funktionen übergeben können. Sie müssen keinen Code schreiben oder externe Bibliotheken importieren. Verwenden Sie einfach die geschweiften Klammern {{...}} , um Ausdrücke in Ihre Eingabeaufforderungen einzubetten. Teams analysiert Ihre Vorlage und führt die zugrunde liegende Logik aus. Auf diese Weise können Sie KI mit minimalem Aufwand und maximaler Flexibilität problemlos in Ihre Apps integrieren.

  • {{function}}: Ruft eine registrierte Funktion auf und fügt deren Rückgabewertzeichenfolge ein.

  • {{$input}}: Fügt den Nachrichtentext ein. Der Wert wird von state.temp.input abgerufen.

  • {{$state.[property]}}: Fügt Zustandseigenschaften ein.

Aktionen

Aktionen behandeln Ereignisse, die von KI-Komponenten ausgelöst werden.

FlaggedInputAction und FlaggedOutputAction sind die integrierten Aktionshandler für die Behandlung der Moderatorflags. Wenn der Moderator eine eingehende Nachrichteneingabe kennzeichnet, leitet der Moderator an den FlaggedInputAction Handler um, und sendet context.sendActivity eine Nachricht über das Flag an den Benutzer. Wenn Sie die Aktion beenden möchten, müssen Sie hinzufügen AI.StopCommandName.

Beispielcodereferenz

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

Registrieren von Aktionshandlern

Aktionshandler helfen Benutzern, die Ziele zu erreichen, die in den Benutzerabsichten gemeinsam verwendet werden. Einer der wichtigsten Aspekte bei Aktionshandlern ist, dass Sie zuerst die Aktionen in den Eingabeaufforderungen registrieren und dann einen Handler für jede in der Eingabeaufforderung aufgeführte Aktion registrieren müssen, einschließlich der unbekannten Aktionen.

Im folgenden Beispiel für einen leichten Bot haben wir die LightsOnAktion , LightsOffund Pause . Jedes Mal, wenn eine Aktion aufgerufen wird, geben Sie ein zurück string. Wenn der Bot die Zeit zurückgeben muss, müssen Sie die Zeit nicht analysieren und in eine Zahl konvertieren. Die PauseParameters -Eigenschaft stellt sicher, dass zeit im Zahlenformat zurückgegeben wird, ohne die Eingabeaufforderung anzuhalten.

Beispielcodereferenz

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

Die Erweiterung von Sequenzen, Monologen oder Tools verhindert, dass das Modell ungültige Funktionsnamen, Aktionsnamen oder Parameter halluziniert. Erstellen Sie eine Aktionsdatei für Folgendes:

  • Definieren von Aktionen für die Eingabeaufforderungserweiterung
  • Geben Sie an, wann Aktionen ausgeführt werden sollen.

Die Sequenzerweiterung eignet sich ideal für mehrstufige oder komplexe Aufgaben, während die Monologerweiterung für Aufgaben geeignet ist, die natürliches Sprachverständnis, Flexibilität und Kreativität erfordern.

Im folgenden Beispiel für einen leichten Bot enthält die actions.json Datei eine Liste aller Aktionen, die der Bot ausführen kann:

[
    {
        "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: Name der Aktion. Erforderlich.
  • description: Beschreibung der Aktion. Optional.
  • parameters: Fügen Sie ein JSON-Schemaobjekt der erforderlichen Parameter hinzu.

Die Feedbackschleife ist die Antwort eines Modells, um die Antwort auf Ihre Frage zu überprüfen, zu korrigieren oder zu verfeinern. Wenn Sie eine sequence Erweiterung verwenden, können Sie die Schleife deaktivieren, um sich vor versehentlichen Schleifen zu schützen:

  • Sie können in der AIOptions Definition auf false festlegenallow_looping?.
  • Sie können in der index.ts Datei auf 0 festlegenmax_repair_attempts.

Verwalten des Verlaufs

Sie können die MaxHistoryMessages Argumente und MaxConversationHistoryTokens verwenden, damit die KI-Bibliothek Ihren Verlauf automatisch verwalten kann.

Rückkopplungsschleife

Eine Feedbackschleife hilft bei der Überwachung und Verbesserung der Interaktionen des Bots, was zu effektiveren und benutzerfreundlicheren Anwendungen führt. Feedback wird verwendet, um den Bot anzupassen und zu verbessern, um die Anforderungen und Erwartungen der Benutzer zu erfüllen. Eine Feedbackschleife umfasst Folgendes:

  • Reparatur Loop: Löst aus, wenn die Antwort des Modells unzureichend ist. Die Konversationsverlaufs-Forks, sodass das System verschiedene Lösungen ausprobieren kann, ohne die Standard Unterhaltung zu beeinträchtigen.
  • Überprüfung: Überprüft die korrigierte Antwort und setzt sie erneut in die Standard Konversation ein, wenn die Antwort erfolgreich überprüft wurde.
  • Aus Fehlern lernen: Das Modell lernt aus korrekten Verhaltensbeispielen, um ähnliche Fehler in Zukunft zu vermeiden.
  • Komplexe Befehle verarbeiten: Das Modell kann komplexere Befehle verarbeiten, nachdem es aus seinen Fehlern gelernt hat.

Verbessern Ihres herkömmlichen Bots zur Verwendung von KI

Sie können Ihren vorhandenen konventionellen Bot so erweitern, dass er von KI unterstützt wird. Nachdem Sie Ihren Bot erstellt haben, können Sie eine KI-Ebene hinzufügen, um KI-gestützte Features für Ihren Bot zu aktivieren.

Der folgende Codeausschnitt veranschaulicht, wie Sie einem Bot KI-Komponenten hinzufügen können. In diesem Beispiel verwendet der Bot den Bot-Framework-Adapter, um eingehende Anforderungen zu verarbeiten, und führt dann die KI-Ebene mithilfe des -Objekts aus app .

// Create AI components
const model = new OpenAIModel({
    // OpenAI Support
    apiKey: process.env.OPENAI_KEY!,
    defaultModel: 'gpt-4o',

    // Azure OpenAI Support
    azureApiKey: process.env.AZURE_OPENAI_KEY!,
    azureDefaultDeployment: 'gpt-4o',
    azureEndpoint: process.env.AZURE_OPENAI_ENDPOINT!,
    azureApiVersion: '2023-03-15-preview',

    // Request logging
    logRequests: true
});

const prompts = new PromptManager({
    promptsFolder: path.join(__dirname, '../src/prompts')
});

// Define a prompt function for getting the current status of the lights
prompts.addFunction('getLightStatus', async (context: TurnContext, memory: Memory) => {
    return memory.getValue('conversation.lightsOn') ? 'on' : 'off';
});

const planner = new ActionPlanner({
    model,
    prompts,
    defaultPrompt: 'tools'
});

// Define storage and application
const storage = new MemoryStorage();
const app = new Application<ApplicationTurnState>({
    storage,
    ai: {
        planner
    }
});

app.ai.action('LightStatus', async (context: TurnContext, state: ApplicationTurnState) => {
    const status = state.conversation.lightsOn ? 'on' : 'off';
    return `the lights are ${status}`;
});

// Register action handlers
app.ai.action('LightsOn', async (context: TurnContext, state: ApplicationTurnState) => {
    state.conversation.lightsOn = true;
    await context.sendActivity(`[lights on]`);
    return `the lights are now on`;
});

app.ai.action('LightsOff', async (context: TurnContext, state: ApplicationTurnState) => {
    state.conversation.lightsOn = false;
    await context.sendActivity(`[lights off]`);
    return `the lights are now off`;
});

interface PauseParameters {
    time: number;
}

app.ai.action('Pause', async (context: TurnContext, state: ApplicationTurnState, parameters: PauseParameters) => {
    await context.sendActivity(`[pausing for ${parameters.time / 1000} seconds]`);
    await new Promise((resolve) => setTimeout(resolve, parameters.time));
    return `done pausing`;
});

// Listen for incoming server requests.
server.post('/api/messages', async (req, res) => {
    // Route received a request to adapter for processing
    await adapter.process(req, res as any, async (context) => {
        // Dispatch to application for routing
        await app.run(context);
    });
});

Migrieren Ihres Bots zur Verwendung der Teams KI-Bibliothek

Wenn Sie Ihre Bot-App mit dem Bot Framework SDK erstellt haben, können Sie zur Teams KI-Bibliothek wechseln, um die erweiterten KI-Features zu verwenden. Diese Migration bietet die folgenden Vorteile:

  • Erweitertes KI-System zum Erstellen komplexer Teams-Anwendungen, die von LLM unterstützt werden.
  • Die Benutzerauthentifizierung ist in die Bibliothek integriert, wodurch die Einrichtung vereinfacht wird.
  • Basiert auf Bot Framework SDK-Tools und -Konzepten, sodass das vorhandene Wissen übertragbar ist.
  • Unterstützt die neuesten Tools und APIs im LLM-Bereich.

In der Teams KI-Bibliothek ersetzt das Application Objekt das herkömmliche Objekt und unterstützt im Vergleich zur vererbungsbasierten ActivityHandlerActivityHandler Klasse einen einfacheren, fließenden Stil der Boterstellung. Es enthält integrierte Unterstützung für:

  • Aufrufen des Teams KI-Bibliothekssystems zum Erstellen von Bots, die LLM und andere KI-Funktionen verwenden.
  • Konfigurieren der Benutzerauthentifizierung für den Zugriff auf Benutzerdaten von Drittanbietern

Verwenden Sie eine der folgenden Optionen, um Ihre Bot-App zur Verwendung der Teams KI-Bibliothek zu migrieren:

Migrieren einer Bot Framework SDK-App ... So verwenden Sie die Ki-Bibliothek von Teams ...
Eine bot-App, die mit JavaScript erstellt wurde Migration
Eine bot-App, die mit C erstellt wurde# Migration
Eine Bot-App mit Python Migration

Codebeispiel

Beispielname Beschreibung .NET Node.js
Action mapping lightbot In diesem Beispiel wird veranschaulicht, wie lightBot die Benutzerabsicht versteht und Befehle genau interpretiert, um den Light-Bot mühelos zu steuern. View View

Nächster Schritt

Grundlegendes zur Ki-Bibliothek von Teams