Stream Botnachrichten

Artikel
11/18/2024

Hinweis

Das Streamen von Botnachrichten ist nur für Einzelchats und in der öffentlichen Entwicklervorschau verfügbar.
Das Streamen von Botnachrichten ist bei Funktionsaufrufen und dem OpenAI-Modell o1 nicht verfügbar.
Das Streamen von Botnachrichten wird im Web, desktop und mobil (Android) unterstützt. Es wird unter iOS nicht unterstützt.

Sie können Botnachrichten streamen, um die Antworten eines Bots als kleine Updates an den Benutzer zu übermitteln, während die vollständige Antwort generiert wird, um die Benutzerfreundlichkeit zu verbessern. Häufig benötigen Bots viel Zeit, um Antworten zu generieren, ohne die Benutzeroberfläche zu aktualisieren, was zu einer weniger ansprechenden Erfahrung führt.

Wenn Benutzer beobachten, wie der Bot ihre Anforderung in Echtzeit verarbeitet, kann dies ihre Zufriedenheit und ihr Vertrauen erhöhen. Diese wahrgenommene Reaktionsfähigkeit und Transparenz verbessert die Benutzerbindung und verringert den Abbruch von Konversationen mit dem Bot.

Streamingbotnachrichten verfügen über zwei Arten von Updates:

Informative Updates: Informative Updates werden als blaue Statusanzeige am unteren Rand des Chats angezeigt. Es informiert den Benutzer über die laufenden Aktionen des Bots, während eine Antwort generiert wird.
Antwortstreaming: Das Antwortstreaming wird als Eingabeindikator angezeigt. Es zeigt die Antwort des Bots an den Benutzer als kleine Updates an, während die vollständige Antwort generiert wird.

Sie können Streamingbotnachrichten in Ihrer App auf eine der folgenden Arten implementieren:

Stream mithilfe der Ki-Bibliothek von Teams.
Stream mithilfe der REST-API.

Stream Nachricht über die Teams KI-Bibliothek

Die Teams KI-Bibliothek bietet die Möglichkeit, Nachrichten für KI-gestützte Bots zu streamen. Streamingbotnachrichten helfen, die Antwortzeitverzögerung zu verringern, während das große Sprachmodell (LLM) die vollständige Antwort generiert. Zu den wichtigsten Faktoren, die zu einer langsamen Antwortzeit beitragen, gehören mehrere Vorverarbeitungsschritte, z. B. Retrieval-Augmented Generation (RAG) oder Funktionsaufrufe, und die Zeit, die der LLM benötigt, um eine vollständige Antwort zu generieren.

Hinweis

Streamingbotnachrichten sind bei Funktionsaufrufen nicht verfügbar.

Durch Streaming kann Ihr KI-Bot eine Benutzeroberfläche bieten, die für den Benutzer ansprechend und reaktionsfähig ist. Konfigurieren Sie die folgenden Features für das Streaming von Nachrichten für Ihre KI-gestützte App:

Aktivieren des Streamings für einen KI-Bot:

Botnachrichten können über das AI SDK gestreamt werden. Der KI-gestützte Bot sendet Blöcke an den Benutzer, während das Modell die Antwort generiert. Streamingnachrichten unterstützen Text. Anlagen-, KI-Bezeichnungs-, Feedbackschleifen- und Vertraulichkeitsbezeichnungen sind jedoch nur für die endgültige Streamingnachricht verfügbar.
Informative Nachricht festlegen:

Sie können eine informative Nachricht für Ihren KI-gestützten Bot definieren. Diese Meldung wird für den Benutzer jedes Mal angezeigt, wenn der Bot ein Update sendet. Hier sind einige Beispiele für informative Nachrichten, die Sie in Ihrer App festlegen können:
- Scannen durch Dokumente
- Zusammenfassen von Inhalten
- Suchen relevanter Arbeitselemente
Das folgende Beispiel zeigt die Informationsupdates in einem KI-gestützten Bot:
Formatieren Sie die endgültige gestreamte Nachricht:

