Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Inferenz mithilfe der Converse-API
Die Converse-API ist nur auf dem `bedrock-runtime` Endpunkt verfügbar.
Sie können mit der Converse-API von Amazon Bedrock Konversationsanwendungen erstellen, die Nachrichten an ein Amazon-Bedrock-Modell senden und von ihm empfangen. Beispielsweise können Sie einen Chatbot erstellen, der eine Konversation über mehrere Runden führt und je nach Bedarf eine Persona- oder Tonanpassung vornimmt, z. B. einen hilfsbereiten Assistenten für den technischen Support.
Um die Converse API zu verwenden, verwenden Sie die Operationen [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) oder [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)(für Streaming-Antworten), um Nachrichten an ein Modell zu senden. Es ist möglich, die vorhandenen Basisinferenzoperationen ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) für Konversationsanwendungen zu verwenden. Wir empfehlen jedoch den Einsatz der Converse-API, da sie eine konsistente API bietet, die mit allen Amazon-Bedrock-Modellen funktioniert, die Nachrichten unterstützen. Das bedeutet, dass Sie Code nur einmal schreiben müssen und ihn mit verschiedenen Modellen verwenden können. Sollte ein Modell eindeutige Inferenzparameter aufweisen, können Sie mit der Converse-API diese eindeutigen Parameter in einer modellspezifischen Struktur zu übergeben.
Sie können die Converse-API verwenden, um die [Verwendung des Tools](tool-use.md) und den [Integritätsschutz](guardrails-use-converse-api.md) in Ihren Anwendungen zu implementieren.
**Anmerkung**
Mit Mistral AI- und Meta-Modellen bettet die Converse-API Ihre Eingaben in eine modellspezifische Promptvorlage ein, die Konversationen ermöglicht.
Einschränkungen gelten für die folgenden Operationen:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, und`ConverseStream`. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
Nachfolgend finden Sie einige Codebeispiele:
+ Python-Beispiele für dieses Thema – [Converse API-BeispieleConverse API-Beispiele (verschoben)](conversation-inference-examples.md)
+ Verschiedene Sprachen und Modelle – [Codebeispiele für Amazon Bedrock Runtime mit AWS SDKs](service_code_examples_bedrock-runtime.md)
+ Java-Tutorial – [Leitfaden für Java-Entwickler für die neue Converse-API von Bedrock](https://community.aws/content/2hUiEkO83hpoGF5nm3FWrdfYvPt/amazon-bedrock-converse-api-java-developer-guide)
+ JavaScript Tutorial — [Ein Leitfaden für Entwickler zur neuen Converse API von Bedrock](https://community.aws/content/2dtauBCeDa703x7fDS9Q30MJoBA/amazon-bedrock-converse-api-developer-guide)
## Verwendung der Converse API
Um die Converse-API zu verwenden, rufen Sie die Operationen `Converse` oder `ConverseStream` auf, um Nachrichten an ein Modell zu senden. Für den Aufruf von `Converse` ist die Berechtigung für die Operation `bedrock:InvokeModel` erforderlich. Für den Aufruf von `ConverseStream` ist die Berechtigung für die Operation `bedrock:InvokeModelWithResponseStream` erforderlich.
### Anforderung
Wenn Sie eine [Converse-Anfrage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) mit einem [Runtime-Endpunkt von Amazon-Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt) stellen, können Sie die folgenden Felder einbeziehen:
+ **modelId** – Ein erforderlicher Parameter im Header, mit dem Sie die Ressource angeben können, die für Inferenzen verwendet werden soll.
+ Mit den folgenden Feldern können Sie den Prompt anpassen:
+ **message** – Wird verwendet, um den Inhalt und die Rolle des Prompts festzulegen.
+ **system** – Dient der Angabe von System-Prompts, die Anweisungen oder den Kontext für das Modell definieren.
+ **inferenceConfig** – Dient der Angabe von Inferenzparametern, die allen Modellen gemeinsam sind. Inferenzparameter beeinflussen die Antwortgenerierung.
+ **zusätzlich ModelRequestFields** — Dient zur Angabe von Inferenzparametern, die für das Modell spezifisch sind, mit dem Sie die Inferenz ausführen.
+ **promptVariables** – (Wenn Sie einen Prompt aus dem Prompt-Management verwenden) Verwenden Sie dieses Feld, um die Variablen im Prompt und ihre jeweiligen Werte zu definieren.
+ Mit den folgenden Feldern können Sie anpassen, wie die Antwort zurückgegeben wird:
+ **guardrailConfig** – Verwenden Sie dieses Feld, um einen Integritätsschutz einzufügen, der auf den gesamten Prompt angewendet werden soll.
+ **toolConfig** – Verwenden Sie dieses Feld, um ein Tool einzufügen, das einem Modell bei der Generierung von Antworten hilft.
+ **zusätzlich ModelResponseFieldPaths** — Verwenden Sie dieses Feld, um Felder anzugeben, die als JSON-Zeigerobjekt zurückgegeben werden sollen.
+ **ServiceTier** — Verwenden Sie dieses Feld, um die Serviceebene für eine bestimmte Anfrage anzugeben
+ **requestMetadata** – Verwenden Sie dieses Feld, um Metadaten einzuschließen, nach denen bei der Verwendung von Aufrufprotokollen gefiltert werden kann.
**Anmerkung**
Die folgenden Einschränkungen gelten, wenn Sie einen Prompt aus dem Prompt-Management mit `Converse` oder `ConverseStream` verwenden:
Die Felder`additionalModelRequestFields`, `inferenceConfig`, `system` oder `toolConfig` können nicht einbezogen werden.
Wenn Sie das Feld `messages` einbeziehen, werden die Nachrichten nach den im Prompt definierten Nachrichten angehängt.
Wenn Sie das Feld `guardrailConfig` einbeziehen, wird der Integritätsschutz auf den gesamten Prompt angewendet. Wenn Sie `guardContent` Blöcke in das [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)Feld aufnehmen, wird die Leitplanke nur auf diese Blöcke angewendet.
Blenden Sie einen Abschnitt ein, um mehr über ein Feld im Text der `Converse`-Anfrage erfahren:
#### messages
Das Feld `messages` ist ein Array von [Message-Objekten](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), die jeweils eine Nachricht zwischen dem Benutzer und dem Modell definieren. Ein `Message`-Objekt enthält die folgenden Felder:
+ **role** – Definiert, ob die Nachricht von `user` (dem an das Modell gesendeten Prompt) oder `assistant` (der Antwort des Modells) stammt.
+ **content** – Definiert den Inhalt des Prompts.
**Anmerkung**
Amazon Bedrock speichert keine Texte, Bilder oder Dokumente, die Sie als Inhalt bereitstellen. Die Daten werden nur verwendet, um die Antwort zu generieren.
Sie können den Konversationskontext beibehalten, indem Sie alle Nachrichten der Konversation in nachfolgende `Converse`-Anfragen einbeziehen und im Feld `role` angeben, ob die Nachricht vom Benutzer oder vom Modell stammt.
Das `content` Feld ist einer Reihe von [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)Objekten zugeordnet. In jedem [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)Feld können Sie eines der folgenden Felder angeben (um zu sehen, welche Modelle welche Blöcke unterstützen, finden Sie unter [Modelle auf einen Blick](model-cards.md)):
------
#### [ text ]
Das Feld `text` ist einer Zeichenfolge zugeordnet, die den Prompt angibt. Das `text` Feld wird zusammen mit anderen Feldern interpretiert, die in demselben Feld angegeben sind [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
Das Folgende zeigt ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array, das nur einen Text enthält [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "{{string}}"
}
]
}
```
------
#### [ image ]
Das `image` Feld ist einem zugeordnet [ImageBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html). Übergeben Sie die base64-codierten Rohbytes für ein Bild im Feld `bytes`. Wenn Sie ein AWS SDK verwenden, müssen Sie die Bytes nicht in Base64 codieren.
Wenn Sie das Feld `text` ausschließen, beschreibt das Modell das Bild.
Im Folgenden wird ein Beispiel für ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array gezeigt, das nur ein Bild enthält: [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"bytes": "{{image in bytes}}"
}
}
}
]
}
```
Sie können auch eine Amazon-S3-URI angeben, anstatt die Bytes direkt im Anforderungstext zu übergeben. Im Folgenden wird ein `Message`-Beispielobjekt mit einem Inhaltsarray gezeigt, das die Quelle enthält, die über einen Amazon-S3-URI übergeben wurde.
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myImage",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ document ]
Das `document` Feld ist einem zugeordnet [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html). Wenn Sie einen `DocumentBlock` angeben, überprüfen Sie, ob Ihre Anfrage den folgenden Einschränkungen unterliegt:
+ In das Feld `content` des [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html)-Objekts müssen Sie auch ein `text`-Feld mit einem Prompt aufnehmen, der sich auf das Dokument bezieht.
+ Übergeben Sie die base64-codierten Rohbytes für ein Dokument im Feld `bytes`. Wenn Sie ein AWS SDK verwenden, müssen die Dokument-Bytes nicht base64-codiert werden.
+ Das Feld `name` darf folgende Zeichen enthalten:
+ Alphanumerische Zeichen
+ Leerzeichen (maximal eines hintereinander)
+ Bindestriche
+ Klammern
+ Eckige Klammern
**Anmerkung**
Das Feld `name` ist anfällig für Promptinjektionen, da das Modell es versehentlich als Anweisungen interpretieren könnte. Daher wird empfohlen, dass Sie einen neutralen Namen angeben.
Wenn Sie ein Dokument verwenden, können Sie das Tag `citations` aktivieren, das bei der Antwort auf den API-Aufruf dokumentspezifische Quellenangaben bereitstellt. Weitere Informationen finden Sie in der [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html)API.
Im Folgenden wird ein Beispiel für ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array gezeigt, das nur ein Dokument [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)und den erforderlichen Begleittext enthält [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
```
{
"role": "user",
"content": [
{
"text": "{{string}}"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"bytes": "{{document in bytes}}"
}
}
}
]
}
```
Sie können auch eine Amazon-S3-URI angeben, anstatt die Bytes direkt im Anforderungstext zu übergeben. Im Folgenden wird ein `Message`-Beispielobjekt mit einem Inhaltsarray gezeigt, das die Quelle enthält, die über einen Amazon-S3-URI übergeben wurde.
```
{
"role": "user",
"content": [
{
"text": "{{string}}"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myDocument",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ video ]
Das `video` Feld ist einem [VideoBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_VideoBlock.html)Objekt zugeordnet. Übergeben Sie die base64-codierten Rohbytes im Feld `bytes`. Wenn Sie das AWS SDK verwenden, müssen Sie die Bytes nicht in Base64 codieren.
Wenn Sie das Feld `text` nicht angeben, wird das Video durch das Modell beschrieben.
Im Folgenden wird ein Beispiel für ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array gezeigt, das nur ein Video enthält. [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": "{{video in bytes}}"
}
}
}
]
}
```
Sie können auch eine Amazon-S3-URI angeben, anstatt die Bytes direkt im Anforderungstext zu übergeben. Im Folgenden wird ein `Message`-Beispielobjekt mit einem Inhaltsarray gezeigt, das die Quelle enthält, die über einen Amazon-S3-URI übergeben wurde.
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myVideo",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
**Anmerkung**
Die übernommene Rolle muss über die Berechtigung `s3:GetObject` für die Amazon-S3-URI verfügen. Das Feld `bucketOwner` ist optional, muss aber angegeben werden, wenn das Konto, das die Anfrage stellt, nicht Eigentümer des Buckets ist, in dem sich der Amazon-S3-URI befindet. Weitere Informationen finden Sie unter [Konfigurieren des Zugriffs auf Amazon-S3-Buckets](s3-bucket-access.md).
------
#### [ cachePoint ]
Sie können Cache-Checkpoints als Block in einer Nachricht zusammen mit einer zugehörigen Eingabeaufforderung hinzufügen, indem Sie `cachePoint` Felder verwenden, um das Zwischenspeichern von Eingabeaufforderungen zu verwenden. Das Prompt-Caching ist ein Feature, mit dem Sie beginnen können, den Kontext von Konversationen zwischenzuspeichern, um Kosten und Latenz zu sparen. Weitere Informationen finden Sie unter [Prompt-Caching für schnellere Modellinferenz](prompt-caching.md).
Im Folgenden wird ein Beispiel für ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array gezeigt, das ein Dokument [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)und einen erforderlichen Begleittext enthält [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), sowie einen **CachePoint**, der sowohl das Dokument als auch den Textinhalt zum Cache hinzufügt.
```
{
"role": "user",
"content": [
{
"text": "{{string}}"
},
{
"document": {
"format": "pdf",
"name": "string",
"source": {
"bytes": "{{document in bytes}}"
}
}
},
{
"cachePoint": {
"type": "default"
}
}
]
}
```
------
#### [ guardContent ]
Das `guardContent` Feld ist einem [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html)Objekt zugeordnet. Sie mit diesem Feld eine Eingabe als Ziel verwenden, die anhand des im Feld `guardrailConfig` definierten Integritätsschutzes ausgewertet werden soll. Wenn Sie dieses Feld nicht angeben, wertet der Integritätsschutz alle Nachrichten im Anforderungstext aus. Sie können die folgenden Inhaltstypen an einen `GuardBlock` übergeben:
+ **text** — Im Folgenden wird ein Beispiel für ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array gezeigt, das nur einen Text enthält [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "Tell me what stocks to buy.",
"qualifiers": [
"guard_content"
]
}
]
}
```
Sie definieren den auszuwertenden Text und schließen alle Qualifizierer ein, die für die [kontextuelle Begründung](guardrails-contextual-grounding-check.md) verwendet werden sollen.
+ **image** — Das Folgende zeigt ein [Message-Objekt](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) mit einem `content` Array, das nur ein Bild enthält [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"format": "png",
"source": {
"bytes": "{{image in bytes}}"
}
}
]
}
```
Sie geben das Format des Bildes an und definieren das Bild in Byte.
Weitere Informationen zum Integritätsschutz finden Sie unter [So erkennen und filtern Sie schädliche Inhalte mithilfe vom Integritätsschutz für Amazon Bedrock](guardrails.md).
------
#### [ reasoningContent ]
Das `reasoningContent` Feld ist einem zugeordnet [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html). Dieser Block enthält Inhalte zu den Argumenten, die vom Modell zur Generierung der Antwort im zugehörigen `ContentBlock` verwendet wurden.
Im Folgenden wird ein `Message`-Objekt mit einem `content`-Array dargestellt, das nur einen `ReasoningContentBlock` und einen zugehörigen `ContentBlock` im Textformat enthält.
```
{
"role": "user",
"content": [
{
"text": "{{string}}"
},
{
"reasoningContent": {
"reasoningText": {
"text": "{{string}}",
"signature": "{{string}}"
}
"redactedContent": "{{base64-encoded binary data object}}"
}
}
]
}
```
Der `ReasoningContentBlock` enthält die Argumentation, die zur Generierung des zugehörigen Inhalts im Feld `reasoningText` verwendet wurde, sowie alle Inhalte der Argumentation, die vom Modellanbieter aus Gründen der Vertraulichkeit und der Sicherheit im Feld `redactedContent` verschlüsselt wurden.
Innerhalb des Feldes `reasoningText` beschreiben die `text`-Felder die Argumentation. Das Feld `signature` ist ein Hash aller Nachrichten in der Konversation und schützt vor Manipulation der im Modell verwendeten Argumentation. Sie müssen die Signatur und alle vorherigen Nachrichten in nachfolgende `Converse`-Anfragen einbeziehen. Wenn eine der Nachrichten geändert wird, gibt die Antwort einen Fehler aus.
------
#### [ toolUse ]
Enthält Informationen zu einem Tool, das für das Modell verwendet werden soll. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
------
#### [ toolResult ]
Enthält Informationen über das Ergebnis, das mit dem Modell unter Verwendung eines Werkzeugs erzielt wurde. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
------
Im folgenden `messages`-Beispiel fragt der Benutzer nach einer Liste mit drei Popsongs, und das Modell generiert eine Liste von Liedern.
```
[
{
"role": "user",
"content": [
{
"text": "Create a list of 3 pop songs."
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"As It Was\" by Harry Styles\n2. \"Easy On Me\" by Adele\n3. \"Unholy\" by Sam Smith and Kim Petras"
}
]
}
]
```
#### system
Ein System-Prompt ist eine Art von Prompt, die dem Modell Anweisungen oder Kontext zu der Aufgabe, die es ausführen soll, oder zu der Persönlichkeit, die es während der Konversation annehmen soll, bereitstellt. Sie können im Feld `system` ([SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)) eine Liste von Systemaufforderungen für die Anforderung angeben, wie im folgenden Beispiel gezeigt.
```
[
{
"text": "You are an app that creates play lists for a radio station that plays rock and pop music. Only return song names and the artist. "
}
]
```
#### inferenceConfig
Die Converse API unterstützt einen Basissatz von Inferenzparametern, die Sie im `inferenceConfig` Feld () [InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)festlegen. Der Basissatz von Inferenzparametern lautet:
+ **maxTokens** – Die maximale Anzahl von Token, die in der generierten Antwort zulässig sind
+ **stopSequences** – Eine Liste von Stoppsequenzen. Eine Stoppsequenz ist eine Folge von Zeichen, die bewirkt, dass das Modell die Generierung der Antwort stoppt.
+ **temperature** – Die Wahrscheinlichkeit, dass das Modell beim Generieren einer Antwortvariablen Optionen mit höherer Wahrscheinlichkeit auswählt
+ **topP** – Der Prozentsatz der wahrscheinlichsten Kandidaten, die das Modell für das nächste Token in Betracht zieht.
Weitere Informationen finden Sie unter [So beeinflussen Sie die Antwortgenerierung mit Inferenzparametern](inference-parameters.md).
Das folgende JSON-Beispiel legt den Inferenzparameter `temperature` fest.
```
{"temperature": 0.5}
```
#### zusätzlich ModelRequestFields
Wenn das von Ihnen verwendete Modell über zusätzliche Inferenzparameter verfügt, können Sie diese Parameter festlegen, indem Sie sie im Feld `additionalModelRequestFields` als JSON angeben. Das folgende JSON-Beispiel zeigt, wie man den Wert `top_k` festlegt, der in Anthropic-Claude-Modellen verfügbar ist, aber keinen Basisinferenzparameter in der Messages API darstellt.
```
{"top_k": 200}
```
#### promptVariables
Wenn Sie einen Prompt aus dem [Prompt-Management](prompt-management.md) in der `modelId` als Ressource angeben, für die Inferenz ausgeführt werden soll, verwenden Sie dieses Feld, um die Prompt-Variablen mit tatsächlichen Werten auszufüllen. Das Feld `promptVariables` ist einem JSON-Objekt mit Schlüsseln zugeordnet, die den in den Prompts definierten Variablen sowie den Werten entsprechen, durch die die Variablen ersetzt werden sollen.
Angenommen, Sie haben folgenden Prompt: **Make me a {{{{genre}}}} playlist consisting of the following number of songs: {{{{number}}}}.**. Die ID des Prompts lautet `PROMPT12345` und ihre Version ist `1`. Sie könnten die folgende `Converse`-Anfrage senden, um die Variablen zu ersetzen:
```
POST /model/arn:aws:bedrock:us-east-1:111122223333:prompt/PROMPT12345:1/converse HTTP/1.1
Content-type: application/json
{
"promptVariables": {
"genre": {
"text": "pop"
},
"number": {
"text": "3"
}
}
}
```
#### guardrailConfig
Sie können einen Integritätsschutz anwenden, den Sie mit dem [Integritätsschutz für Amazon Bedrock](guardrails.md) erstellt haben, indem Sie dieses Feld einbeziehen. Um die Leitplanke auf eine bestimmte Nachricht in der Konversation anzuwenden, fügen Sie die Nachricht in eine ein. [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) Wenn Sie keine `GuardrailConverseContentBlock` in den Anforderungstext aufnehmen, wird der Integritätsschutz auf alle Nachrichten im Feld `messages` angewendet. Ein Beispiel finden Sie unter [Fügen Sie eine Leitplanke mit dem hinzu Converse API](guardrails-use-converse-api.md).
#### toolConfig
In diesem Feld können Sie ein Tool definieren, mit dem das Modell eine Antwort generieren kann. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
#### zusätzlich ModelResponseFieldPaths
Sie können die Pfade für zusätzliche Modellparameter im Feld `additionalModelResponseFieldPaths` angeben, wie im folgenden Beispiel gezeigt.
```
[ "/stop_sequence" ]
```
Die API gibt die zusätzlichen Felder zurück, die Sie im Feld `additionalModelResponseFields` anfordern.
#### requestMetadata
Das `requestMetadata` Feld ist einem JSON-Objekt mit Schlüssel-Wert-Tags zugeordnet, die zusammen mit der Anforderung in Ihren Modellaufrufprotokollen aufgezeichnet werden. Sie können Anforderungsmetadaten verwenden, um Logs nach Team, Anwendung, Umgebung oder jeder anderen Dimension, die je nach Aufruf variiert, zu filtern und zu aggregieren.
Dieselbe Funktion ist im [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)und [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)über den `X-Amzn-Bedrock-Request-Metadata` HTTP-Header verfügbar. Weitere Informationen zu unterstützten APIs, Grenzwerten und dazu, wie Anforderungsmetadaten in Aufrufprotokollen angezeigt werden, finden Sie unter[Per-request Tagging von Metadaten](cost-mgmt-request-metadata.md).
#### ServiceTier
Dieses Feld ist einem JSON-Objekt zugeordnet. Sie können die Servicestufe für eine bestimmte Anfrage angeben.
Das folgende Beispiel zeigt die `serviceTier` Struktur:
```
"serviceTier": {
"type": "reserved" | "priority" | "default" | "flex"
}
```
Ausführliche Informationen zu den Servicestufen, einschließlich Preis- und Leistungsmerkmalen, finden Sie unter[Servicestufen zur Optimierung von Leistung und Kosten](service-tiers-inference.md).
Je nach verwendetem Modell können Sie optional auch Cache-Prüfpunkte zu den Feldern `system` oder `tools` hinzufügen, um das Prompt-Caching zu verwenden. Weitere Informationen finden Sie unter [Prompt-Caching für schnellere Modellinferenz](prompt-caching.md).
### Antwort
Die Antwort, die Sie von der Converse-API erhalten, hängt davon ab, welche Operation Sie aufrufen, `Converse` oder `ConverseStream`.
#### Antwort von Converse
In der Antwort von `Converse` enthält das `output` Feld ([ConverseOutput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseOutput.html)) die [Nachricht (Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html)), die das Modell generiert. Der Nachrichteninhalt befindet sich im Feld `content` ([ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)) und die Rolle (`user`oder`assistant`), der die Nachricht entspricht, befindet sich im `role` Feld.
Wenn Sie [Prompt-Caching](prompt-caching.md) verwendet haben, geben Sie im Verwendungsfeld `cacheReadInputTokens` und `cacheWriteInputTokens` an, wie viele Token insgesamt aus dem Cache gelesen bzw. in den Cache geschrieben wurden.
Wenn Sie [Serviceebenen](#inference-service-tiers) verwendet haben, `service tier` würde ich Ihnen im Antwortfeld mitteilen, welche Servicestufe für die Anfrage verwendet wurde.
Das `metrics` Feld ([ConverseMetrics](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseMetrics.html)) enthält Metriken für den Anruf. Überprüfen Sie das Feld `stopReason`, um festzustellen, warum das Modell keine Inhalte mehr generiert hat. Sie können Informationen über die in der Anfrage an das Modell übergebenen Token und die in der Antwort generierten Token abrufen, indem Sie das `usage` Feld ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)) überprüfen. Wenn Sie in der Anfrage zusätzliche Antwortfelder angegeben haben, gibt die API sie im Feld `additionalModelResponseFields` als JSON zurück.
Das folgende Beispiel zeigt die Antwort von `Converse` nach der Übergabe des unter [Anforderung](#conversation-inference-call-request) beschriebenen Prompts.
```
{
"output": {
"message": {
"role": "assistant",
"content": [
{
"text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"Wannabe\" by Spice Girls\n2. \"Bitter Sweet Symphony\" by The Verve \n3. \"Don't Look Back in Anger\" by Oasis"
}
]
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 125,
"outputTokens": 60,
"totalTokens": 185
},
"metrics": {
"latencyMs": 1175
}
}
```
#### ConverseStream Antwort
Wenn Sie `ConverseStream` aufrufen, um die Antwort von einem Modell zu streamen, wird der Stream im Antwortfeld `stream` zurückgegeben. Der Stream gibt die folgenden Ereignisse in der folgenden Reihenfolge aus.
1. `messageStart`([MessageStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStartEvent.html)). Das Startereignis für eine Nachricht. Beinhaltet die Rolle für die Nachricht.
1. `contentBlockStart`([ContentBlockStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStartEvent.html)). Ein Startereignis für Inhaltsblöcke. Nur bei Verwendung des Tools.
1. `contentBlockDelta`([ContentBlockDeltaEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockDeltaEvent.html)). Ein Delta-Ereignis für Inhaltsblöcke. Beinhaltet einen der folgenden Bestandteile:
+ `text` – Den Teiltext, den das Modell generiert.
+ `reasoningContent` – Die teilweise Argumentation, die das Modell zur Generierung der Antwort durchgeführt hat. Sie müssen in nachfolgenden `Converse`-Anfragen zusätzlich zu allen vorherigen Nachrichten die zurückgegebene `signature` senden. Wenn eine der Nachrichten geändert wird, gibt die Antwort einen Fehler aus.
+ `toolUse` – Das teilweise eingegebene JSON-Objekt für die Verwendung mit dem Tool.
1. `contentBlockStop`([ContentBlockStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStopEvent.html)). Ein Ereignis zum Stoppen eines Inhaltsblocks.
1. `messageStop`([MessageStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html)). Das Stopp-Ereignis für die Nachricht. Beinhaltet den Grund, aus dem die Erzeugung der Ausgabe durch das Modell gestoppt wurde.
1. `metadata`([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)). Metadaten für die Anfrage. Die Metadaten umfassen die Token-Nutzung in `usage` ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)) und Metriken für den Aufruf in `metrics` ([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)).
ConverseStream streamt einen kompletten Inhaltsblock als `ContentBlockStartEvent` Ereignis, ein oder mehrere `ContentBlockDeltaEvent` Ereignisse und ein `ContentBlockStopEvent` Ereignis. Verwenden Sie das Feld `contentBlockIndex` als Index, um die Ereignisse zu korrelieren, aus denen ein Inhaltsblock besteht.
Das folgende Beispiel ist ein Teil einer Antwort von `ConverseStream`.
```
{'messageStart': {'role': 'assistant'}}
{'contentBlockDelta': {'delta': {'text': ''}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ' Title'}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ':'}, 'contentBlockIndex': 0}}
.
.
.
{'contentBlockDelta': {'delta': {'text': ' The'}, 'contentBlockIndex': 0}}
{'messageStop': {'stopReason': 'max_tokens'}}
{'metadata': {'usage': {'inputTokens': 47, 'outputTokens': 20, 'totalTokens': 67}, 'metrics': {'latencyMs': 100.0}}}
```
## Converse API-Beispiele
Die folgende Tabelle zeigt Beispiele für die Verwendung der Operationen `Converse` und `ConverseStream`.
------
#### [ Text ]
Dieses Beispiel zeigt, wie die Operation `Converse` mit dem *Anthropic Claude 3 Sonnet*-Modell aufgerufen wird. Das Beispiel zeigt, wie der Eingabetext, die Inferenzparameter und zusätzliche Parameter gesendet werden, die für das Modell einzigartig sind. Durch den Code wird eine Konversation gestartet, in der das Modell aufgefordert wird, eine Liste mit Liedern zu erstellen. Anschließend wird das Gespräch mit der Aufforderung, dass die Lieder von Künstlern aus dem Vereinigtes Königreich stammen sollen, fortgesetzt.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
system_prompts,
messages):
"""
Sends messages to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
system_prompts (JSON) : The system prompts for the model to use.
messages (JSON) : The messages to send to the model.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Inference parameters to use.
temperature = 0.5
top_k = 200
# Base inference parameters to use.
inference_config = {"temperature": temperature}
# Additional inference parameters to use.
additional_model_fields = {"top_k": top_k}
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
additionalModelRequestFields=additional_model_fields
)
# Log token usage.
token_usage = response['usage']
logger.info("Input tokens: %s", token_usage['inputTokens'])
logger.info("Output tokens: %s", token_usage['outputTokens'])
logger.info("Total tokens: %s", token_usage['totalTokens'])
logger.info("Stop reason: %s", response['stopReason'])
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
# Setup the system prompts and messages to send to the model.
system_prompts = [{"text": "You are an app that creates playlists for a radio station that plays rock and pop music. Only return song names and the artist."}]
message_1 = {
"role": "user",
"content": [{"text": "Create a list of 3 pop songs."}]
}
message_2 = {
"role": "user",
"content": [{"text": "Make sure the songs are by artists from the United Kingdom."}]
}
messages = []
try:
bedrock_client = boto3.client(service_name='bedrock-runtime')
# Start the conversation with the 1st message.
messages.append(message_1)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
# Add the response message to the conversation.
output_message = response['output']['message']
messages.append(output_message)
# Continue the conversation with the 2nd message.
messages.append(message_2)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
output_message = response['output']['message']
messages.append(output_message)
# Show the complete conversation.
for message in messages:
print(f"Role: {message['role']}")
for content in message['content']:
print(f"Text: {content['text']}")
print()
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Image ]
Im Beispiel wird gezeigt, wie ein Bild als Teil einer Nachricht gesendet wird, und das Modell aufgefordert wird, das Bild zu beschreiben. Im Beispiel werden die Operation `Converse` und das *Anthropic-Claude 3 Sonnet*-Modell verwendet.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an image with the Converse API with an accompanying text prompt to Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
input_text,
input_image):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The text prompt accompanying the image.
input_image : The path to the input image.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Get image extension and read in image as bytes
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as f:
image = f.read()
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"image": {
"format": image_ext,
"source": {
"bytes": image
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What's in this image?"
input_image = "path/to/image"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_conversation(
bedrock_client, model_id, input_text, input_image)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Document ]
Im Beispiel wird gezeigt, wie ein Bild als Teil einer Nachricht gesendet wird, und das Modell aufgefordert wird, das Bild zu beschreiben. Im Beispiel werden die Operation `Converse` und das *Anthropic-Claude 3 Sonnet*-Modell verwendet.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an document as part of a message to Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_client,
model_id,
input_text,
input_document_path):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The input message.
input_document_path : The path to the input document.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Get format from path and read the path
input_document_format = input_document_path.split(".")[-1]
with open(input_document_path, 'rb') as input_document_file:
input_document = input_document_file.read()
# Message to send.
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"document": {
"name": "MyDocument",
"format": input_document_format,
"source": {
"bytes": input_document
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What's in this document?"
input_document_path = "path/to/document"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_message(
bedrock_client, model_id, input_text, input_document_path)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Streaming ]
Dieses Beispiel zeigt, wie die Operation `ConverseStream` mit dem *Anthropic-Claude 3 Sonnet*-Modell aufgerufen wird. Das Beispiel zeigt, wie der Eingabetext, die Inferenzparameter und zusätzliche Parameter gesendet werden, die für das Modell einzigartig sind.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API to stream a response from Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_conversation(bedrock_client,
model_id,
messages,
system_prompts,
inference_config,
additional_model_fields):
"""
Sends messages to a model and streams the response.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send.
system_prompts (JSON) : The system prompts to send.
inference_config (JSON) : The inference configuration to use.
additional_model_fields (JSON) : Additional model fields to use.
Returns:
Nothing.
"""
logger.info("Streaming messages with model %s", model_id)
response = bedrock_client.converse_stream(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
additionalModelRequestFields=additional_model_fields
)
stream = response.get('stream')
if stream:
for event in stream:
if 'messageStart' in event:
print(f"\nRole: {event['messageStart']['role']}")
if 'contentBlockDelta' in event:
print(event['contentBlockDelta']['delta']['text'], end="")
if 'messageStop' in event:
print(f"\nStop reason: {event['messageStop']['stopReason']}")
if 'metadata' in event:
metadata = event['metadata']
if 'usage' in metadata:
print("\nToken usage")
print(f"Input tokens: {metadata['usage']['inputTokens']}")
print(
f":Output tokens: {metadata['usage']['outputTokens']}")
print(f":Total tokens: {metadata['usage']['totalTokens']}")
if 'metrics' in event['metadata']:
print(
f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
def main():
"""
Entrypoint for streaming message API response example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
system_prompt = """You are an app that creates playlists for a radio station
that plays rock and pop music. Only return song names and the artist."""
# Message to send to the model.
input_text = "Create a list of 3 pop songs."
message = {
"role": "user",
"content": [{"text": input_text}]
}
messages = [message]
# System prompts.
system_prompts = [{"text" : system_prompt}]
# inference parameters to use.
temperature = 0.5
top_k = 200
# Base inference parameters.
inference_config = {
"temperature": temperature
}
# Additional model inference parameters.
additional_model_fields = {"top_k": top_k}
try:
bedrock_client = boto3.client(service_name='bedrock-runtime')
stream_conversation(bedrock_client, model_id, messages,
system_prompts, inference_config, additional_model_fields)
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished streaming messages with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Video ]
Im Beispiel wird gezeigt, wie ein Video als Teil einer Nachricht gesendet wird, und das Modell aufgefordert wird, das Video zu beschreiben. Im Beispiel werden die Operation `Converse` und das Amazon Nova Pro-Modell verwendet.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send a video with the Converse API to Amazon Nova Pro (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
input_text,
input_video):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The input message.
input_video : The input video.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Message to send.
with open(input_video, "rb") as f:
video = f.read()
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"video": {
"format": 'mp4',
"source": {
"bytes": video
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Amazon Nova Pro example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.nova-pro-v1:0"
input_text = "What's in this video?"
input_video = "path/to/video"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_conversation(
bedrock_client, model_id, input_text, input_video)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------