Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Inviare prompt e generare risposte utilizzando l’API
Per eseguire l’inferenza dei modelli, Amazon Bedrock offre le seguenti operazioni API:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Invia una richiesta e genera una risposta. Il corpo della richiesta è specifico del modello. Per generare risposte in streaming, usa [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): invia un prompt e genera risposte con una struttura unificata in tutti i modelli. I campi di richiesta specifici del modello possono essere specificati nel campo `additionalModelRequestFields`. È anche possibile includere prompt di sistema e conversazioni precedenti per fornire un contesto. Per generare risposte in streaming, usa [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)— Invia una richiesta e genera una risposta in modo asincrono che può essere recuperata in un secondo momento. Consente di generare video.
+ [InvokeModelWithBidirectionalStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithBidirectionalStream.html) –
+ API Chat Completions OpenAI: usa l’[API Chat Completions OpenAI](https://platform.openai.com/docs/api-reference/chat/create) con modelli supportati da Amazon Bedrock per generare una risposta.
**Nota**
Le restrizioni si applicano alle seguenti operazioni:`InvokeModel`,, e. `InvokeModelWithResponseStream` `Converse` `ConverseStream` Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
Per l’inferenza del modello, è necessario definire i seguenti parametri:
+ ID modello: ID o nome della risorsa Amazon (ARN) del modello o del profilo di inferenza da utilizzare nel campo `modelId` per l’inferenza. La tabella seguente descrive come trovare IDs diversi tipi di risorse:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/inference-api.html)
+ Corpo della richiesta: contiene i parametri di inferenza per un modello e altre configurazioni. A ogni modello sono associati i propri parametri di inferenza. I parametri di inferenza per un modello personalizzato o allocato dipendono dal modello base da cui è stato creato. Per ulteriori informazioni, consulta [Parametri di richiesta di inferenza e campi di risposta per i modelli di fondazione](model-parameters.md).
Seleziona un argomento per imparare a usare l' APIsinvocazione del modello.
**Topics**
+ [Invia una sola richiesta con InvokeModel](inference-invoke.md)
+ [Invocare un modello con l’API Chat Completions OpenAI](inference-chat-completions.md)
+ [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md)
+ [Restrizioni API](inference-api-restrictions.md)
# Invia una sola richiesta con InvokeModel
L'inferenza viene eseguita su un singolo prompt utilizzando le operazioni [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)e [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API e specificando un modello. I modelli Amazon Bedrock si differenziano per l’accettazione di input di testo, immagini o video e per la possibilità di produrre output di testo, immagini o embedding. Alcuni modelli possono restituire la risposta in un flusso. Per controllare il supporto del modello per input, output e streaming, esegui una di queste operazioni:
+ Controlla il valore nelle colonne **Modalità di input**, **Modalità di output** o **Streaming supportato** per un modello in [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
+ Invia una [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)richiesta con l'ID del modello e controlla i valori nel campo `inputModalities``outputModalities`, e. `responseStreamingSupported`
Esegui l'inferenza del modello su un prompt inviando una [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)richiesta [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)or con un endpoint di runtime [Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt).
**Nota**
Le restrizioni si applicano alle seguenti operazioni:`InvokeModel`,, e`InvokeModelWithResponseStream`. `Converse` `ConverseStream` Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
I seguenti campi sono obbligatori:
****
| Campo | Caso d’uso |
| --- | --- |
| modelId | Specificare il modello, il profilo di inferenza o il prompt di Gestione prompt da utilizzare. Per ulteriori informazioni su come trovare questo valore, consulta [Inviare prompt e generare risposte utilizzando l’API](inference-api.md). |
| body | Specificare i parametri di inferenza per un modello. Per informazioni sui parametri di inferenza per modelli diversi, consulta [Parametri di richiesta di inferenza e campi di risposta per i modelli di fondazione](model-parameters.md). Se si specifica un prompt da Gestione dei prompt nel campo modelId, omettere questo campo (se lo si include, viene ignorato). |
I seguenti campi sono facoltativi:
****
| Campo | Caso d’uso |
| --- | --- |
| accept | Specificare il tipo di supporto per il corpo della richiesta. Per ulteriori informazioni, consulta Media Types sul [sito web di Swagger](https://swagger.io/specification/). |
| contentType | Specificare il tipo di supporto per il corpo della risposta. Per ulteriori informazioni, consulta Media Types sul [sito web di Swagger](https://swagger.io/specification/). |
| performanceConfigLatency | Specificare se ottimizzare un modello per la latenza. Per ulteriori informazioni, consulta [Ottimizzare l’inferenza del modello per la latenza](latency-optimized-inference.md). |
| guardrailIdentifier | Specificare un guardrail da applicare al prompt e alla risposta. Per ulteriori informazioni, consulta [Testare il guardrail](guardrails-test.md). |
| guardrailVersion | Specificare un guardrail da applicare al prompt e alla risposta. Per ulteriori informazioni, consulta [Testare il guardrail](guardrails-test.md). |
| trace | Specificare se restituire la traccia per il guardrail indicato. Per ulteriori informazioni, consulta [Testare il guardrail](guardrails-test.md). |
| ServiceTier | Per specificare il livello di servizio per una richiesta. Per ulteriori informazioni, consulta [Livelli di servizio per l'ottimizzazione delle prestazioni e dei costi](service-tiers-inference.md). |
## Invocare esempi di codice del modello
Questo argomento fornisce alcuni esempi di base per eseguire l'inferenza utilizzando un singolo prompt con l'[InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Per altri esempi con modelli diversi, consulta le seguenti risorse:
+ Scegli un esempio nell’argomento [Esempi di codice per Amazon Bedrock Runtime utilizzando AWS SDKs](service_code_examples_bedrock-runtime.md).
+ Consulta il riferimento ai parametri di inferenza per il modello desiderato in [Parametri di richiesta di inferenza e campi di risposta per i modelli di fondazione](model-parameters.md).
Gli esempi seguenti presuppongono che tu abbia impostato l'accesso programmatico in modo da autenticarti automaticamente all' AWS CLI SDK for Python (Boto3) come impostazione predefinita quando esegui questi esempi. Regione AWS Per informazioni sulla configurazione dell’accesso alla programmazione, consulta [Iniziare a utilizzare l’API](getting-started-api.md).
**Nota**
Esamina i seguenti punti prima di provare gli esempi:
È possibile testare questi esempi nella Regione Stati Uniti orientali (Virginia settentrionale) (us-east-1), che supporta tutti i modelli utilizzati negli esempi.
Il parametro `body` può essere di grandi dimensioni, quindi per alcuni esempi di CLI, verrà chiesto di creare un file JSON e di passarlo all’argomento `--body` anziché specificarlo nella riga di comando.
Per gli esempi di immagini e video, verrà chiesto di utilizzare la propria immagine e il proprio video. Gli esempi presuppongono che il file di immagine abbia un nome *image.png* e che il file video abbia un nome. *video.mp4*
Potrebbe essere necessario convertire immagini o video in una stringa con codifica base64 o caricarli in una posizione Amazon S3. Negli esempi, è necessario sostituire i segnaposto con la stringa effettiva con codifica base64 o con la posizione S3.
Espandi una sezione per provare alcuni esempi di codice di base.
### Generare testo con un prompt di testo
I seguenti esempi generano una risposta di testo a un prompt di testo utilizzando il modello Amazon Titan Text Premier. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Eseguite il seguente comando in un terminale e trovate la risposta generata in un file chiamato*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 ]
Esegui il codice Python di esempio per generare una risposta di testo:
```
# 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)
```
------
### Genera testo con un prompt di testo utilizzando il livello di servizio
Gli esempi seguenti generano una risposta testuale a un prompt di testo utilizzando il modello OpenAI GPT con un livello di servizio per dare priorità alla richiesta. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Esegui il comando seguente in un terminale e convalida il livello di servizio nella risposta.
```
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 ]
Esegui il seguente esempio di codice Python per generare una risposta testuale con livello di servizio:
```
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)
```
------
### Generare un’immagine con un prompt di testo.
I seguenti esempi di codice generano un’immagine utilizzando un prompt di testo con il modello Stable Diffusion XL 1.0. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Esegui il seguente comando in un terminale e trova la risposta generata in un file chiamato*invoke-model-output.txt*. I byte che rappresentano l’immagine si trovano nel campo `base64` della risposta:
```
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 ]
Esegui il seguente esempio di codice Python per generare un'immagine e trovare il file di *stability\$11.png* immagine risultante in una cartella chiamata. *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}")
```
------
### Generare embedding dal testo
I seguenti esempi utilizzano il modello Amazon Titan Text Embeddings V2 per generare embedding binari per un input di testo. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Esegui il seguente comando in un terminale e trova la risposta generata in un file chiamato*invoke-model-output.txt*. Gli embedding risultanti si trovano nel campo `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 ]
Esegui questo esempio di codice Python per generare embedding per il testo fornito:
```
# 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()
```
------
### Generare embedding da un’immagine
I seguenti esempi utilizzano il modello Amazon Titan Multimodal Embeddings G1 per generare embedding per un’input immagine. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Apri il terminale ed esegui questo comando:
1. Converti un'immagine con un titolo *image.png* nella tua cartella corrente in una stringa con codifica base64 e scrivila in un file intitolato *image.txt* eseguendo il seguente comando:
```
base64 -i image.png -o image.txt
```
1. Crea un file JSON chiamato *image-input-embeddings-output.json* e incolla il seguente codice JSON, sostituendolo *\$1\$1image-base64\$1* con il contenuto del *image.txt* file (assicurati che non ci sia una nuova riga alla fine della stringa):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Eseguite il comando seguente, specificando il *image-input-embeddings-output.json* file come corpo.
```
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. Trova gli incorporamenti risultanti nel *invoke-model-output.txt* file.
------
#### [ Python ]
Nel seguente script Python, sostituisci */path/to/image* con il percorso di un'immagine effettiva. Esegui lo script per generare gli embedding:
```
# 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()
```
------
### Generare una risposta di testo a un’immagine con un prompt di testo associato
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
L’esempio seguente utilizza il modello Anthropic Claude 3 Haiku per generare una risposta, sulla base di un’immagine e di un prompt di testo che chiede il contenuto dell’immagine stessa. Apri il terminale ed esegui questo comando:
1. Converte un'immagine con titolo *image.png* nella cartella corrente in una stringa con codifica base64 e scrivila in un file intitolato eseguendo il seguente comando: *image.txt*
```
base64 -i image.png -o image.txt
```
1. Crea un file JSON chiamato *image-text-input.json* e incolla il seguente codice JSON, sostituendolo *\$1\$1image-base64\$1* con il contenuto del *image.txt* file (assicurati che non ci sia una nuova riga alla fine della stringa):
```
{
"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. Esegui il comando seguente per generare un output di testo, basato sull'immagine e sul prompt di testo che lo accompagna, in un file chiamato: *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. Trova l'output nel *invoke-model-output.txt* file nella cartella corrente.
------
#### [ Python ]
Nel seguente script python, sostituiscilo */path/to/image.png* con il percorso effettivo dell'immagine prima di eseguire lo script:
```
# 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()
```
------
### Generare una risposta di testo a un video caricato in Amazon S3 con un prompt di testo associato
Gli esempi seguenti mostrano come generare una risposta con il modello Amazon Nova Lite, sulla base di un video caricato in un bucket S3 e di un prompt di testo associato.
**Prerequisito:** carica un video intitolato *video.mp4* su un bucket Amazon S3 nel tuo account seguendo la procedura descritta in [Uploading](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) objects nella Amazon Simple Storage Service User Guide. Prendi nota dell’URI S3 del video.
Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Apri un terminale ed esegui il comando seguente, sostituendolo *s3://amzn-s3-demo-bucket/video.mp4* con la posizione S3 effettiva del tuo video:
```
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
```
Trova l'output nel *invoke-model-output.txt* file nella cartella corrente.
------
#### [ Python ]
Nel seguente script Python, sostituiscilo *s3://amzn-s3-demo-bucket/video.mp4* con la posizione S3 effettiva del tuo video. Esegui lo script.
```
# 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()
```
------
### Generare una risposta di testo a un video convertito in una stringa con codifica base64 con un prompt di testo associato
Gli esempi seguenti mostrano come generare una risposta con il modello Amazon Nova Lite, sulla base di un video convertito con codifica base64 e di un prompt di testo associato. Scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ CLI ]
Esegui questa operazione:
1. Convertite un video intitolato *video.mp4* nella cartella corrente in base64 eseguendo il seguente comando:
```
base64 -i video.mp4 -o video.txt
```
1. Crea un file JSON chiamato *video-text-input.json* e incolla il seguente codice JSON, sostituendolo *\$1\$1video-base64\$1* con il contenuto del `video.txt` file (assicurati che non ci sia una nuova riga alla fine):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Eseguite il comando seguente per generare un output di testo basato sul video e sul relativo messaggio di testo in un file chiamato: *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. Trova l'output nel *invoke-model-output.txt* file nella cartella corrente.
------
#### [ Python ]
Nel seguente script Python, sostituiscilo */path/to/video.mp4* con il percorso effettivo del video. Esegui lo script.
```
# 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()
```
------
## Invocazione del modello con un esempio di codice in streaming
**Nota**
Non AWS CLI supporta lo streaming.
L'esempio seguente mostra come utilizzare l'[InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API per generare testo in streaming con Python utilizzando il prompt. *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()))
```
# Invocare un modello con l’API Chat Completions OpenAI
Per eseguire l’inferenza del modello, è possibile utilizzare l’[API Create chat completion OpenAI](https://platform.openai.com/docs/api-reference/chat/create) con i modelli Amazon Bedrock.
L’API Create chat completion può essere chiamata nei modi seguenti:
+ Effettuare una richiesta HTTP con un endpoint di runtime Amazon Bedrock.
+ Utilizzare una richiesta OpenAI SDK con un endpoint di runtime Amazon Bedrock.
Per ulteriori informazioni, scegli un argomento:
**Topics**
+ [Regioni e modelli supportati per l’API Chat Completions OpenAI](#inference-chat-completions-supported)
+ [Prerequisiti per utilizzare l’API Chat Completions](#inference-chat-completions-prereq)
+ [Creare un completamento di chat](#inference-chat-completions-create)
+ [Includere un guardrail in un completamento di chat](#inference-chat-completions-guardrails)
## Regioni e modelli supportati per l’API Chat Completions OpenAI
Puoi utilizzare l'API Create chat completion con tutti i OpenAI modelli supportati in Amazon Bedrock e nelle AWS regioni che supportano questi modelli. Per ulteriori informazioni sulle Regioni e sui modelli supportati, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
## Prerequisiti per utilizzare l’API Chat Completions
Per visualizzare i prerequisiti per l’utilizzo dell’API Chat Completions, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ OpenAI SDK ]
+ **Autenticazione**: OpenAI SDK supporta solo l’autenticazione con una chiave API Amazon Bedrock. Genera una chiave API Amazon Bedrock per autenticare la tua richiesta. Per informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consulta la sezione Chiavi API nel capitolo Build.
+ **Endpoint**: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli [endpoint e nelle quote di Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client.
+ **Installa OpenAI SDK**: per ulteriori informazioni, consulta [Librerie](https://platform.openai.com/docs/libraries) nella documentazione OpenAI.
------
#### [ HTTP request ]
+ **Autenticazione**: puoi autenticarti con AWS le tue credenziali o con una chiave API Amazon Bedrock.
Configura AWS le tue credenziali o genera una chiave API Amazon Bedrock per autenticare la tua richiesta.
+ Per ulteriori informazioni sulla configurazione delle AWS credenziali, consulta Accesso [programmatico](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) con credenziali di sicurezza. AWS
+ Per informazioni sulle chiavi API di Amazon Bedrock e su come generarle, consulta la sezione Chiavi API nel capitolo Build.
+ **Endpoint**: trova l'endpoint che corrisponde alla AWS regione da utilizzare negli [endpoint e nelle quote di Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Se utilizzi un AWS SDK, potresti dover specificare solo il codice regionale e non l'intero endpoint quando configuri il client.
------
## Creare un completamento di chat
Per i dettagli sull’API Create chat completion, consulta le risorse seguenti nella documentazione OpenAI:
+ [Parametri del corpo della richiesta](https://platform.openai.com/docs/api-reference/chat/create)
+ [Parametri del corpo di risposta](https://platform.openai.com/docs/api-reference/chat/object)
**Nota**
Amazon Bedrock attualmente non supporta le altre operazioni dell’API Chat Completions OpenAI.
Per le modalità di utilizzo dell’API Create chat completion OpenAI, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ OpenAI SDK (Python) ]
Per creare un completamento di chat con un SDK OpenAI, esegui queste operazioni:
1. Importa il componente SDK OpenAI e configura il client con i seguenti campi:
+ `base_url`: anteponi l’endpoint di runtime Amazon Bedrock a `/openai/v1`, come nel seguente formato:
```
https://${bedrock-runtime-endpoint}/openai/v1
```
+ `api_key`: specifica una chiave API Amazon Bedrock.
+ `default_headers`: se è necessario includere intestazioni, includile come coppie chiave-valore in questo oggetto. In alternativa, puoi specificare le intestazioni in `extra_headers` quando effettui una chiamata API specifica.
1. Utilizza il metodo `chat.completions.create()` con il client e specifica almeno `model` e `messages` nel corpo della richiesta.
L’esempio seguente chiama l’API Create chat completion in `us-west-2`. Sostituiscilo *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* con la tua chiave API effettiva.
```
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 ]
Per creare un completamento della chat con una richiesta HTTP diretta, esegui queste operazioni:
1. Specifica l’URL anteponendo l’endpoint di runtime Amazon Bedrock a `/openai/v1/chat/completions`, come nel seguente formato:
```
https://${bedrock-runtime-endpoint}/openai/v1/chat/completions
```
1. Specificate AWS le vostre credenziali o una chiave API Amazon Bedrock nell'`Authorization`intestazione.
1. Nel corpo della richiesta, specifica almeno `model` e `messages` nel corpo della richiesta.
L’esempio seguente utilizza il comando curl per chiamare l’API Create chat completion in `us-west-2`. Sostituisci *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* con la tua chiave API effettiva:
```
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!"
}
]
}'
```
------
## Includere un guardrail in un completamento di chat
Per includere misure di sicurezza nell’input e nelle risposte del modello, applica un [guardrail](guardrails.md) quando esegui l’invocazione del modello includendo i seguenti [parametri aggiuntivi](https://github.com/openai/openai-python#undocumented-request-params) come campi nel corpo della richiesta.
+ `extra_headers`: esegue il mapping a un oggetto contenente i seguenti campi, che specificano intestazioni aggiuntive nella richiesta:
+ `X-Amzn-Bedrock-GuardrailIdentifier` (obbligatorio): ID del guardrail.
+ `X-Amzn-Bedrock-GuardrailVersion` (obbligatorio): versione del guardrail.
+ `X-Amzn-Bedrock-Trace` (facoltativo): indica se abilitare o meno la traccia del guardrail.
+ `extra_body`: esegue il mapping a un oggetto. In tale oggetto è possibile includere il campo `amazon-bedrock-guardrailConfig`, che viene mappato a un oggetto contenente i campi seguenti:
+ `tagSuffix` (facoltativo): includi questo campo per il[tagging di input](guardrails-tagging.md).
Per ulteriori informazioni sui questi parametri in Guardrail per Amazon Bedrock, consulta [Testare il guardrail](guardrails-test.md).
Per esempi di utilizzo dei guardrail con Chat Completions OpenAI, scegli la scheda relativa al metodo che preferisci, quindi segui la procedura:
------
#### [ 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);
```
------
# Avvio di una conversazione con le operazioni dell’API Converse
L’API Converse per Amazon Bedrock consente di creare applicazioni conversazionali che inviano e ricevono messaggi verso e da un modello Amazon Bedrock. È possibile ad esempio creare un chatbot che gestisca una conversazione a più turni e utilizzi una personalizzazione del tono o della persona adatta alle esigenze specifiche, come un utile assistente di supporto tecnico.
Per utilizzare l'ConverseAPI, utilizzi le operazioni [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) o [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)(per lo streaming delle risposte) per inviare messaggi a un modello. È possibile utilizzare le operazioni di inferenza di base esistenti ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) per applicazioni di conversazione. Si consiglia tuttavia di utilizzare l’API Converse in quanto è un’API coerente in grado di funzionare con tutti i modelli Amazon Bedrock che supportano i messaggi. Ciò significa che è possibile scrivere il codice una sola volta e utilizzarlo con modelli diversi. Se un modello ha parametri di inferenza unici, l’API Converse consente anche di passare tali parametri in una struttura specifica del modello.
L’API Converse può essere utilizzata per implementare l’[uso di strumenti](tool-use.md) e di [guardrail](guardrails-use-converse-api.md) nelle tue applicazioni.
**Nota**
Con i modelli Mistral AI and Meta, l’API Converse integra l’input dell’utente in un tipo di prompt specifico del modello che abilita le conversazioni.
Le restrizioni si applicano alle seguenti operazioni:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, e`ConverseStream`. Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
Per esempi di codice, consulta le sezioni seguenti:
+ Esempi Python per questo argomento: [Esempi di API Converse](conversation-inference-examples.md)
+ Vari linguaggi e modelli: [Esempi di codice per Amazon Bedrock Runtime utilizzando AWS SDKs](service_code_examples_bedrock-runtime.md)
+ Tutorial Java: [una guida per gli sviluppatori Java alla nuova API Converse di Bedrock](https://community.aws/content/2hUiEkO83hpoGF5nm3FWrdfYvPt/amazon-bedrock-converse-api-java-developer-guide)
+ JavaScript tutorial — [Una guida per sviluppatori alla nuova Converse API di Bedrock](https://community.aws/content/2dtauBCeDa703x7fDS9Q30MJoBA/amazon-bedrock-converse-api-developer-guide)
**Topics**
+ [Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md)
+ [Utilizzo dell’API Converse](conversation-inference-call.md)
+ [Esempi di API Converse](conversation-inference-examples.md)
# Modelli e funzionalità del modello supportati
L’API Converse supporta i seguenti modelli Amazon Bedrock con le relative funzionalità. L’API Converse non supporta alcun modello di embedding o di generazione di immagini.
| Modello | Converse | ConverseStream | Prompt di sistema | Chat con documenti | Vista | Utilizzo degli strumenti | Utilizzo degli strumenti di streaming | Guardrail | Link Amazon S3 per contenuti multimediali |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AI21 Jamba-Instruct | Sì | Sì | Sì | No | No | No | No | No | No |
| AI21 Labs Jurassic-2 (testo) | Limitato. Nessun supporto via chat. | No | No | No | No | No | No | Sì | No |
| AI21 Labs Jamba 1.5 Large | Sì | Sì | Sì | Sì | No | Sì | Sì | Sì | No |
| AI21 Labs Jamba 1.5 Mini | Sì | Sì | Sì | Sì | No | Sì | Sì | Sì | No |
| Amazon Nova Premier | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì |
| Amazon Nova Pro | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì |
| Amazon Nova Lite | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì |
| Amazon Nova Micro | Sì | Sì | Sì | No | No | Sì | Sì | Sì | No |
| Modelli Amazon Titan | Sì | Sì | No | Sì (ad eccezione di Titan Text Premier) | No | No | No | Sì | No |
| Modelli Anthropic Claude 2.x e precedenti | Sì | Sì | Sì | Sì | No | No | No | Sì | No |
| Modelli Anthropic Claude 3 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No |
| Anthropic Claude 3.5 Sonnet | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No |
| Anthropic Claude 3.5 Sonnet v2 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No |
| Anthropic Claude 3.7 Sonnet | Sì | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No |
| Anthropic Claude 3.5 Haiku | Sì | Sì | Sì | Sì | No | Sì | Sì | No | No |
| Anthropic Claude Sonnet 4 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No | No |
| AnthropicClaude Opus4 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No | No |
| Anthropic Claude Sonnet 4.5 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No | No |
| Anthropic Claude Haiku 4.5 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No | No |
| AnthropicClaude Opus4.1 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No | No |
| Claude Opus4.5 | Sì | Sì | Sì | Sì | Sì | Sì | Sì | No | No |
| Cohere Command | Limitato. Nessun supporto via chat. | Limitato. Nessun supporto via chat. | No | Sì | No | No | No | Sì | No |
| Cohere Command Light | Limitato. Nessun supporto via chat. | Limitato. Nessun supporto via chat. | No | No | No | No | No | Sì | No |
| Cohere e Command R Command R\$1 | Sì | Sì | Sì | Sì | No | Sì | Sì | No | No |
| DeepSeek-R1 | Sì | Sì | Sì | Sì | No | No | No | Sì | No |
| Meta e Llama 2 Llama 3 | Sì | Sì | Sì | Sì | No | No | No | Sì | No |
| Meta Llama 3.1 | Sì | Sì | Sì | Sì | No | Sì | No | Sì | No |
| Meta Llama 3.2 1b and Llama 3.2 3b | Sì | Sì | Sì | Sì | No | No | No | Sì | No |
| Meta Llama 3.2 11b and Llama 3.2 90b | Sì | Sì | Sì | Sì | Sì | Sì | No | Sì | No |
| Meta Llama 4 Maverick 17B and Llama 4.0 Scout 17B | Sì | Sì | Sì | Sì | Sì | Sì | No | Sì | No |
| Mistral AI Instruct | Sì | Sì | No | Sì | No | No | No | Sì | No |
| Mistral Large | Sì | Sì | Sì | Sì | No | Sì | No | Sì | No |
| Mistral Large 2 (24.07) | Sì | Sì | Sì | Sì | No | Sì | No | Sì | No |
| Mistral Small | Sì | Sì | Sì | No | No | Sì | No | Sì | No |
| Pixtral Large (25.02) | Sì | Sì | Sì | Sì | No | Sì | No | Sì | No |
| Writer Palmyra X4 | Sì | Sì | Sì | Sì | No | Sì | No | Sì | No |
| Writer Palmyra X5 | Sì | Sì | Sì | Sì | No | Sì | No | Sì | No |
Per una tabella delle Regioni che supportano ciascun modello, consulta [Supporto del modello da parte Regione AWS di Amazon Bedrock](models-regions.md).
**Nota**
Cohere Command (testo) e AI21 Labs Jurassic-2 (testo) non supportano la chat con l’API Converse. I modelli possono gestire solo un messaggio utente alla volta e non possono mantenere la cronologia di una conversazione. Se si tenta di trasmettere più di un messaggio, viene visualizzato un errore.
# Utilizzo dell’API Converse
Per utilizzare l’API Converse, vengono chiamate le operazioni `Converse` o `ConverseStream` per inviare messaggi a un modello. Per chiamare `Converse`, è richiesta l’autorizzazione per l’operazione `bedrock:InvokeModel`. Per chiamare `ConverseStream`, è richiesta l’autorizzazione per l’operazione `bedrock:InvokeModelWithResponseStream`.
**Topics**
+ [Richiesta](#conversation-inference-call-request)
+ [Risposta](#conversation-inference-call-response)
**Nota**
Le restrizioni si applicano alle seguenti operazioni: InvokeModel, InvokeModelWithResponseStream, Converse e ConverseStream. Per i dettagli, consulta [Restrizioni API](inference-api-restrictions.md).
## Richiesta
Quando si effettua una richiesta [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) con un [endpoint di runtime Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt), è possibile includere i seguenti campi:
+ **modelId**: parametro obbligatorio nell’intestazione che consente di specificare la risorsa da utilizzare per l’inferenza.
+ I seguenti campi consentono di personalizzare il prompt:
+ **messages**: consente di specificare il contenuto e il ruolo dei prompt.
+ **system**: consente di specificare i prompt di sistema che definiscono le istruzioni o il contesto per il modello.
+ **inferenceConfig**: consente di specificare i parametri di inferenza comuni a tutti i modelli. Parametri di inferenza che influenzano la generazione della risposta.
+ **additionalModelRequestCampi**: da utilizzare per specificare i parametri di inferenza specifici del modello con cui si esegue l'inferenza.
+ **promptVariables** (se si utilizza un prompt di Gestione prompt): consente di definire le variabili da usare nel prompt e i valori da assegnarvi.
+ I seguenti campi consentono di personalizzare la modalità di restituzione della risposta:
+ **guardrailConfig**: consente di includere un guardrail da applicare all’intero prompt.
+ **toolConfig**: consente di includere uno strumento che aiuti un modello a generare risposte.
+ **additionalModelResponseFieldPaths**— Utilizzate questo campo per specificare i campi da restituire come oggetto puntatore JSON.
+ **ServiceTier**: utilizzare questo campo per specificare il livello di servizio per una particolare richiesta
+ **requestMetadata**: consente di includere metadati che si possono filtrare quando si utilizzano log di invocazione.
**Nota**
Le seguenti restrizioni si applicano quando si utilizza un prompt di Gestione prompt con `Converse` o `ConverseStream`:
Non è possibile includere i campi `additionalModelRequestFields`, `inferenceConfig`, `system` o `toolConfig`.
Se si include il campo `messages`, i messaggi vengono aggiunti dopo i messaggi definiti nel prompt.
Se si include il campo `guardrailConfig`, il guardrail viene applicato all’intero prompt. Se includi `guardContent` blocchi nel [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)campo, il guardrail verrà applicato solo a quei blocchi.
Per ulteriori informazioni su una campo nel corpo della richiesta `Converse`, espandi la sezione corrispondente:
### messages
Il campo `messages` è un array di oggetti [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), ciascuno dei quali definisce un messaggio tra l’utente e il modello. Un oggetto `Message` contiene i campi seguenti:
+ **role**: definisce se il messaggio proviene da `user` (prompt inviato al modello) o `assistant` (risposta del modello).
+ **content**: definisce il contenuto del prompt.
**Nota**
Amazon Bedrock non archivia testo, immagini o documenti forniti dall’utente come contenuto. I dati vengono utilizzati solo per generare la risposta.
È possibile mantenere il contesto della conversazione includendone tutti i messaggi nelle richieste `Converse` successive e utilizzando il campo `role` per specificare se il messaggio proviene dall’utente o dal modello.
Il `content` campo è mappato su una serie di [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)oggetti. All'interno di ciascuno [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), puoi specificare uno dei seguenti campi (per vedere quali modelli supportano quali blocchi, vedi[Modelli e funzionalità del modello supportati](conversation-inference-supported-models-features.md)):
------
#### [ text ]
Il campo `text` viene mappato a una stringa che specifica il prompt. Il `text` campo viene interpretato insieme ad altri campi specificati nello stesso [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
Quanto segue mostra un oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matrice contenente solo un testo [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "string"
}
]
}
```
------
#### [ image ]
Il `image` campo è mappato su un [ImageBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html). Passa i byte non elaborati, con codifica base64, per un’immagine nel campo `bytes`. Se si utilizza un AWS SDK, non è necessario codificare i byte in base64.
Se si esclude il campo `text`, il modello descrive l’immagine.
Quanto segue mostra un esempio di oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con un `content` array contenente solo un'immagine: [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
}
]
}
```
È anche possibile specificare un URI Amazon S3 anziché passare i byte direttamente nel corpo della richiesta. Di seguito viene mostrato un oggetto `Message` di esempio con un array di contenuti in cui è inclusa l’origine passata tramite un URI Amazon S3.
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myImage",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ document ]
Il `document` campo è mappato su un [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html). Se si include un oggetto `DocumentBlock`, verificare che la richiesta sia conforme alle seguenti restrizioni:
+ Nel campo `content` dell’oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), è necessario includere anche un campo `text` con un prompt relativo al documento.
+ Passa i byte non elaborati, con codifica base64, per il documento nel campo `bytes`. Se utilizzi un SDK AWS , non è necessario utilizzare la codifica base64 per i byte.
+ Il campo `name` può contenere solo i seguenti caratteri:
+ Caratteri alfanumerici
+ Caratteri di spaziatura (non più di uno in una stessa riga)
+ Trattini
+ Parentesi
+ Parentesi quadre
**Nota**
Il campo `name` è vulnerabile alle iniezioni di prompt, poiché il modello potrebbe inavvertitamente interpretarle come istruzioni. Pertanto, consigliamo di specificare un nome neutro.
Quando si utilizza un documento, è possibile abilitare il tag `citations`, che fornisce citazioni specifiche del documento nella risposta alla chiamata API. Consulta l'[DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html)API per maggiori dettagli.
Quanto segue mostra un oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) di esempio con un `content` array contenente solo un documento [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)e un testo [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)di accompagnamento obbligatorio.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"bytes": "document in bytes"
}
}
}
]
}
```
È anche possibile specificare un URI Amazon S3 anziché passare i byte direttamente nel corpo della richiesta. Di seguito viene mostrato un oggetto `Message` di esempio con un array di contenuti in cui è inclusa l’origine passata tramite un URI Amazon S3.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myDocument",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ video ]
Il `video` campo è mappato a un [VideoBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_VideoBlock.html)oggetto. Passa i byte non elaborati nel campo `bytes` con codifica base64. Se si utilizza l' AWS SDK, non è necessario codificare i byte in base64.
Se non si include il campo `text`, il modello descrive il video.
Quanto segue mostra un oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) di esempio con un `content` array contenente solo un video. [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": "video in bytes"
}
}
}
]
}
```
È anche possibile specificare un URI Amazon S3 anziché passare i byte direttamente nel corpo della richiesta. Di seguito viene mostrato un oggetto `Message` di esempio con un array di contenuti in cui è inclusa l’origine passata tramite un URI Amazon S3.
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myVideo",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
**Nota**
Il ruolo assunto deve disporre dell’autorizzazione `s3:GetObject` per l’URI Amazon S3. Il campo `bucketOwner` è facoltativo, ma è necessario specificare se l’account che effettua la richiesta non possiede il bucket in cui si trova l’URI Amazon S3. Per ulteriori informazioni, consulta [Configurare l’accesso a bucket Amazon S3](s3-bucket-access.md).
------
#### [ cachePoint ]
È possibile aggiungere punti di controllo della cache come blocco in un messaggio insieme a un prompt associato tramite i campi `cachePoint` per utilizzare il caching dei prompt. Il caching dei prompt è una funzionalità che consente di iniziare a memorizzare nella cache il contesto delle conversazioni per ottenere risparmi in termini di costi e latenza. Per ulteriori informazioni, consulta [Caching dei prompt per un’inferenza del modello più rapida](prompt-caching.md).
Di seguito viene illustrato un oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) di esempio con un `content` array contenente un documento [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)e il testo di accompagnamento obbligatorio [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), nonché un **CachePoint** che aggiunge sia il contenuto del documento che quello del testo alla cache.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "string",
"source": {
"bytes": "document in bytes"
}
}
},
{
"cachePoint": {
"type": "default"
}
}
]
}
```
------
#### [ guardContent ]
Il `guardContent` campo è mappato a un oggetto. [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) È possibile utilizzare questo campo per specificare un input che deve essere valutato dal guardrail definito nel campo `guardrailConfig`. Se non si specifica questo campo, il guardrail valuta tutti i messaggi nel corpo della richiesta. In un oggetto `GuardBlock`, si possono passare i seguenti tipi di contenuto:
+ **text** — Quanto segue mostra un esempio di oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con un `content` array contenente solo un testo [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"
]
}
]
}
```
Si definisce il testo da valutare e si includono i qualificatori da utilizzare per la [correlazione contestuale](guardrails-contextual-grounding-check.md).
+ **image** — Quanto segue mostra un oggetto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con un `content` array contenente solo un'immagine [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
]
}
```
Si specifica il formato dell’immagine e si definisce l’immagine in byte.
Per ulteriori informazioni sull’utilizzo dei guardrail, consulta [Rilevare e filtrare contenuti dannosi utilizzando Guardrail per Amazon Bedrock](guardrails.md).
------
#### [ reasoningContent ]
Il `reasoningContent` campo è mappato su un [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html). Questo blocco include contenuti riguardanti il ragionamento che è stato eseguito dal modello per generare la risposta nell’oggetto `ContentBlock` associato.
Di seguito viene mostrato un oggetto `Message` con un array `content` contenente solo un oggetto `ReasoningContentBlock` e un oggetto `ContentBlock` testo associato.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"reasoningContent": {
"reasoningText": {
"text": "string",
"signature": "string"
}
"redactedContent": "base64-encoded binary data object"
}
}
]
}
```
L’oggetto `ReasoningContentBlock` contiene il ragionamento utilizzato per generare il contenuto associato nel campo `reasoningText`, oltre a qualsiasi contenuto del ragionamento crittografato dal provider del modello per motivi di affidabilità e sicurezza nel campo `redactedContent`.
Nel campo `reasoningText`, i campi `text` descrivono il ragionamento. Il campo `signature` è un hash di tutti i messaggi della conversazione ed è una protezione contro la manomissione del ragionamento utilizzato dal modello. È necessario includere la firma e tutti i messaggi precedenti nelle richieste `Converse` successive. Se uno qualsiasi dei messaggi viene modificato, la risposta genera un errore.
------
#### [ toolUse ]
Contiene informazioni su uno strumento che il modello può utilizzare. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
------
#### [ toolResult ]
Contiene informazioni sul risultato ottenuto dal modello con l’utilizzo di uno strumento. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
------
Nell’esempio `messages` seguente, l’utente richiede un elenco di tre brani pop e il modello genera un elenco di brani.
```
[
{
"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"
}
]
}
]
```
### sistema
Un prompt di sistema è un tipo di prompt che fornisce istruzioni o contesto al modello sull’attività che deve eseguire o sulla persona che dovrebbe adottare durante la conversazione. È possibile specificare un elenco di prompt di sistema per la richiesta nel campo `system` ([SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)), come illustrato nell'esempio seguente.
```
[
{
"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
L'ConverseAPI supporta un set base di parametri di inferenza impostati nel `inferenceConfig` campo (). [InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html) I parametri di inferenza inclusi nel set di base sono i seguenti:
+ **maxTokens**: numero massimo di token da consentire nella risposta generata.
+ **stopSequences**: elenco di sequenze di arresto. Una sequenza di arresto è una sequenza di caratteri che determina l’interruzione della generazione della risposta da parte del modello.
+ **temperature**: probabilità che il modello selezioni opzioni con maggiore probabilità durante la generazione di una risposta.
+ **topP**: percentuale di candidati più probabili che il modello considera per il token successivo.
Per ulteriori informazioni, consulta [Influenza sulla generazione della risposta con i parametri di inferenza](inference-parameters.md).
L’esempio JSON seguente imposta il parametro di inferenza `temperature`.
```
{"temperature": 0.5}
```
### additionalModelRequestCampi
Se il modello in uso ha parametri di inferenza aggiuntivi, è possibile impostare tali parametri specificandoli come elementi JSON nel campo `additionalModelRequestFields`. L’esempio JSON seguente mostra come impostare `top_k`, disponibile nei modelli Anthropic Claude, ma non è un parametro di inferenza di base nell’API Messages.
```
{"top_k": 200}
```
### promptVariables
Se si specifica un prompt di [Gestione prompt](prompt-management.md) in `modelId` come risorsa su cui eseguire l’inferenza, è possibile utilizzare questo campo per assegnare i valori effettivi alle variabili dei prompt. Il campo `promptVariables` è mappato a un oggetto JSON con chiavi che corrispondono alle variabili definite nei prompt e ai valori con cui sostituire le variabili.
Supponiamo ad esempio che sia presente un prompt che dice **Make me a *\$1\$1genre\$1\$1* playlist consisting of the following number of songs: *\$1\$1number\$1\$1*.** L’ID del prompt è `PROMPT12345` e la sua versione è `1`. È possibile inviare la seguente richiesta `Converse` per sostituire le variabili:
```
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
È possibile applicare un guardrail creato con [Guardrail per Amazon Bedrock](guardrails.md) includendo questo campo. Per applicare il guardrail a un messaggio specifico della conversazione, includi il messaggio in un. [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) Se non si include alcun oggetto `GuardrailConverseContentBlock` nel corpo della richiesta, il guardrail viene applicato a tutti i messaggi nel campo `messages`. Per vedere un esempio, consulta [Includere un guardrail con l’API Converse](guardrails-use-converse-api.md).
### toolConfig
Questo campo consente di definire uno strumento che il modello può utilizzare per generare una risposta. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
### additionalModelResponseFieldPaths
Si può anche specificare i percorsi per i parametri aggiuntivi del modello nel campo `additionalModelResponseFieldPaths`, come illustrato nell’esempio seguente:
```
[ "/stop_sequence" ]
```
L’API restituisce i campi aggiuntivi richiesti nel campo `additionalModelResponseFields`.
### requestMetadata
Questo campo è mappato a un oggetto JSON. È possibile specificare le chiavi e i valori dei metadati a cui eseguire il mapping all’interno dell’oggetto. È possibile utilizzare i metadati di richiesta per filtrare i log di invocazione del modello.
### ServiceTier
Questo campo è mappato a un oggetto JSON. È possibile specificare il livello di servizio per una richiesta particolare.
L'esempio seguente mostra la `serviceTier` struttura:
```
"serviceTier": {
"type": "reserved" | "priority" | "default" | "flex"
}
```
Per informazioni dettagliate sui livelli di servizio, inclusi prezzi e caratteristiche prestazionali, vedere[Livelli di servizio per l'ottimizzazione delle prestazioni e dei costi](service-tiers-inference.md).
È anche possibile aggiungere, facoltativamente, punti di controllo della cache ai campi `tools` o `system` per utilizzare il caching dei prompt, a seconda del modello in uso. Per ulteriori informazioni, consulta [Caching dei prompt per un’inferenza del modello più rapida](prompt-caching.md).
## Risposta
La risposta ricevuta dall’API Converse dipende dall’operazione chiamata, `Converse` o `ConverseStream`.
**Topics**
+ [Risposta Converse](#conversation-inference-call-response-converse)
+ [ConverseStream risposta](#conversation-inference-call-response-converse-stream)
### Risposta Converse
Nel modulo di risposta`Converse`, il `output` campo ([ConverseOutput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseOutput.html)) contiene il [messaggio (Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html)) generato dal modello. Il contenuto del messaggio si trova nel campo `content` ([ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)) e il ruolo (`user`o`assistant`) a cui corrisponde il messaggio è nel `role` campo.
Se è stato utilizzato il [caching dei prompt](prompt-caching.md), nel campo di utilizzo `cacheReadInputTokensCount` e `cacheWriteInputTokensCount` indicano quanti token totali sono stati letti e scritti dalla e nella cache, rispettivamente.
Se hai utilizzato [i livelli di servizio](#inference-service-tiers), nel campo di risposta, ti `service tier` diremo quale livello di servizio è stato utilizzato per la richiesta.
Il `metrics` campo ([ConverseMetrics](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseMetrics.html)) include le metriche per la chiamata. Per determinare il motivo per cui il modello ha interrotto la generazione di contenuto, controlla il campo `stopReason`. È possibile ottenere informazioni sui token passati al modello nella richiesta e sui token generati nella risposta controllando il `usage` campo (). [TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html) Se sono stati specificati campi di risposta aggiuntivi nella richiesta, l’API li restituisce come elementi JSON nel campo `additionalModelResponseFields`.
L’esempio seguente mostra la risposta ottenuta da `Converse` quando si passa il prompt discusso in [Richiesta](#conversation-inference-call-request).
```
{
"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 risposta
Se si chiama `ConverseStream` per trasmettere in streaming la risposta da un modello, il flusso viene restituito nel campo `stream` della risposta. Il flusso invia gli eventi seguenti nell’ordine indicato.
1. `messageStart`([MessageStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStartEvent.html)). L'evento di inizio di un messaggio. Include il ruolo per il messaggio.
1. `contentBlockStart`([ContentBlockStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStartEvent.html)). Un evento di avvio del blocco di contenuto. Solo con utilizzo dello strumento.
1. `contentBlockDelta`([ContentBlockDeltaEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockDeltaEvent.html)). Un evento delta del blocco di contenuto. Include uno degli elementi seguenti:
+ `text`: testo parziale generato dal modello.
+ `reasoningContent`: ragionamento parziale eseguito dal modello per generare la risposta. È necessario inviare l’oggetto `signature` restituito, oltre a tutti i messaggi precedenti nelle richieste `Converse` successive. Se uno qualsiasi dei messaggi viene modificato, la risposta genera un errore.
+ `toolUse`: oggetto JSON di input parziale per l’utilizzo dello strumento.
1. `contentBlockStop`([ContentBlockStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStopEvent.html)). Un evento Content Block Stop.
1. `messageStop`([MessageStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html)). L'evento di interruzione del messaggio. Include il motivo per cui il modello ha interrotto la generazione di output.
1. `metadata`([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)). Metadati per la richiesta. I metadati includono l'utilizzo del token in `usage` ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)) e le metriche per la chiamata in `metrics` (). [ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)
ConverseStream trasmette un blocco di contenuto completo come `ContentBlockStartEvent` evento, uno o più `ContentBlockDeltaEvent` eventi e un evento. `ContentBlockStopEvent` Utilizza il campo `contentBlockIndex` come indice per correlare gli eventi che compongono un blocco di contenuto.
Di seguito è mostrato un esempio di risposta parziale di `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}}}
```
# Esempi di API Converse
Gli esempi seguenti mostrano come utilizzare le operazioni `Converse` e `ConverseStream`.
------
#### [ Text ]
Questo esempio mostra come chiamare l’operazione `Converse` con il modello *Anthropic Claude 3 Sonnet*. L’esempio mostra come inviare il testo di input, i parametri di inferenza e i parametri aggiuntivi univoci per il modello. Il codice avvia una conversazione chiedendo al modello di creare un elenco di brani. Continua quindi la conversazione chiedendo che i brani siano di artisti del Regno Unito.
```
# 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 ]
Questo esempio mostra come inviare un’immagine nell’ambito di un messaggio e richiede che il modello la descriva. L’esempio utilizza l’operazione `Converse` e il modello *Anthropic Claude 3 Sonnet*.
```
# 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 ]
Questo esempio mostra come inviare un documento nell’ambito di un messaggio e richiede che il modello ne descriva il contenuto. L’esempio utilizza l’operazione `Converse` e il modello *Anthropic Claude 3 Sonnet*.
```
# 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 ]
Questo esempio mostra come chiamare l’operazione `ConverseStream` con il modello *Anthropic Claude 3 Sonnet*. L’esempio mostra come inviare il testo di input, i parametri di inferenza e i parametri aggiuntivi univoci per il modello.
```
# 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 ]
Questo esempio mostra come inviare un video nell’ambito di un messaggio e richiede che il modello lo descriva. L’esempio utilizza l’operazione `Converse` e il modello Amazon Nova Pro.
```
# 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()
```
------
# Restrizioni API
Le seguenti restrizioni si applicano alle `ConverseStream` operazioni `InvokeModel` `InvokeModelWithResponseStream``Converse`,, e. Alcune restrizioni variano in base all'operazione o al modello, come indicato di seguito:
+ Quando si utilizzano queste operazioni, è possibile includere immagini e documenti solo se lo `role` è`user`.
+ **Generazione di video:** la generazione di video non è supportata con `InvokeModel` and`InvokeModelWithResponseStream`. È invece possibile utilizzare l'[StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)operazione. Per un esempio, consulta [Utilizzare Amazon Nova Reel per generare un video da un prompt di testo](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.html).
+ **Supporto dei documenti nel corpo della richiesta:** l'inclusione di documenti nel corpo della richiesta non è supportata quando si utilizza `InvokeModel` and`InvokeModelWithResponseStream`. Per includere un documento durante l'inferenza, usa il [parco giochi Chat/text](playgrounds.md) in Console di gestione AWS o usa le `Converse` operazioni or. `ConverseStream`
+ **Numero e dimensione dei documenti:** puoi includere fino a 5 documenti per richiesta. Ogni documento non può avere dimensioni superiori a 4,5 MB. Per Claude 4 e versioni successive, la limitazione della dimensione del documento di 4,5 MB non si applica al `PDF` formato. Per i modelli Nova, la limitazione della dimensione del documento di 4,5 MB non si applica ai formati e ai `PDF` formati. `DOCX` Queste restrizioni continuano ad applicarsi nella console Bedrock. I singoli modelli possono avere restrizioni sui contenuti aggiuntive oltre a quelle applicate da Amazon Bedrock. Per ulteriori informazioni, consulta **Requisiti per i fornitori di modelli di terze parti**.
+ **Numero e dimensioni delle immagini**: Amazon Bedrock non impone restrizioni sul numero e sulle dimensioni delle immagini. Tuttavia, i singoli modelli possono avere requisiti di immagine specifici. Per ulteriori informazioni, consulta **Requisiti dei fornitori di modelli di terze parti**.
+ **Requisiti del fornitore di modelli di terze parti:** i requisiti del fornitore di modelli di terze parti si applicano all'utilizzo di `InvokeModel` `InvokeModelWithResponseStream``Converse`, e `ConverseStream` alle operazioni e possono causare un errore se non vengono soddisfatti. Se utilizzi un modello di terze parti tramite Amazon Bedrock (ad esempio, Anthropic Claude), consulta la guida per l'utente e la documentazione API del provider per evitare errori imprevisti. Ad esempio, l'endpoint standard Anthropic Messages supporta una dimensione massima di richiesta di 32 MB. Claude ha anche requisiti di contenuto specifici, come un massimo di 100 `PDF` pagine per richiesta e una dimensione massima dell'immagine di 8000x8000 px. [Per le informazioni più recenti sulle richieste e le risposte di Anthropic Claude Messages, inclusi i requisiti di dimensione e contenuto delle richieste, consulta la seguente documentazione di Anthropic Claude: [Panoramica delle API di Anthropic Claude, Riferimento API di Anthropic Claude](https://platform.claude.com/docs/en/api/overview)[Messages, Build with Claude](https://docs.anthropic.com/claude/reference/messages_post): [Vision e Build with Claude](https://platform.claude.com/docs/en/build-with-claude/vision): PDF Support.](https://platform.claude.com/docs/en/build-with-claude/pdf-support)
**Suggerimento**
Claude richiede che i documenti PDF abbiano un massimo di 100 pagine per richiesta. Se hai documenti PDF di grandi dimensioni, ti consigliamo di dividerli in più di 100 pagine ciascuno o di consolidare più testo in PDFs meno pagine.