Mithilfe des AI SDK können Textnachrichten und einfaches Markdown formatiert werden, während sie gestreamt werden. Für adaptive Karten, Bilder oder rich HTML kann die Formatierung jedoch angewendet werden, sobald die endgültige Nachricht abgeschlossen ist. Der Bot kann Anlagen nur im letzten gestreamten Block senden.

Das folgende Beispiel zeigt die Streamingantwort in einem KI-gestützten Bot:

Das folgende Beispiel zeigt die endgültige gestreamte Antwort in einem KI-gestützten Bot:
Aktivieren Sie KI-gestützte Features für die endgültige Nachricht:

Sie können die folgenden KI-gestützten Features für die endgültige Nachricht aktivieren, die vom Bot gesendet wird:
- Zitate: Die KI-Bibliothek von Teams enthält automatisch Zitate in den Antworten des Bots. Sie enthält Verweise auf die Quellen, die der Bot zum Generieren der Antwort verwendet hat. Es ermöglicht Benutzern, durch In-Text-Zitate und Verweise auf die Quelle zu verweisen.
- Vertraulichkeitsbezeichnung: Verwenden Sie Vertraulichkeitsbezeichnungen, um Benutzern zu helfen, die Vertraulichkeit einer Nachricht zu verstehen.
- Feedbackschleife: Auf diese Weise können Benutzer positives oder negatives Feedback zu den Botnachrichten geben.
- Generiert durch KI: Die Ki-Bibliothek von Teams enthält automatisch die Bezeichnung Generiert von KI in den Antworten des Bots. Mit dieser Bezeichnung können Benutzer erkennen, dass eine Nachricht mithilfe von KI generiert wurde.
Weitere Informationen zum Formatieren von KI-Botnachrichten finden Sie unter Botnachrichten mit KI-generiertem Inhalt.

Konfigurieren von Streamingbotnachrichten

Führen Sie die folgenden Schritte aus, um Streamingbotnachrichten zu konfigurieren:

Aktivieren des Streamings für einen KI-Bot:

a. Verwenden Sie die DefaultAugmentation -Klasse in der config.json Datei und in einer der folgenden Standard Anwendungsklassen Ihrer Bot-App:
- Für eine C#-Bot-App: Aktualisieren Sie Program.cs.
- Für eine JavaScript-App: Aktualisieren Sie index.ts.
- Für eine Python-App: Aktualisieren Sie bot.py.
b. Legen Sie in der OpenAIModel Deklaration auf true feststream.
Informative Nachricht festlegen: Geben Sie die informative Nachricht in der ActionPlanner Deklaration mithilfe der Konfiguration an StartStreamingMessage .
Formatieren Sie die endgültige gestreamte Nachricht:
- Legen Sie die Feedbackschleife im -Objekt innerhalb der AIOptions App-Deklaration um, und geben Sie einen Handler an.
  - Legen Sie für eine bot-App, die mit Python erstellt wurde, die Feedbackschleife zusätzlich zum AIOptions -Objekt im ActionPlannerOptions -Objekt fest.
- Legen Sie Anlagen im letzten Block mithilfe von EndStreamHandler innerhalb der ActionPlanner Deklaration fest.

Der folgende Codeausschnitt zeigt ein Beispiel für bot-Streamingnachrichten:

    // Create OpenAI Model
    builder.Services.AddSingleton<OpenAIModel > (sp => new(
        new OpenAIModelOptions(config.OpenAI.ApiKey, "gpt-4o")
        {
            LogRequests = true,
            Stream = true,              // Set stream toggle
        },
        sp.GetService<ILoggerFactory>()
    ));

