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.
# So reichen Sie mithilfe der API Prompts ein und generieren Antworten
Amazon Bedrock bietet die folgenden API-Operationen für die Ausführung von Modellinferenzen:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Senden Sie eine Aufforderung und generieren Sie eine Antwort. Der Anfragetext ist modellspezifisch. Um Streaming-Antworten zu generieren, verwenden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
+ [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) – Sie senden einen Prompt und generieren Antworten mit einer für alle Modelle einheitlichen Struktur. Modellspezifische Anforderungsfelder können im Feld `additionalModelRequestFields` angegeben werden. Sie können auch System-Prompts und frühere Konversationen als Kontext einbeziehen. Um Streaming-Antworten zu generieren, verwenden Sie [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html).
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Senden Sie eine Aufforderung und generieren Sie asynchron eine Antwort, die später abgerufen werden kann. Wird zum Generieren von Videos verwendet.
+ [InvokeModelWithBidirectionalStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithBidirectionalStream.html) –
+ OpenAI-API für Chat-Abschlüsse – Verwenden Sie die [OpenAI-Chat-Completions-API](https://platform.openai.com/docs/api-reference/chat/create) mit Modellen, die von Amazon Bedrock unterstützt werden, um eine Antwort zu generieren.
**Anmerkung**
Einschränkungen gelten für die folgenden Operationen:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, und`ConverseStream`. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
Für die Modellinferenz müssen Sie die folgenden Parameter bestimmen:
+ Modell-ID – Die ID oder der Amazon-Ressourcenname (ARN) des Modells oder Inferenzprofils zur Verwendung im `modelId`-Inferenzfeld. In der folgenden Tabelle wird beschrieben, wie Sie IDs nach verschiedenen Ressourcentypen suchen können:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/inference-api.html)
+ Anforderungstext – Enthält die Inferenzparameter für ein Modell und andere Konfigurationen. Jedes Modell hat seine eigenen Inferenzparameter. Die Inferenzparameter für ein benutzerdefiniertes oder bereitgestelltes Modell hängen vom Basismodell ab, auf deren Basis sie erstellt wurden. Weitere Informationen finden Sie unter [Inferenzanforderungsparameter und Antwortfelder für Basismodelle](model-parameters.md).
Wählen Sie ein Thema aus, um zu erfahren, wie Sie den Modellaufruf APIs verwenden.
**Topics**
+ [Senden Sie eine einzelne Aufforderung mit InvokeModel](inference-invoke.md)
+ [Rufen Sie ein Modell mit der OpenAI-Chat-Completions-API auf](inference-chat-completions.md)
+ [Führen einer Konversation mit den Converse-API-Operationen](conversation-inference.md)
+ [API-Einschränkungen](inference-api-restrictions.md)
# Senden Sie eine einzelne Aufforderung mit InvokeModel
Sie führen Inferenzen für eine einzelne Eingabeaufforderung aus, indem Sie die [InvokeModel[InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API-Operationen und verwenden und ein Modell angeben. Amazon-Bedrock-Modelle unterscheiden sich darin, ob sie Text-, Bild- oder Videoeingaben akzeptieren und ob sie Ausgaben in Form von Text, Bildern oder Einbettungen erzeugen können. Einige Modelle können die Antwort in einem Stream zurückgeben. Gehen Sie wie folgt vor, um die Modellunterstützung für Eingabe, Ausgabe und Streaming zu überprüfen:
+ Überprüfen Sie den Wert in den Spalten **Eingabemodalitäten**, **Ausgabemodalitäten** oder **Streaming-unterstützt** für ein Modell unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
+ Senden Sie eine [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)Anfrage mit der Modell-ID und überprüfen Sie die Werte im `responseStreamingSupported` Feld `inputModalities``outputModalities`, und.
Führen Sie die Modellinferenz an einer Eingabeaufforderung aus, indem Sie eine [InvokeModel[InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)Oder-Anfrage mit einem [Amazon Bedrock-Laufzeitendpunkt](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt) senden.
**Anmerkung**
Einschränkungen gelten für die folgenden Operationen:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, und. `ConverseStream` Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
Die folgenden Felder sind erforderlich:
****
| Feld | Anwendungsfall |
| --- | --- |
| modelId | So geben Sie das zu verwendende Modell, das Inferenzprofil oder den Prompt aus dem Prompt-Management an. Weitere Informationen zur Auffindung dieses Werts finden Sie unter [So reichen Sie mithilfe der API Prompts ein und generieren Antworten](inference-api.md). |
| body | So geben Sie die Inferenzparameter für ein Modell an. Weitere Informationen zu den Inferenzparametern für verschiedene Modelle finden Sie unter [Inferenzanforderungsparameter und Antwortfelder für Basismodelle](model-parameters.md). Wenn Sie ein Prompt aus dem Prompt-Management im Feld modelId angeben, lassen Sie dieses Feld weg (falls Sie es dennoch angeben, wird es ignoriert). |
Die folgenden Felder sind optional:
****
| Feld | Anwendungsfall |
| --- | --- |
| accept | Um den Medientyp für den Anforderungstext anzugeben. Weitere Informationen finden Sie unter Medientypen auf der [Swagger-Website](https://swagger.io/specification/). |
| contentType | Um den Medientyp für den Antworttext anzugeben. Weitere Informationen finden Sie unter Medientypen auf der [Swagger-Website](https://swagger.io/specification/). |
| performanceConfigLatency | Um anzugeben, ob ein Modell für Latenz optimiert werden soll. Weitere Informationen finden Sie unter [Optimieren der Modellinferenz für die Latenz](latency-optimized-inference.md). |
| guardrailIdentifier | Um einen Integritätsschutz anzugeben, der auf den Prompt und die Antwort angewendet werden soll. Weitere Informationen finden Sie unter [So testen Sie Ihren Integritätsschutz](guardrails-test.md). |
| guardrailVersion | Um einen Integritätsschutz anzugeben, der auf den Prompt und die Antwort angewendet werden soll. Weitere Informationen finden Sie unter [So testen Sie Ihren Integritätsschutz](guardrails-test.md). |
| trace | Um anzugeben, ob die Ablaufverfolgung für den von Ihnen angegebenen Integritätsschutz zurückgegeben werden soll. Weitere Informationen finden Sie unter [So testen Sie Ihren Integritätsschutz](guardrails-test.md). |
| ServiceTier | Um die Servicestufe für eine Anfrage anzugeben. Weitere Informationen finden Sie unter [Servicestufen zur Optimierung von Leistung und Kosten](service-tiers-inference.md). |
## Beispiel für das Aufrufen von Modellcode
Dieses Thema enthält einige grundlegende Beispiele für die Ausführung von Inferenzen mithilfe einer einzigen Eingabeaufforderung mit der [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Weitere Beispiele mit anderen Modellen finden Sie in den folgenden Ressourcen:
+ Wählen Sie im Thema [Codebeispiele für Amazon Bedrock Runtime mit AWS SDKs](service_code_examples_bedrock-runtime.md) ein Beispiel aus.
+ Besuchen Sie die Referenz zu den Inferenzparametern für das gewünschte Modell unter [Inferenzanforderungsparameter und Antwortfelder für Basismodelle](model-parameters.md).
In den folgenden Beispielen wird davon ausgegangen, dass Sie den programmatischen Zugriff so eingerichtet haben, dass Sie sich standardmäßig automatisch beim AWS CLI SDK for Python (Boto3) authentifizieren, AWS-Region wenn Sie diese Beispiele ausführen. Weitere Informationen zum Einrichten des programmatischen Zugriffs finden Sie unter [Erste Schritte mit der API](getting-started-api.md).
**Anmerkung**
Lesen Sie sich die folgenden Punkte durch, bevor Sie die Beispiele ausprobieren:
Sie sollten diese Beispiele in der Region USA Ost (Nord-Virginia) (us-east-1) testen, wo alle in den Beispielen verwendeten Modelle unterstützt werden.
Der `body`-Parameter kann groß sein, sodass Sie bei einigen CLI-Beispielen aufgefordert werden, eine JSON-Datei zu erstellen und diese Datei im `--body`-Argument bereitzustellen, anstatt sie in der Befehlszeile anzugeben.
Für die Bild- und Videobeispiele werden Sie aufgefordert, Ihr eigenes Bild und Video zu verwenden. In den Beispielen wird davon ausgegangen, dass Ihre Bilddatei benannt ist *image.png* und dass Ihre Videodatei benannt ist. *video.mp4*
Möglicherweise müssen Sie Bilder oder Videos in eine base64-kodierte Zeichenfolge konvertieren oder sie auf einen Amazon-S3-Speicherort hochladen. In den Beispielen müssen Sie die Platzhalter durch die tatsächliche base64-kodierte Zeichenfolge oder den S3-Speicherort ersetzen.
Erweitern Sie einen Abschnitt, um einige grundlegende Codebeispiele auszuprobieren.
### So generieren Sie Text mit einem Text-Prompt
Die folgenden Beispiele generieren eine Textantwort auf einen Text-Prompt mithilfe des Amazon-Titan Text Premier-Modells. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ CLI ]
Führen Sie den folgenden Befehl in einem Terminal aus und suchen Sie die generierte Antwort in einer Datei namens*invoke-model-output.txt*.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-text-premier-v1:0 \
--body '{
"inputText": "Describe the purpose of a 'hello world' program in one line.",
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5
}
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Führen Sie das folgende Python-Codebeispiel aus, um eine Textantwort zu generieren:
```
# Use the native inference API to send a text message to Amazon Titan Text.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Text Premier.
model_id = "amazon.titan-text-premier-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"inputText": prompt,
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["results"][0]["outputText"]
print(response_text)
```
------
### Generieren Sie Text mit einer Texteingabeaufforderung mithilfe der Serviceebene
In den folgenden Beispielen wird eine Textantwort auf eine Texteingabeaufforderung generiert, wobei das OpenAI GPT-Modell mit einer Serviceebene zur Priorisierung der Anfrage verwendet wird. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ CLI ]
Führen Sie den folgenden Befehl in einem Terminal aus und überprüfen Sie die Serviceebene in der Antwort.
```
aws bedrock-runtime invoke-model \
--model-id openai.gpt-oss-120b-1:0 \
--body '{
"messages": [
{
"role": "user",
"content": "Describe the purpose of a '\''hello world'\'' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
}' \
--content-type application/json \
--accept application/json \
--service-tier priority \
--cli-binary-format raw-in-base64-out
```
------
#### [ Python ]
Führen Sie das folgende Python-Codebeispiel aus, um eine Textantwort mit Serviceebene zu generieren:
```
import boto3
import json
# Create a Bedrock Runtime client
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1"
)
# Define the model ID and request body
model_id = "openai.gpt-oss-120b-1:0"
body = json.dumps({
"messages": [
{
"role": "user",
"content": "Describe the purpose of a 'hello world' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
})
# Make the request with service tier
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=body,
contentType="application/json",
accept="application/json",
serviceTier="priority"
)
# Parse and print the response
response_body = json.loads(response["body"])
print(response_body)
```
------
### So generieren Sie ein Bild mithilfe eines Text-Prompts
Die folgenden Codebeispiele generieren ein Bild mithilfe eines Text-Prompts mit dem Stable Diffusion XL-1.0-Modell. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ CLI ]
Führen Sie den folgenden Befehl in einem Terminal aus und suchen Sie die generierte Antwort in einer Datei namens*invoke-model-output.txt*. Die Bytes, die das Bild darstellen, befinden sich im `base64`-Feld in der Antwort:
```
aws bedrock-runtime invoke-model \
--model-id stability.stable-diffusion-xl-v1 \
--body '{
"text_prompts": [{"text": "A stylized picture of a cute old steampunk robot."}],
"style_preset": "photographic",
"seed": 0,
"cfg_scale": 10,
"steps": 30
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Führen Sie das folgende Python-Codebeispiel aus, um ein Bild zu generieren und die resultierende *stability\$11.png* Bilddatei in einem Ordner mit dem Namen zu suchen*output*.
```
# Use the native inference API to create an image with Amazon Titan Image Generator
import base64
import boto3
import json
import os
import random
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Image Generator G1.
model_id = "amazon.titan-image-generator-v2:0"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed.
seed = random.randint(0, 2147483647)
# Format the request payload using the model's native structure.
native_request = {
"taskType": "TEXT_IMAGE",
"textToImageParams": {"text": prompt},
"imageGenerationConfig": {
"numberOfImages": 1,
"quality": "standard",
"cfgScale": 8.0,
"height": 512,
"width": 512,
"seed": seed,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["images"][0]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"titan_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"titan_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
------
### So generieren Sie Einbettungen aus Text
Die folgenden Beispiele verwenden das Modell Amazon Titan Text Embeddings V2, um binäre Einbettungen für eine Texteingabe zu generieren. Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ CLI ]
Führen Sie den folgenden Befehl in einem Terminal aus und suchen Sie die generierte Antwort in einer Datei namens*invoke-model-output.txt*. Die resultierenden Einbettungen befinden sich im Feld `binary`.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-text-v2:0 \
--body '{
"inputText": "What are the different services that you offer?",
"embeddingTypes": ["binary"]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Führen Sie das folgende Python-Codebeispiel aus, um Einbettungen für den bereitgestellten Text zu generieren:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embedding(model_id, body):
"""
Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embedding created by the model and the number of input tokens.
"""
logger.info("Generating an embedding with Amazon Titan Text Embeddings V2 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Amazon Titan Embeddings V2 - Text example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.titan-embed-text-v2:0"
input_text = "What are the different services that you offer?"
# Create request body.
body = json.dumps({
"inputText": input_text,
"embeddingTypes": ["binary"]
})
try:
response = generate_embedding(model_id, body)
print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
print(f"Input text: {input_text}")
print(f"Input Token count: {response['inputTextTokenCount']}")
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 generating an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### So generieren Sie Einbettungen aus einem Bild
Die folgenden Beispiele verwenden das Amazon-Titan Multimodal Embeddings G1-Modell, um binäre Einbettungen für eine Bildeingabe zu generieren. Wählen Sie die Registerkarte für Ihre bevorzugte Methode und führen Sie die folgenden Schritte aus:
------
#### [ CLI ]
Öffnen Sie einen Terminal und gehen Sie wie folgt vor:
1. Konvertiert ein Bild mit dem Titel *image.png* in Ihrem aktuellen Ordner in eine Base64-kodierte Zeichenfolge und schreibt es in eine Datei mit dem Titel, *image.txt* indem Sie den folgenden Befehl ausführen:
```
base64 -i image.png -o image.txt
```
1. Erstellen Sie eine JSON-Datei *\$1\$1image-base64\$1* mit dem Namen *image-input-embeddings-output.json* und fügen Sie den folgenden JSON-Code ein, indem Sie ihn durch den Inhalt der *image.txt* Datei ersetzen (stellen Sie sicher, dass am Ende der Zeichenfolge keine neue Zeile steht):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Führen Sie den folgenden Befehl aus und geben Sie die *image-input-embeddings-output.json* Datei als Hauptteil an.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-image-v1 \
--body file://image-input-embeddings-output.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Suchen Sie die resultierenden Einbettungen in der *invoke-model-output.txt* Datei.
------
#### [ Python ]
Ersetzen Sie im folgenden Python-Skript */path/to/image* durch den Pfad zu einem tatsächlichen Bild. Führen Sie dann das Skript aus, um Einbettungen zu generieren:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from an image with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""
import base64
import json
import logging
import boto3
from botocore.exceptions import ClientError
class EmbedError(Exception):
"Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embeddings(model_id, body):
"""
Generate a vector of embeddings for an image input using Amazon Titan Multimodal Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embeddings that the model generated, token information, and the
reason the model stopped generating embeddings.
"""
logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
finish_reason = response_body.get("message")
if finish_reason is not None:
raise EmbedError(f"Embeddings generation error: {finish_reason}")
return response_body
def main():
"""
Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
model_id = 'amazon.titan-embed-image-v1'
output_embedding_length = 256
# Create request body.
body = json.dumps({
"inputImage": input_image,
"embeddingConfig": {
"outputEmbeddingLength": output_embedding_length
}
})
try:
response = generate_embeddings(model_id, body)
print(f"Generated image embeddings of length {output_embedding_length}: {response['embedding']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except EmbedError as err:
logger.error(err.message)
print(err.message)
else:
print(f"Finished generating image embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### So generieren Sie eine Textantwort auf ein Bild mit einem zugehörigen Text-Prompt
Wählen Sie die Registerkarte für Ihre bevorzugte Methode und führen Sie die folgenden Schritte aus:
------
#### [ CLI ]
Im folgenden Beispiel wird das Modell Anthropic Claude 3 Haiku verwendet, um anhand eines Bildes und eines Text-Prompts, in dem nach dem Inhalt des Bildes gefragt wird, eine Antwort zu generieren. Öffnen Sie einen Terminal und gehen Sie wie folgt vor:
1. Konvertiert ein Bild mit dem Titel *image.png* in Ihrem aktuellen Ordner in eine Base64-kodierte Zeichenfolge und schreibt es in eine Datei mit dem Titel, *image.txt* indem Sie den folgenden Befehl ausführen:
```
base64 -i image.png -o image.txt
```
1. Erstellen Sie eine JSON-Datei *\$1\$1image-base64\$1* mit dem Namen *image-text-input.json* und fügen Sie den folgenden JSON-Code ein, indem Sie ihn durch den Inhalt der *image.txt* Datei ersetzen (stellen Sie sicher, dass am Ende der Zeichenfolge keine neue Zeile steht):
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1000,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "${image-base64}"
}
},
{
"type": "text",
"text": "What's in this image?"
}
]
}
]
}
```
1. Führen Sie den folgenden Befehl aus, um auf der Grundlage des Bildes und der zugehörigen Texteingabeaufforderung eine Textausgabe in eine Datei mit dem Namen zu generieren*invoke-model-output.txt*:
```
aws bedrock-runtime invoke-model \
--model-id anthropic.claude-3-haiku-20240307-v1:0 \
--body file://image-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Suchen Sie die Ausgabe in der *invoke-model-output.txt* Datei im aktuellen Ordner.
------
#### [ Python ]
Ersetzen Sie es im folgenden Python-Skript */path/to/image.png* durch den tatsächlichen Pfad zum Bild, bevor Sie das Skript ausführen:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
------
### So generieren Sie eine Textantwort auf ein auf Amazon S3 hochgeladenes Video mit einem zugehörigen Text-Prompt
Die folgenden Beispiele zeigen, wie Sie anhand eines Videos, das Sie in einen S3-Bucket hochladen, und einem zugehörigen Text-Prompt eine Antwort mit dem Amazon Nova Lite-Modell generieren.
**Voraussetzung:** Laden Sie ein Video mit *video.mp4* dem Titel eines Amazon S3 S3-Buckets in Ihr Konto hoch, indem Sie den Schritten unter [Objekte hochladen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) im Amazon Simple Storage Service-Benutzerhandbuch folgen. Notieren Sie sich die S3-URI des Videos.
Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:
------
#### [ CLI ]
Öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus, *s3://amzn-s3-demo-bucket/video.mp4* wobei Sie ihn durch den tatsächlichen S3-Speicherort Ihres Videos ersetzen:
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body '{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video.mp4"
}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
Suchen Sie die Ausgabe in der *invoke-model-output.txt* Datei im aktuellen Ordner.
------
#### [ Python ]
Ersetzen Sie es im folgenden Python-Skript *s3://amzn-s3-demo-bucket/video.mp4* durch den tatsächlichen S3-Speicherort Ihres Videos. Führen Sie dann folgendes Skript aus:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video_s3_uri = "s3://amzn-s3-demo-bucket/video.mp4" # Replace with real S3 URI
video_ext = input_video_s3_uri.split(".")[-1]
input_text = "What happens in this video?"
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"s3Location": {
"uri": input_video_s3_uri
}
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
### So generieren Sie eine Textantwort auf ein Video, das in eine base64-kodierte Zeichenfolge mit einem zugehörigen Text-Prompt konvertiert wurde
Die folgenden Beispiele zeigen, wie Sie mit dem Amazon Nova Lite-Modell eine Antwort generieren können, wenn ein Video in eine base64‑codierte Zeichenkette konvertiert wurde und ein begleitender Text-Prompt vorliegt. Wählen Sie die Registerkarte für Ihre bevorzugte Methode und führen Sie die folgenden Schritte aus:
------
#### [ CLI ]
Gehen Sie wie folgt vor:
1. Konvertieren Sie ein Video mit dem Titel *video.mp4* in Ihrem aktuellen Ordner in ein Base64-Format, indem Sie den folgenden Befehl ausführen:
```
base64 -i video.mp4 -o video.txt
```
1. Erstellen Sie eine JSON-Datei *\$1\$1video-base64\$1* mit dem Namen *video-text-input.json* und fügen Sie den folgenden JSON-Code ein, indem Sie ihn durch den Inhalt der `video.txt` Datei ersetzen (stellen Sie sicher, dass am Ende keine neue Zeile steht):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Führen Sie den folgenden Befehl aus, um eine Textausgabe zu generieren, die auf dem Video und der zugehörigen Textaufforderung für eine Datei mit dem Namen basiert*invoke-model-output.txt*:
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body file://video-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Suchen Sie die Ausgabe in der *invoke-model-output.txt* Datei im aktuellen Ordner.
------
#### [ Python ]
Ersetzen Sie im folgenden Python-Skript */path/to/video.mp4* durch den tatsächlichen Pfad zum Video. Führen Sie dann folgendes Skript aus:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video = "/path/to/video.mp4" # Replace with real path to video
video_ext = input_video.split(".")[-1]
input_text = "What happens in this video?"
# Read reference video from file and encode as base64 string.
with open(input_video, "rb") as video_file:
content_video = base64.b64encode(video_file.read()).decode('utf8')\
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"bytes": content_video
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
## Beispiel für das Aufrufen eines Modells mit Streaming-Code
**Anmerkung**
Das AWS CLI unterstützt kein Streaming.
Das folgende Beispiel zeigt, wie die [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API verwendet wird, um Streaming-Text mit Python mithilfe der Eingabeaufforderung zu generieren*write an essay for living on mars in 1000 words*.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```
# Rufen Sie ein Modell mit der OpenAI-Chat-Completions-API auf
Sie können Modellinferenzen mithilfe der [OpenAI-Create-Chat-Completion-API](https://platform.openai.com/docs/api-reference/chat/create) für Amazon-Bedrock-Modelle ausführen.
Sie können die API Create-Chat-Completion wie folgt aufrufen:
+ Stellen Sie eine HTTP-Anfrage mit einem Amazon-Bedrock-Runtime-Endpunkt.
+ Verwenden Sie eine OpenAI-SDK-Anfrage mit einem Amazon-Bedrock-Runtime-Endpunkt.
Wählen Sie ein Thema aus, um mehr zu erfahren:
**Topics**
+ [Unterstützte Modelle und Regionen für die OpenAI-Chat-Completions-API](#inference-chat-completions-supported)
+ [Voraussetzungen für die Verwendung der Chat-Completions-API](#inference-chat-completions-prereq)
+ [Erstellen einer Chat-Vervollständigung](#inference-chat-completions-create)
+ [So fügen Sie einen Integritätsschutz in eine Chat-Vervollständigung ein](#inference-chat-completions-guardrails)
## Unterstützte Modelle und Regionen für die OpenAI-Chat-Completions-API
Sie können die Create Chat Completion API mit allen OpenAI Modellen verwenden, die in Amazon Bedrock und in den AWS Regionen unterstützt werden, die diese Modelle unterstützen. Weitere Informationen zu unterstützten Modellen und Regionen finden Sie unter [Unterstützte Basismodelle in Amazon Bedrock](models-supported.md).
## Voraussetzungen für die Verwendung der Chat-Completions-API
Wenn Sie Beispiele für die Verwendung der Chat-Completions-API sehen möchten, wählen Sie die Registerkarte mit Ihrer bevorzugten Methode aus und führen Sie dann die folgenden Schritte aus:
------
#### [ OpenAI SDK ]
+ **Authentifizierung** – Das OpenAI SDK unterstützt ausschließlich Authentifizierungen mit einem API-Schlüssel von Amazon Bedrock. Generieren Sie einen API-Schlüssel von Amazon Bedrock, um Ihre API-Anfrage zu authentifizieren. Weitere Informationen zu Amazon Bedrock API-Schlüsseln und deren Generierung finden Sie im Abschnitt API-Schlüssel im Kapitel Build.
+ **Endpunkt** — Finden Sie den Endpunkt, der der AWS Region entspricht, die in [Amazon Bedrock Runtime-Endpunkten und](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt) -Kontingenten verwendet werden soll. Wenn Sie ein AWS SDK verwenden, müssen Sie bei der Einrichtung des Clients möglicherweise nur den Regionalcode und nicht den gesamten Endpunkt angeben.
+ **Installieren eines OpenAI SDK** – Weitere Informationen finden Sie in der OpenAI-Dokumentation unter [Bibliotheken](https://platform.openai.com/docs/libraries).
------
#### [ HTTP request ]
+ **Authentifizierung** — Sie können sich entweder mit Ihren AWS Anmeldeinformationen oder mit einem Amazon Bedrock API-Schlüssel authentifizieren.
Richten Sie Ihre AWS Anmeldeinformationen ein oder generieren Sie einen Amazon Bedrock API-Schlüssel, um Ihre Anfrage zu authentifizieren.
+ Weitere Informationen zum Einrichten Ihrer AWS Anmeldeinformationen finden Sie unter [Programmatischer Zugriff mit AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) Sicherheitsanmeldedaten.
+ Weitere Informationen zu Amazon Bedrock API-Schlüsseln und deren Generierung finden Sie im Abschnitt API-Schlüssel im Kapitel Build.
+ **Endpunkt** — Finden Sie den Endpunkt, der der AWS Region entspricht, die in [Amazon Bedrock Runtime-Endpunkten und](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt) -Kontingenten verwendet werden soll. Wenn Sie ein AWS SDK verwenden, müssen Sie bei der Einrichtung des Clients möglicherweise nur den Regionalcode und nicht den gesamten Endpunkt angeben.
------
## Erstellen einer Chat-Vervollständigung
Einzelheiten zur Create-Chat-Completion-API finden Sie in den folgenden Ressourcen in der OpenAI-Dokumentation:
+ [Anfrage von Textparametern](https://platform.openai.com/docs/api-reference/chat/create)
+ [Parameter des Antworttextes](https://platform.openai.com/docs/api-reference/chat/object)
**Anmerkung**
Amazon Bedrock unterstützt derzeit nicht die anderen API-Operationen zur OpenAI-Chat-Vervollständigung.
Um zu erfahren, wie Sie die OpenAI-Create-Chat-Completion-API verwenden, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und folgen den Schritten:
------
#### [ OpenAI SDK (Python) ]
Gehen Sie wie folgt vor, um eine Chat-Vervollständigung mit dem OpenAI SDK zu erstellen:
1. Importieren Sie das OpenAI SDK und richten Sie den Client mit den folgenden Feldern ein:
+ `base_url` – Stellen Sie dem Amazon Bedrock Runtime-Endpunkt das Präfix `/openai/v1` wie im folgenden Format vor:
```
https://${bedrock-runtime-endpoint}/openai/v1
```
+ `api_key` – Geben Sie einen Amazon-Bedrock-API-Schlüssel an.
+ `default_headers` – Wenn Sie Header einbeziehen müssen, können Sie diese als Schlüssel-Wert-Paare in dieses Objekt aufnehmen. Sie können auch Header unter `extra_headers` angeben, wenn Sie einen bestimmten API-Aufruf tätigen.
1. Verwenden Sie die `chat.completions.create()`-Methode mit dem Client und geben Sie mindestens das `messages` und die `model` im Anforderungstext an.
Im folgenden Beispiel wird die Create-Chat-Completion-API in `us-west-2` aufgerufen. *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK*Ersetzen Sie es durch Ihren tatsächlichen API-Schlüssel.
```
from openai import OpenAI
client = OpenAI(
base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1",
api_key="$AWS_BEARER_TOKEN_BEDROCK" # Replace with actual API key
)
completion = client.chat.completions.create(
model="openai.gpt-oss-20b-1:0",
messages=[
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
)
print(completion.choices[0].message)
```
------
#### [ HTTP request ]
Gehen Sie wie folgt vor, um eine Chat-Vervollständigung mit einer direkten HTTP-Anfrage zu erstellen:
1. Geben Sie die URL an, indem Sie dem Amazon-Bedrock-Runtime-Endpunkt das Präfix `/openai/v1/chat/completions` wie im folgenden Format voranstellen:
```
https://${bedrock-runtime-endpoint}/openai/v1/chat/completions
```
1. Geben Sie Ihre AWS Anmeldeinformationen oder einen Amazon Bedrock API-Schlüssel in der `Authorization` Kopfzeile an.
1. Geben Sie im Anfragetext mindestens das `model` und die `messages` an.
Im folgenden Beispiel wird Curl verwendet, um die Create-Chat-Completion-API in `us-west-2` aufzurufen. *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK*Ersetzen Sie es durch Ihren tatsächlichen API-Schlüssel:
```
curl -X POST https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
-d '{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
}'
```
------
## So fügen Sie einen Integritätsschutz in eine Chat-Vervollständigung ein
Um Sicherheitsvorkehrungen in Modelleingaben und -antworten einzubeziehen, wenden Sie einen [Integritätsschutz](guardrails.md) an, indem Sie die folgenden [zusätzlichen Parameter](https://github.com/openai/openai-python#undocumented-request-params) als Felder im Anforderungstext aufnehmen:
+ `extra_headers` – Ordnet einem Objekt mit den folgenden Felder zu, die zusätzliche Header in der Anfrage angeben:
+ `X-Amzn-Bedrock-GuardrailIdentifier` (erforderlich) – Die ID des Integritätsschutzes.
+ `X-Amzn-Bedrock-GuardrailVersion` (erforderlich) – Die Version des Integritätsschutzes.
+ `X-Amzn-Bedrock-Trace` (optional) – Ob die Ablaufverfolgung für den Integritätsschutz aktiviert werden soll oder nicht.
+ `extra_body` – Ordnet einem Objekt zu. In dieses Objekt können Sie das `amazon-bedrock-guardrailConfig`-Feld aufnehmen, das einem Objekt mit den folgenden Feldern zugeordnet ist:
+ `tagSuffix` (optional) – Fügen Sie dieses Feld für [Eingabemarkierung](guardrails-tagging.md) hinzu.
Weitere Informationen zu diesen Parametern in Integritätsschutz für Amazon Bedrock finden Sie unter [So testen Sie Ihren Integritätsschutz](guardrails-test.md).
Wenn Sie Beispiele für die Verwendung des Integritätsschutzes mit OpenAI-Chat-Vervollständigungen sehen möchten, wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und führen Sie dann die folgenden Schritte aus:
------
#### [ OpenAI SDK (Python) ]
```
import openai
from openai import OpenAIError
# Endpoint for Amazon Bedrock Runtime
bedrock_endpoint = "https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values
bedrock_api_key = "$AWS_BEARER_TOKEN_BEDROCK"
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
client = openai.OpenAI(
api_key=bedrock_api_key,
base_url=bedrock_endpoint,
)
try:
response = client.chat.completions.create(
model=model_id,
# Specify guardrail information in the header
extra_headers={
"X-Amzn-Bedrock-GuardrailIdentifier": guardrail_id,
"X-Amzn-Bedrock-GuardrailVersion": guardrail_version,
"X-Amzn-Bedrock-Trace": "ENABLED",
},
# Additional guardrail information can be specified in the body
extra_body={
"amazon-bedrock-guardrailConfig": {
"tagSuffix": "xyz" # Used for input tagging
}
},
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
]
)
request_id = response._request_id
print(f"Request ID: {request_id}")
print(response)
except OpenAIError as e:
print(f"An error occurred: {e}")
if hasattr(e, 'response') and e.response is not None:
request_id = e.response.headers.get("x-request-id")
print(f"Request ID: {request_id}")
```
------
#### [ OpenAI SDK (Java) ]
```
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponseFor;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
// Endpoint for Amazon Bedrock Runtime
String bedrockEndpoint = "http://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
// Model ID
String modelId = "openai.gpt-oss-20b-1:0"
// Replace with actual values
String bedrockApiKey = "$AWS_BEARER_TOKEN_BEDROCK"
String guardrailId = "GR12345"
String guardrailVersion = "DRAFT"
OpenAIClient client = OpenAIOkHttpClient.builder()
.apiKey(bedrockApiKey)
.baseUrl(bedrockEndpoint)
.build()
ChatCompletionCreateParams request = ChatCompletionCreateParams.builder()
.addUserMessage("What is the temperature in Seattle?")
.model(modelId)
// Specify additional headers for the guardrail
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailIdentifier", guardrailId)
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailVersion", guardrailVersion)
// Specify additional body parameters for the guardrail
.putAdditionalBodyProperty(
"amazon-bedrock-guardrailConfig",
JsonValue.from(Map.of("tagSuffix", JsonValue.of("xyz"))) // Allows input tagging
)
.build();
HttpResponseFor rawChatCompletionResponse =
client.chat().completions().withRawResponse().create(request);
final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();
System.out.println(chatCompletion);
```
------
# Führen einer Konversation mit den Converse-API-Operationen
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 – [Beispiele für die Converse-API](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)
**Topics**
+ [Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.md)
+ [Verwenden der Converse-API](conversation-inference-call.md)
+ [Beispiele für die Converse-API](conversation-inference-examples.md)
# Unterstützte Modelle und Modellfeatures
Die Converse-API unterstützt die folgenden Amazon-Bedrock-Modelle und Modellfeatures. Die Converse-API unterstützt keine Modelle zum Einbetten oder Generieren von Bildern.
| Modell | Converse | ConverseStream | System-Prompts | Dokument-Chat | Vision | Verwendung des Tools | Streaming-Tool-Verwendung | Integritätsschutz | Amazon-S3-Links für Multimedia |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AI21 Jamba-Instruct | Ja | Ja | Ja | Nein | Nein | Nein | Nein | Nein | Nein |
| AI21 Labs Jurassic-2 (Text) | Begrenzt. Keine Chat-Unterstützung. | Nein | Nein | Nein | Nein | Nein | Nein | Ja | Nein |
| AI21 Labs Jamba 1.5 Large | Ja | Ja | Ja | Ja | Nein | Ja | Ja | Ja | Nein |
| AI21 Labs Jamba 1.5 Mini | Ja | Ja | Ja | Ja | Nein | Ja | Ja | Ja | Nein |
| Amazon Nova Premier | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja |
| Amazon Nova Pro | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja |
| Amazon Nova Lite | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja |
| Amazon Nova Micro | Ja | Ja | Ja | Nein | Nein | Ja | Ja | Ja | Nein |
| Amazon-Titan-Modelle | Ja | Ja | Nein | Ja (außer Titan Text Premier) | Nein | Nein | Nein | Ja | Nein |
| Anthropic Claude 2.x und frühere Modelle | Ja | Ja | Ja | Ja | Nein | Nein | Nein | Ja | Nein |
| Anthropic–Claude3-Modelle | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein |
| Anthropic Claude 3.5 Sonnet | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein |
| Anthropic Claude 3.5 Sonnet v2 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein |
| Anthropic Claude 3.7 Sonnet | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein |
| Anthropic Claude 3.5 Haiku | Ja | Ja | Ja | Ja | Nein | Ja | Ja | Nein | Nein |
| Anthropic Claude Sonnet 4 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Nein |
| AnthropicClaude Opus4 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Nein |
| Anthropic Claude Sonnet 4.5 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Nein |
| Anthropic Claude Haiku 4.5 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Nein |
| AnthropicClaude Opus4.1 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Nein |
| Claude Opus4,5 | Ja | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Nein |
| Cohere Command | Begrenzt. Keine Chat-Unterstützung. | Begrenzt. Keine Chat-Unterstützung. | Nein | Ja | Nein | Nein | Nein | Ja | Nein |
| Cohere Command Light | Begrenzt. Keine Chat-Unterstützung. | Begrenzt. Keine Chat-Unterstützung. | Nein | Nein | Nein | Nein | Nein | Ja | Nein |
| Cohere und Command R Command R\$1 | Ja | Ja | Ja | Ja | Nein | Ja | Ja | Nein | Nein |
| DeepSeek-R1 | Ja | Ja | Ja | Ja | Nein | Nein | Nein | Ja | Nein |
| Meta und Llama 2 Llama 3 | Ja | Ja | Ja | Ja | Nein | Nein | Nein | Ja | Nein |
| Meta Llama 3.1 | Ja | Ja | Ja | Ja | Nein | Ja | Nein | Ja | Nein |
| Meta Llama 3.2 1b and Llama 3.2 3b | Ja | Ja | Ja | Ja | Nein | Nein | Nein | Ja | Nein |
| Meta Llama 3.2 11b and Llama 3.2 90b | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Ja | Nein |
| Meta Llama 4 Maverick 17B and Llama 4.0 Scout 17B | Ja | Ja | Ja | Ja | Ja | Ja | Nein | Ja | Nein |
| Mistral AI Instruct | Ja | Ja | Nein | Ja | Nein | Nein | Nein | Ja | Nein |
| Mistral Large | Ja | Ja | Ja | Ja | Nein | Ja | Nein | Ja | Nein |
| Mistral Large 2 (24.07) | Ja | Ja | Ja | Ja | Nein | Ja | Nein | Ja | Nein |
| Mistral Small | Ja | Ja | Ja | Nein | Nein | Ja | Nein | Ja | Nein |
| Pixtral Large (25.02) | Ja | Ja | Ja | Ja | Nein | Ja | Nein | Ja | Nein |
| Writer Palmyra X4 | Ja | Ja | Ja | Ja | Nein | Ja | Nein | Ja | Nein |
| Writer Palmyra X5 | Ja | Ja | Ja | Ja | Nein | Ja | Nein | Ja | Nein |
Eine Tabelle der Regionen, die die einzelnen Modelle unterstützen, finden Sie unter [Modellunterstützung von AWS-Region in Amazon Bedrock](models-regions.md).
**Anmerkung**
Cohere Command (Text) und AI21 Labs Jurassic-2 (Text) unterstützen keinen Chat mit der Converse-API. Die Modelle können jeweils nur eine Benutzernachricht bearbeiten und den Verlauf einer Konversation nicht verwalten. Sie erhalten eine Fehlermeldung, wenn Sie versuchen, mehr als eine Nachricht weiterzuleiten.
# Verwenden 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.
**Topics**
+ [Anforderung](#conversation-inference-call-request)
+ [Antwort](#conversation-inference-call-response)
**Anmerkung**
Einschränkungen gelten für die folgenden Operationen: InvokeModel, InvokeModelWithResponseStream, Converse und ConverseStream. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
## 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.
+ **additionalModelRequestFelder** — 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.
+ **additionalModelResponseFieldPaths**— 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 (Informationen darüber, welche Modelle welche Blöcke unterstützen, finden Sie unter[Unterstützte Modelle und Modellfeatures](conversation-inference-supported-models-features.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-Prüfpunkte als Block in einer Nachricht zusammen mit einem zugehörigen Prompt hinzufügen, indem Sie `cachePoint`-Felder verwenden, um das Prompt-Caching zu nutzen. 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 den 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}
```
### additionalModelRequestFelder
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 *\$1\$1genre\$1\$1* playlist consisting of the following number of songs: *\$1\$1number\$1\$1*.**. 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" : "pop",
"number": 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 [So fügen Sie der Converse-API einen Integritätsschutz hinzu](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).
### additionalModelResponseFieldPaths
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
Dieses Feld ist einem JSON-Objekt zugeordnet. Sie können Metadatenschlüssel und Werte angeben, denen sie innerhalb dieses Objekts zugeordnet werden. Sie können Modellaufrufprotokolle mithilfe von Anforderungsmetadaten filtern.
### 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`.
**Topics**
+ [Antwort von Converse](#conversation-inference-call-response-converse)
+ [ConverseStream Antwort](#conversation-inference-call-response-converse-stream)
### 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 `cacheReadInputTokensCount` und `cacheWriteInputTokensCount` 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-Verwendung 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}}}
```
# Beispiele für die Converse-API
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()
```
------
# API-Einschränkungen
Die folgenden Einschränkungen gelten für die `ConverseStream` Operationen `InvokeModel` `InvokeModelWithResponseStream``Converse`,, und. Einige Einschränkungen variieren je nach Betrieb oder Modell, wie unten angegeben:
+ Wenn Sie diese Operationen verwenden, können Sie nur Bilder und Dokumente einbeziehen, wenn dies der Fall `role` ist`user`.
+ **Videogenerierung:** Die Videogenerierung wird mit `InvokeModel` und nicht unterstützt`InvokeModelWithResponseStream`. Stattdessen können Sie die [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)Operation verwenden. Ein Beispiel finden Sie unter [Verwenden von Amazon Nova Reel, um ein Video aus einem Text-Prompt zu generieren](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.html).
+ **Unterstützung von Dokumenten im Anforderungstext:** Das Einbeziehen von Dokumenten in den Anforderungstext wird bei Verwendung von `InvokeModel` und nicht unterstützt`InvokeModelWithResponseStream`. Um ein Dokument während der Inferenz einzubeziehen, verwenden Sie den [Chat/Text-Playground](playgrounds.md) in den AWS-Managementkonsole Operationen oder oder. `Converse` `ConverseStream`
+ **Anzahl und Größe der Dokumente:** Sie können bis zu 5 Dokumente pro Anfrage hinzufügen. Jedes Dokument darf nicht größer als 4,5 MB sein. Für Claude 4 und nachfolgende Versionen gilt die Beschränkung der Dokumentengröße von 4,5 MB nicht für das `PDF` Format. Bei Nova-Modellen gilt die Beschränkung der Dokumentengröße von 4,5 MB nicht für `DOCX` Formate `PDF` und Formate. Diese Einschränkungen gelten weiterhin in der Bedrock Console. Für einzelne Modelle gelten möglicherweise zusätzliche Inhaltsbeschränkungen, die über die von Amazon Bedrock geltenden hinausgehen. Weitere Informationen finden Sie unter **Anforderungen für Drittanbieter von Modellen**.
+ **Anzahl und Größe von Bildern**: Amazon Bedrock legt keine Einschränkungen in Bezug auf Anzahl und Größe von Bildern fest. Für einzelne Modelle können jedoch spezifische Bildanforderungen gelten. Weitere Informationen finden Sie unter **Anforderungen für Drittanbieter von Modellen**.
+ **Anforderungen des Drittanbieters für Modellanbieter:** Die Anforderungen des Drittanbieters gelten, wenn Sie die `ConverseStream` Operationen `InvokeModel` `InvokeModelWithResponseStream``Converse`,, und verwenden, und können zu einem Fehler führen, wenn sie nicht erfüllt werden. Wenn Sie ein Drittanbietermodell über Amazon Bedrock verwenden (z. B. Anthropic Claude), lesen Sie das Benutzerhandbuch und die API-Dokumentation des Anbieters, um unerwartete Fehler zu vermeiden. Der Standardendpunkt Anthropic Messages unterstützt beispielsweise eine maximale Anforderungsgröße von 32 MB. Claude hat auch spezifische Inhaltsanforderungen, z. B. maximal 100 `PDF` Seiten pro Anfrage und eine maximale Bildgröße von 8000 x 8000 px. Aktuelle Informationen zu Anfragen und Antworten von Anthropic Claude Messages, einschließlich der Anforderungen an die Größe und den Inhalt der Anfrage, finden Sie in der folgenden Dokumentation zu Anthropic Claude: [Anthropic Claude API Overview](https://platform.claude.com/docs/en/api/overview), [Anthropic Claude Messages API-Referenz](https://docs.anthropic.com/claude/reference/messages_post), [Build with Claude: Vision](https://platform.claude.com/docs/en/build-with-claude/vision) und [Build with Claude](https://platform.claude.com/docs/en/build-with-claude/pdf-support): PDF Support.
**Tipp**
Claude verlangt, dass PDF-Dokumente pro Anfrage maximal 100 Seiten umfassen. Wenn Sie größere PDF-Dokumente haben, empfehlen wir, diese auf mehrere Seiten PDFs unter 100 Seiten aufzuteilen oder mehr Text auf weniger Seiten zu konsolidieren.