ResponseReceivedHandler endStreamHandler = new((object sender, ResponseReceivedEventArgs args) =>
    {
        StreamingResponse? streamer = args.Streamer;

        if (streamer == null)
        {
            return;
        }

        AdaptiveCard adaptiveCard = new("1.6")
        {
            Body = [new AdaptiveTextBlock(streamer.Message) { Wrap = true }]
        };

        var adaptiveCardAttachment = new Attachment()
        {
            ContentType = "application/vnd.microsoft.card.adaptive",
            Content = adaptiveCard,
        };


        streamer.Attachments = [adaptiveCardAttachment];    // Set attachments

    });


    // Create ActionPlanner
    ActionPlanner<TurnState> planner = new(
        options: new(
            model: sp.GetService<OpenAIModel>()!,
            prompts: prompts,
            defaultPrompt: async (context, state, planner) =>
            {
                PromptTemplate template = prompts.GetPrompt("Chat");
                return await Task.FromResult(template);
            }
        )
        {
            LogRepairs = true,
            StartStreamingMessage = "Loading stream results...", // Set informative message
            EndStreamHandler = endStreamHandler // Set final chunk handler
        },
        loggerFactory: loggerFactory
    );

const model = new OpenAIModel({
    // ...Setup OpenAI or AzureOpenAI
    stream: true,                                         // Set stream toggle
});

const endStreamHandler: PromptCompletionModelResponseReceivedEvent = (ctx, memory, response, streamer) => {
    // ... Setup attachments
    streamer.setAttachments([...cards]);                      // Set attachments
};

const planner = new ActionPlanner({
    model,
    prompts,
    defaultPrompt: 'default',
    startStreamingMessage: 'Loading stream results...', // Set informative message
    endStreamHandler: endStreamHandler                  // Set final chunk handler
});

model = OpenAIModel(
        OpenAIModelOptions(api_key=config.OPENAI_KEY, default_model="gpt-4o", stream=True)
    )

def end_stream_handler(
    context: TurnContext,
    state: MemoryBase,
    response: PromptResponse[str],
    streamer: StreamingResponse,
):
    if not streamer:
        return

    card = CardFactory.adaptive_card(
        {
            "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
            "version": "1.6",
            "type": "AdaptiveCard",
            "body": [{"type": "TextBlock", "wrap": True, "text": streamer.message}],
        }
    )

    streamer.set_attachments([card])

planner=ActionPlanner(
                ActionPlannerOptions(
                    model=model,
                    prompts=prompts,
                    default_prompt="tools",
                    enable_feedback_loop=True,                                      # Enable the feedback loop
                    start_streaming_message="Loading streaming results...",         # Set the informative message
                    end_stream_handler=end_stream_handler,                          # Set the final chunk handler
                )
            ),

Benutzerdefinierte Planner und Modellentwicklung

Die StreamingResponse -Klasse ist die Hilfsklasse zum Streamen von Antworten an den Client. Es ermöglicht Ihnen, eine Reihe von Updates in einer einzigen Antwort zu senden, wodurch die Interaktion reibungsloser wird. Wenn Sie Ihr eigenes benutzerdefiniertes Modell verwenden, können Sie diese Klasse problemlos verwenden, um Antworten nahtlos zu streamen. Dies ist eine hervorragende Möglichkeit, den Benutzer zu engagieren.

Streamingbotnachrichten müssen die folgende Sequenz verwenden:

queueInformativeUpdate()
queueTextChunk()
endStream()

Nachdem Ihr Modell aufgerufen hat endStream(), wird der Stream beendet, und der Bot kann keine weiteren Updates mehr senden.

Im Folgenden finden Sie eine Liste mit anderen Methoden, die Sie zum Anpassen der App-Erfahrung verwenden können:

setAttachments
setSensitivityLabel
setFeedbackLoop
setGeneratedByAILabel

Einschränkungen für Azure OpenAI oder OpenAI

Wenn Ihr Bot die Streaming-API zu schnell aufruft, kann dies zu Problemen führen und die Streamingerfahrung unterbrechen. Um dies zu vermeiden, streamen Sie jeweils eine Nachricht in einem konsistenten Tempo. Ist dies nicht der Fall, wird die Anforderung möglicherweise gedrosselt. Puffern Sie die Token aus dem Modell für 1,5 bis 2 Sekunden, um ein reibungsloses Streaming sicherzustellen.
KI-gestützte Features wie Zitate, Vertraulichkeitsbezeichnungen, Feedbackschleifen und Generiert von KI-Bezeichnungen werden nur im letzten Abschnitt unterstützt. Zitate werden pro Textblock in der Warteschlange festgelegt.
Nur Rich-Text kann gestreamt werden.
Sie können nur eine informative Nachricht festlegen. Ihr Bot verwendet diese Nachricht für jedes Update wieder. Dazu gehören:
- Scannen durch Dokumente
- Zusammenfassen von Inhalten
- Suchen relevanter Arbeitselemente
Das Modell rendert die informative Nachricht nur am Anfang jeder nachricht, die vom LLM zurückgegeben wird.
Anlagen können nur im letzten Block gesendet werden.
Streaming ist mit den Funktionsaufrufen des AI SDK und dem AOAI- oder OAI-Modell o1 noch nicht verfügbar.
Dies sind die Anforderungen, die für das AI SDK verwendet werden streamSequence müssen:
- Die Sequenz muss mit der Zahl "1" beginnen.
- Nachfolgende Zahlen (außer final) müssen eine monoton steigende ganze Zahl sein (z. B. 1-2-3>>).
- Für die endgültige Nachricht streamSequence darf nicht festgelegt werden.

Stream Nachricht über die REST-API

Botnachrichten können über die REST-API gestreamt werden. Streamingnachrichten unterstützen Rich-Text und Zitate. Anlagen, KI-Bezeichnungen, Feedbackschaltflächen und Vertraulichkeitsbezeichnungen sind nur für die endgültige Streamingnachricht verfügbar. Weitere Informationen finden Sie unter Anlagen und Botnachrichten mit KI-generiertem Inhalt.

Wenn Ihr Bot Streaming über die REST-API aufruft, stellen Sie sicher, dass die nächste Streaming-API nur nach dem Empfang einer erfolgreichen Antwort des anfänglichen API-Aufrufs aufgerufen wird. Wenn Ihr Bot das SDK verwendet, überprüfen Sie, ob Sie ein NULL-Antwortobjekt von der Send-Aktivitätsmethode erhalten, um zu bestätigen, dass der vorherige Aufruf erfolgreich übertragen wurde.

Wenn Ihr Bot die Streaming-API zu schnell aufruft, treten möglicherweise Probleme auf, und das Streaming kann unterbrochen werden. Es wird empfohlen, dass Ihr Bot jeweils eine Nachricht streamt, um sicherzustellen, dass er die Streaming-API in einem konsistenten Tempo aufruft. Andernfalls wird die Anforderung möglicherweise gedrosselt. Puffern Sie die Token aus dem Modell für 1,5 bis zwei Sekunden, um einen reibungslosen Streamingprozess sicherzustellen. Es wird empfohlen, dass Ihr Bot jeweils eine Nachricht streamt, um sicherzustellen, dass er die Streaming-API in einem konsistenten Tempo aufruft. Andernfalls wird die Anforderung möglicherweise gedrosselt. Puffern Sie die Token aus dem Modell für 1,5 bis zwei Sekunden, um einen reibungslosen Streamingprozess sicherzustellen.

Im Folgenden sind die Eigenschaften für Streamingbotnachrichten aufgeführt:

Eigenschaft	Erforderlich	Beschreibung
`type`	✔️	Unterstützte Werte sind entweder `typing` oder `message`. • : `typing`Verwenden Sie beim Streamen der Nachricht. • `message`: Wird für die letzte gestreamte Nachricht verwendet.
`text`	✔️	Der Inhalt der Nachricht, die gestreamt werden soll.
`entities.type`	✔️	Muss `streamInfo` sein.
`entities.streamId`	✔️	`streamId` Starten Sie das Streaming aus der ersten Streaminganforderung.
`entities.streamType`		Typ der Streamingupdates. Unterstützte Werte sind , `informativestreaming`oder `final`. Der Standardwert ist `streaming`. `final` wird nur in der endgültigen Nachricht verwendet.
`entities.streamSequence`	✔️	Inkrementelle ganze Zahl für jede Anforderung.

Hinweis

Dies sind die Anforderungen für die Verwendung von streamSequence für REST-APIs:

Das erste muss die Zahl "1" sein.
Nachfolgende Zahlen (außer final) müssen eine monoton steigende ganze Zahl sein (z. B. 1-2-3>>).
Für die endgültige Nachricht streamSequence darf nicht festgelegt werden.

Führen Sie die folgenden Schritte aus, um das Streaming in Bots zu aktivieren:

Streaming starten
Fortsetzen des Streamings
Endgültiges Streaming

Streaming starten

Der Bot kann entweder eine informative oder eine Streamingnachricht als erste Kommunikation senden. Die Antwort enthält die streamId, die für die Ausführung nachfolgender Aufrufe wichtig ist.

Ihr Bot kann mehrere informative Aktualisierungen senden, während die Anforderung des Benutzers verarbeitet wird, z. B . Scannen durch Dokumente, Zusammenfassung von Inhalten und Relevante Arbeitselemente gefunden. Sie können diese Updates senden, bevor Ihr Bot die endgültige Antwort an den Benutzer generiert.


//Ex: A bot sends the first request with content & the content is informative loading message.

POST /conversations/<conversationId>/activities HTTP/1.1 
{
  "type": "typing",
  "serviceurl": "https://smba.trafficmanager.net/amer/",
  "channelId": "msteams",
  "from": {
    "id": "<botId>",
    "name": "<BotName>"
  },
  "conversation": {
    "conversationType": "personal",
    "id": "<conversationId>"
  },
  "recipient": {
    "id": "<recipientId>",
    "name": "<recipientName>",
    "aadObjectId": "<recipient aad objecID>"
  },
  "locale": "en-US",
  "text": "Searching through documents...", //(required) first informative loading message.
  "entities":[
    {
      "type": "streaminfo",
      "streamType": "informative", // informative or streaming; default= streaming.
      "streamSequence": 1 // (required) incremental integer; must be present for start and continue streaming request, but must not be set for final streaming request.
    }
  ],
}

201 created { "id": "a-0000l" } // return stream id

Die folgende Abbildung zeigt ein Beispiel für das Starten des Streamings:

Fortsetzen des Streamings

Verwenden Sie die , die streamId Sie von der ersten Anforderung erhalten haben, um entweder informative nachrichten oder Streamingnachrichten zu senden. Sie können mit informativen Updates beginnen und später zum Antwortstreaming wechseln , wenn die endgültige Antwort bereit ist.

Beginnen Sie mit informativen Updates

Wenn Ihr Bot eine Antwort generiert, senden Sie informative Aktualisierungen an den Benutzer, z. B . Scannen durch Dokumente, Zusammenfassen von Inhalten und Gefunden relevante Arbeitselemente. Stellen Sie sicher, dass Sie nachfolgende Aufrufe erst ausführen, nachdem der Bot eine erfolgreiche Antwort von den vorherigen Aufrufen erhalten hat.


// Ex: A bot sends the second request with content & the content is informative loading message.

POST /conversations/<conversationId>/activities HTTP/1.1 
{
  "type": "typing",
  " serviceurl": "https://smba.trafficmanager.net/amer/",
  "channelId": "msteams",
  "from": {
    "id": "<botId>",
    "name": "<BotName>"
  },
  "conversation": {
    "conversationType": "personal",
    "id" : "<conversationId>"
  },
  "recipient": {
    "id": "<recipientId>",
    "name": "<recipientName>",
    "aadObjectId": "<recipient aad objecID>"
  },
  "locale": "en -US",
  "text ": "Searching through emails...", // (required) second informative loading message.
  "entities":[
    {
      "type": "streaminfo",
      "streamId": "a-0000l", // // (required) must be present for any subsequent request after the first chunk.
      "streamType": "informative", // informative or streaming; default= streaming.
      "streamSequence": 2 // (required) incremental integer; must be present for start and continue streaming request, but must not be set for final streaming request.
    }
  ],
} 
202 0K { }

Die folgende Abbildung zeigt ein Beispiel für einen Bot, der informative Updates bereitstellt:

Wechseln zum Antwortstreaming

Wenn Ihr Bot bereit ist, die endgültige Nachricht für den Benutzer zu generieren, wechseln Sie von der Bereitstellung informativer Updates zum Antwortstreaming. Für jedes Antwortstreamingupdate sollte der Nachrichteninhalt die neueste Version der endgültigen Nachricht sein. Dies bedeutet, dass Ihr Bot alle neuen Token enthalten sollte, die von den llMs (Large Language Models, große Sprachmodelle) generiert werden. Fügen Sie diese Token an die vorherige Nachrichtenversion an, und senden Sie sie dann an den Benutzer.

Wenn der Bot eine Streaminganforderung sendet, stellen Sie sicher, dass der Bot die Anforderung mit einer Mindestrate von einer Anforderung pro Sekunde sendet.


// Ex: A bot sends the third request with content & the content is actual streaming content.

POST /conversations/<conversationId>/activities HTTP/1.1
{
  "type": "typing",
  " serviceurl" : "https://smba.trafficmanager.net/amer/ ",
  "channelId": "msteams",
  "from": {
    "id": "<botId>",
    "name": "<BotName>"
  },
  "conversation": {
    "conversationType": "personal",
    "id" : "<conversationId>"
  },
  "recipient": {
    "id" : "<recipientId>",
    "name": "<recipientName>",
    "aadObjectId": "<recipient aad objecID>"
  },
  "locale": "en-US" ,
  "text ": "A brown fox", // (required) first streaming content.
  "entities":[
    {
      "type": "streaminfo",
      "streamId": "a-0000l", // // (required) must be present for any subsequent request after the first chunk.
      "streamType": "streaming", // informative or streaming; default= streaming.
      "streamSequence": 3 // (required) incremental integer; must be present for start and continue streaming request, but must not be set for final streaming request.
    }
  ],
}
202 0K{ }


// Ex: A bot sends the fourth request with content & the content is actual streaming content.

POST /conversations/<conversationId>/activities HTTP/1.1
{
  "type": "typing",
  " serviceurl" : "https://smba.trafficmanager.net/amer/ ",
  "channelId": "msteams",
  "from": {
    "id": "<botId>",
    "name": "<BotName>"
  },
  "conversation": {
    "conversationType": "personal",
    "id" : "<conversationId>"
  },
  "recipient": {
    "id" : "<recipientId>",
    "name": "<recipientName>",
    "aadObjectId": "<recipient aad objecID>"
  },
  "locale": "en-US" ,
  "text ": "A brown fox jumped over the fence", // (required) first streaming content.
  "entities":[
    {
      "type": "streaminfo",
      "streamId": "a-0000l", // // (required) must be present for any subsequent request after the first chunk.
      "streamType": "streaming", // informative or streaming; default= streaming.
      "streamSequence": 4 // (required) incremental integer; must be present for start and continue streaming request, but must not be set for final streaming request.
    }
  ],
}
202 0K{ }

Die folgende Abbildung zeigt ein Beispiel für einen Bot, der Updates in Blöcken bereitstellt:

Endgültiges Streaming

Nachdem Ihr Bot die Generierung der Nachricht abgeschlossen hat, senden Sie das Endstreamingsignal zusammen mit der endgültigen Nachricht. Für die letzte Nachricht ist messagedie type der -Aktivität . Hier legt der Bot alle Felder fest, die für die reguläre Nachrichtenaktivität zulässig sind, aber final der einzige zulässige Wert für streamTypeist.


// Ex: A bot sends the second request with content && the content is informative loading message.

POST /conversations/<conversationId>/activities HTTP/1.1
{
  "type": "message",
  " serviceurl" : "https://smba.trafficmanager.net/amer/ ",
  "channelId": "msteams",
  "from": {
    "id": "<botId>",
    "name": "<BotName>"
  },
  "conversation": {
    "conversationType": "personal",
    "id" : "<conversationId>"
  },
  "recipient": {
    "id" : "recipientId>",
    "name": "<recipientName>",
    "aadObjectId": "<recipient aad objecID>"
  },
  "locale": "en-US",
  "text ": "A brown fox jumped over the fence.", // (required) first streaming content.
  "entities":[
    {
      "type": "streaminfo",
      "streamId": "a-0000l", // // (required) must be present for any subsequent request after the first chunk.
      "streamType": "final", // (required) final is only allowed for the last message of the streaming.
    }
  ],
  }
202 0K{ }

Die folgende Abbildung zeigt ein Beispiel für die endgültige Antwort des Bots:

Antwortcodes

Im Folgenden finden Sie die Erfolgs- und Fehlercodes:

Erfolgscodes

HTTP-status-Code	Rückgabewert	Beschreibung
`201`	`streamId`, dies ist dasselbe wie `activityId{"id":"1728640934763"}`	Der Bot gibt diesen Wert nach dem Senden der ersten Streaminganforderung zurück. Für alle nachfolgenden Streaminganforderungen ist erforderlich `streamId` .
`202`	`{}`	Erfolgscode für nachfolgende Streaminganforderungen.

Fehlercodes

HTTP-status-Code	Fehlercode	Fehlermeldung	Beschreibung
`202`	`ContentStreamSequenceOrderPreConditionFailed`	`PreCondition failed exception when processing streaming activity.`	Einige Streaminganforderungen können außerhalb der Reihenfolge eingehen und verworfen werden. Die neueste Streaminganforderung, die von `streamSequence`bestimmt wird, wird verwendet, wenn Anforderungen ungeordnet empfangen werden. Stellen Sie sicher, dass jede Anforderung sequenziell gesendet wird.
`400`	`BadRequest`	Je nach Szenario können verschiedene Fehlermeldungen auftreten, z. B. `Start streaming activities should include text`	Die eingehende Nutzlast entspricht nicht den erforderlichen Werten oder enthält sie nicht.
`403`	`ContentStreamNotAllowed`	`Content stream is not allowed`	Das Streaming-API-Feature ist für den Benutzer oder Bot nicht zulässig.
`403`	`ContentStreamNotAllowed`	`Content stream is not allowed on an already completed streamed message`	Ein Bot kann nicht kontinuierlich für eine Nachricht streamen, die bereits gestreamt und abgeschlossen wurde.
`403`	`ContentStreamNotAllowed`	`Content stream finished due to exceeded streaming time.`	Der Bot konnte den Streamingprozess nicht innerhalb des strengen Zeitlimits von zwei Minuten abschließen.
`403`	`ContentStreamNotAllowed`	`Message size too large`	Der Bot hat eine Nachricht gesendet, die die aktuelle Größenbeschränkung für Nachrichten überschreitet.
`429`	–	`API calls quota exceeded`	Die Anzahl der vom Bot gestreamten Nachrichten hat das Kontingent überschritten.

Codebeispiel

Beispielname	Beschreibung	Node.js	C#	Python
Beispiel eines Teams-Streamingbots	In diesem Codebeispiel wird veranschaulicht, wie Sie einen Bot erstellen, der mit einer LLM verbunden ist, und Nachrichten über Teams senden.	–	View	–
Bot für Unterhaltungsstreaming	Dies ist ein Konversationsstreamingbot mit teams KI-Bibliothek.	View	View	Anzeigen

Freigeben über

Stream Botnachrichten

Stream Nachricht über die Teams KI-Bibliothek

Konfigurieren von Streamingbotnachrichten

Benutzerdefinierte Planner und Modellentwicklung

Einschränkungen für Azure OpenAI oder OpenAI

Stream Nachricht über die REST-API

Streaming starten

Fortsetzen des Streamings

Beginnen Sie mit informativen Updates

Wechseln zum Antwortstreaming

Endgültiges Streaming

Antwortcodes

Erfolgscodes

Fehlercodes

Codebeispiel

Siehe auch

Zusätzliche Ressourcen