Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Envío de solicitudes y generación de respuestas mediante la API
Amazon Bedrock ofrece las siguientes operaciones de API para realizar la inferencia de modelos:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Envíe un mensaje y genere una respuesta. El cuerpo de la solicitud es específico del modelo. Para generar respuestas en streaming, utilice [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): envíe una petición y genere respuestas con una estructura unificada en todos los modelos. Los campos de solicitud específicos del modelo se pueden especificar en el campo `additionalModelRequestFields`. También puede incluir peticiones del sistema y conversaciones anteriores para ofrecer contexto. Para generar respuestas de streaming, utilice [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)— Envíe un mensaje y genere una respuesta de forma asíncrona que se pueda recuperar más adelante. Se utiliza para generar vídeos.
+ [InvokeModelWithBidirectionalStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithBidirectionalStream.html) –
+ API Chat Completions de OpenAI: utilice la [API Chat Completions de OpenAI](https://platform.openai.com/docs/api-reference/chat/create) con los modelos compatibles con Amazon Bedrock para generar una respuesta.
**nota**
Se aplican restricciones a las siguientes operaciones:`InvokeModel`,`InvokeModelWithResponseStream`, `Converse` y. `ConverseStream` Consulte [las restricciones de la API](inference-api-restrictions.md) para obtener más información.
Para la inferencia del modelo, debe determinar los siguientes parámetros:
+ ID de modelo: el ID o nombre de recurso de Amazon (ARN) del modelo o perfil de inferencia que se va a utilizar en el campo `modelId` para la inferencia. En la siguiente tabla se describe cómo IDs buscar diferentes tipos de recursos:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/inference-api.html)
+ Cuerpo de la solicitud: contiene los parámetros de inferencia de un modelo y otras configuraciones. Cada modelo base tiene sus propios parámetros de inferencia. Los parámetros de inferencia de un modelo personalizado o aprovisionado dependen del modelo base a partir del cual se creó. Para obtener más información, consulte [Parámetros de solicitud de inferencia y campos de respuesta para los modelos fundacionales](model-parameters.md).
Seleccione un tema para aprender a usar la invocación APIs modelo.
**Topics**
+ [Envíe un único mensaje con InvokeModel](inference-invoke.md)
+ [Invocación de un modelo con la API Chat Completions de OpenAI](inference-chat-completions.md)
+ [Cómo mantener una conversación con las operaciones de la API Converse](conversation-inference.md)
+ [Restricciones de API](inference-api-restrictions.md)
# Envíe un único mensaje con InvokeModel
La inferencia se realiza en una sola solicitud mediante las operaciones [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)y la [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API y especificando un modelo. Los modelos de Amazon Bedrock difieren en cuanto a si aceptan entradas de texto, imagen o vídeo y si pueden producir salidas de texto, imagen o incrustaciones. Algunos modelos pueden devolver la respuesta en una secuencia. Para comprobar la compatibilidad del modelo con la entrada, la salida y la transmisión, realice una de las siguientes acciones:
+ Compruebe el valor en las columnas **Modalidades de entrada**, **Modalidades de salida** o **Compatibles con la transmisión** para un modelo en [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
+ Envía una [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)solicitud con el ID del modelo y comprueba los valores del `responseStreamingSupported` campo `inputModalities``outputModalities`, y.
Ejecute la inferencia del modelo en un mensaje enviando una [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)solicitud [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)o con un punto de [ejecución de Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt).
**nota**
Se aplican restricciones a las siguientes operaciones:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, y. `ConverseStream` Consulte [las restricciones de la API](inference-api-restrictions.md) para obtener más información.
Los siguientes campos son obligatorios:
****
| Campo | Caso de uso |
| --- | --- |
| modelId | Especificar el modelo, el perfil de inferencia o la petición desde Administración de peticiones que se va a utilizar. Para obtener más información sobre cómo encontrar este valor, consulte [Envío de solicitudes y generación de respuestas mediante la API](inference-api.md). |
| cuerpo | Para especificar los parámetros de inferencia de un modelo. Para ver los parámetros de inferencia de los diferentes modelos, consulte [Parámetros de solicitud de inferencia y campos de respuesta para los modelos fundacionales](model-parameters.md). Si especifica una petición desde Administración de peticiones en el campo modelId, omita este campo (si lo incluye, se ignorará). |
Los siguientes campos son opcionales:
****
| Campo | Caso de uso |
| --- | --- |
| accept | Para especificar el tipo de soporte del cuerpo de la solicitud. Para obtener más información, consulte Media types en el [sitio web de Swagger](https://swagger.io/specification/). |
| contentType | Para especificar el tipo de soporte del cuerpo de la respuesta. Para obtener más información, consulte Media types en el [sitio web de Swagger](https://swagger.io/specification/). |
| performanceConfigLatency | Especificar si se debe optimizar un modelo para la latencia. Para obtener más información, consulte [Optimización de la inferencia del modelo para la latencia](latency-optimized-inference.md). |
| guardrailIdentifier | Para especificar una barrera de protección para aplicarla a la petición y a la respuesta. Para obtener más información, consulte [Prueba de la barrera de protección](guardrails-test.md). |
| guardrailVersion | Para especificar una barrera de protección para aplicarla a la petición y a la respuesta. Para obtener más información, consulte [Prueba de la barrera de protección](guardrails-test.md). |
| trace | Para especificar si se debe devolver el seguimiento de la barrera de protección que especifique. Para obtener más información, consulte [Prueba de la barrera de protección](guardrails-test.md). |
| ServiceTier | Para especificar el nivel de servicio de una solicitud. Para obtener más información, consulte [Niveles de servicio para optimizar el rendimiento y los costes](service-tiers-inference.md). |
## Ejemplos de código de modelo de invocación
En este tema se proporcionan algunos ejemplos básicos para ejecutar inferencias mediante una única solicitud con la [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Para ver más ejemplos con diferentes modelos, consulte los siguientes recursos:
+ Elija un ejemplo en el tema [Ejemplos de código para Amazon Bedrock Runtime mediante AWS SDKs](service_code_examples_bedrock-runtime.md).
+ Consulte la referencia del parámetro de inferencia del modelo deseado en [Parámetros de solicitud de inferencia y campos de respuesta para los modelos fundacionales](model-parameters.md).
En los ejemplos siguientes se supone que ha configurado el acceso mediante programación de forma que se autentica automáticamente en el AWS CLI SDK para Python (Boto3) de forma predeterminada al ejecutar estos ejemplos. Región de AWS Para obtener información acerca de cómo configurar el acceso mediante programación, consulte [Introducción a la API](getting-started-api.md).
**nota**
Consulte los puntos siguientes antes de probar los ejemplos:
Debe probar estos ejemplos en Este de EE. UU. (Norte de Virginia) (us-east-1), que admite todos los modelos utilizados en los ejemplos.
El parámetro `body` puede ser grande, por lo que, en algunos ejemplos de la CLI, se le pedirá que cree un archivo JSON y lo incluya en el argumento `--body` en lugar de especificarlo en la línea de comandos.
Para los ejemplos de imagen y vídeo, se le pedirá que utilice su propia imagen y vídeo. En los ejemplos se supone que el archivo de imagen tiene un nombre *image.png* y que el archivo de vídeo tiene un nombre. *video.mp4*
Puede que tenga que convertir las imágenes o vídeos en una cadena codificada en base64 o cargarlos en una ubicación de Amazon S3. En los ejemplos, tendrá que reemplazar los marcadores de posición por la cadena codificada en base64 o la ubicación en S3 reales.
Expanda una sección para probar algunos ejemplos de código básicos.
### Generación de texto con una petición de texto
Los siguientes ejemplos generan una respuesta de texto a una petición de texto utilizando el modelo Amazon Titan Text Premier. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecute el siguiente comando en una terminal y busque la respuesta generada en un archivo llamado*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 ]
Ejecute el siguiente ejemplo de código de Python para generar una respuesta de texto:
```
# 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)
```
------
### Genere texto con un mensaje de texto utilizando el nivel de servicio
Los siguientes ejemplos generan una respuesta de texto a una solicitud de texto mediante el modelo OpenAI GPT con un nivel de servicio para priorizar la solicitud. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecuta el siguiente comando en un terminal y valida el nivel de servicio en la respuesta.
```
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 ]
Ejecute el siguiente ejemplo de código de Python para generar una respuesta de texto con el nivel de servicio:
```
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)
```
------
### Generación de una imagen mediante un petición de texto
Los siguientes ejemplos de código generan una imagen mediante una petición de texto con el modelo Stable Diffusion XL 1.0. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecute el siguiente comando en una terminal y busque la respuesta generada en un archivo llamado*invoke-model-output.txt*. Los bytes que representan la imagen se encuentran en el campo `base64` de la respuesta:
```
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 ]
Ejecute el siguiente ejemplo de código de Python para generar una imagen y buscar el archivo de *stability\$11.png* imagen resultante en una carpeta llamada*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}")
```
------
### Generación de incrustaciones a partir de texto
Los siguientes ejemplos utilizan el modelo Amazon Titan Text Embeddings V2 para generar incrustaciones binarias para una entrada de texto. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Ejecuta el siguiente comando en una terminal y busca la respuesta generada en un archivo llamado*invoke-model-output.txt*. Las incrustaciones resultantes están en el 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 ]
Ejecute el siguiente ejemplo de código de Python para generar incrustaciones para el texto proporcionado:
```
# 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()
```
------
### Generación de incrustaciones a partir de una imagen
Los siguientes ejemplos utilizan el modelo Amazon Titan Multimodal Embeddings G1 para generar incrustaciones para una entrada de imagen. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Abra una nueva ventana de terminal de la siguiente manera:
1. Convierte una imagen titulada *image.png* en tu carpeta actual en una cadena codificada en base64 y escríbela en un archivo titulado *image.txt* ejecutando el siguiente comando:
```
base64 -i image.png -o image.txt
```
1. Crea un archivo JSON llamado *image-input-embeddings-output.json* y pega el siguiente JSON y *\$1\$1image-base64\$1* sustitúyelo por el contenido del *image.txt* archivo (asegúrate de que no haya ninguna línea nueva al final de la cadena):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Ejecute el siguiente comando, especificando el *image-input-embeddings-output.json* archivo como cuerpo.
```
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. Busque las incrustaciones resultantes en el archivo. *invoke-model-output.txt*
------
#### [ Python ]
En el siguiente script de Python, */path/to/image* sustitúyalo por la ruta a una imagen real. A continuación, ejecute el script para generar incrustaciones:
```
# 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()
```
------
### Generación de una respuesta de texto a una imagen con una petición del texto que la acompaña
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
En el siguiente ejemplo, se utiliza el modelo Anthropic Claude 3 Haiku para generar una respuesta, dada una imagen y una petición de texto que pregunta por el contenido de la imagen. Abra una nueva ventana de terminal de la siguiente manera:
1. Convierte una imagen titulada *image.png* en tu carpeta actual en una cadena codificada en base64 y escríbela en un archivo titulado *image.txt* ejecutando el siguiente comando:
```
base64 -i image.png -o image.txt
```
1. Crea un archivo JSON llamado *image-text-input.json* y pega el siguiente JSON y *\$1\$1image-base64\$1* sustitúyelo por el contenido del *image.txt* archivo (asegúrate de que no haya ninguna línea nueva al final de la cadena):
```
{
"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. Ejecute el siguiente comando para generar una salida de texto, basada en la imagen y el mensaje de texto que la acompaña, en un archivo llamado*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. Busca el resultado en el *invoke-model-output.txt* archivo de la carpeta actual.
------
#### [ Python ]
En el siguiente script de Python, */path/to/image.png* sustitúyalo por la ruta real a la imagen antes de ejecutar el 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()
```
------
### Generación de una respuesta de texto a un vídeo cargado en Amazon S3 con una petición del texto que lo acompaña
Los siguientes ejemplos muestran cómo generar una respuesta con el modelo Amazon Nova Lite, dado un vídeo que se carga en un bucket de S3 y la petición del texto que lo acompaña.
**Requisito previo:** Suba un vídeo titulado *video.mp4* a un bucket de Amazon S3 de su cuenta siguiendo los pasos que se indican en [Carga de objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) en la Guía del usuario de Amazon Simple Storage Service. Anote la URI de S3 del video.
Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Abre una terminal y ejecuta el siguiente comando, sustituyéndola por *s3://amzn-s3-demo-bucket/video.mp4* la ubicación real de tu vídeo en S3:
```
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
```
Busca el resultado en el *invoke-model-output.txt* archivo de la carpeta actual.
------
#### [ Python ]
En la siguiente secuencia de comandos de Python, *s3://amzn-s3-demo-bucket/video.mp4* sustitúyala por la ubicación S3 real del vídeo. A continuación, ejecute el 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()
```
------
### Generación de una respuesta de texto a un vídeo convertido en una cadena codificada en base64 con una petición del texto que lo acompaña
Los siguientes ejemplos muestran cómo generar una respuesta con el modelo Amazon Nova Lite, dado un vídeo convertido en una cadena codificada en base64 y la petición del texto que lo acompaña. Elija la pestaña del método que prefiera y siga estos pasos:
------
#### [ CLI ]
Haga lo siguiente:
1. Convierte un vídeo titulado *video.mp4* en tu carpeta actual a base64 ejecutando el siguiente comando:
```
base64 -i video.mp4 -o video.txt
```
1. Crea un archivo JSON llamado *video-text-input.json* y pega el siguiente JSON, *\$1\$1video-base64\$1* sustituyéndolo por el contenido del `video.txt` archivo (asegúrate de que no haya ninguna línea nueva al final):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Ejecute el siguiente comando para generar una salida de texto basada en el vídeo y el mensaje de texto que lo acompaña en un archivo llamado*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. Busca el resultado en el *invoke-model-output.txt* archivo de la carpeta actual.
------
#### [ Python ]
En la siguiente secuencia de comandos de Python, */path/to/video.mp4* sustitúyala por la ruta real al vídeo. A continuación, ejecute el 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()
```
------
## Ejemplos de código de modelo de invocación con transmisión
**nota**
AWS CLI No es compatible con la transmisión.
El siguiente ejemplo muestra cómo usar la [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API para generar texto en streaming con Python mediante la línea de comandos*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()))
```
# Invocación de un modelo con la API Chat Completions de OpenAI
Puede ejecutar la inferencia de modelos mediante la [API Create chat completion de OpenAI](https://platform.openai.com/docs/api-reference/chat/create) con los modelos de Amazon Bedrock.
Puede llamar a la API Create chat completion de las formas siguientes:
+ Realice una solicitud HTTP con un punto de conexión de Tiempo de ejecución de Amazon Bedrock.
+ Use una solicitud SDK de OpenAI con un punto de conexión de Tiempo de ejecución de Amazon Bedrock.
Elija un tema para obtener más información:
**Topics**
+ [Modelos y regiones compatibles con la API Chat Completions de OpenAI](#inference-chat-completions-supported)
+ [Requisitos previos para usar la API Chat Completions](#inference-chat-completions-prereq)
+ [Creación de una finalización de chat](#inference-chat-completions-create)
+ [Inclusión de una barrera de protección en una finalización de chat](#inference-chat-completions-guardrails)
## Modelos y regiones compatibles con la API Chat Completions de OpenAI
Puede usar la API Create para completar chats con todos los OpenAI modelos compatibles con Amazon Bedrock y en las AWS regiones que admiten estos modelos. Para obtener más información acerca de los modelos y regiones compatibles, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
## Requisitos previos para usar la API Chat Completions
Para ver los requisitos previos para usar la API Chat Completions, elija la pestaña que corresponda al método que prefiera y, a continuación, siga estos pasos:
------
#### [ OpenAI SDK ]
+ **Autenticación**: el SDK de OpenAI solo admite la autenticación con una clave de API de Amazon Bedrock. Genere una clave de API de Amazon Bedrock para autenticar la solicitud. Para obtener más información sobre las claves de API de Amazon Bedrock y cómo generarlas, consulte la sección de claves de API del capítulo Creación.
+ **Punto final**: busque el punto de enlace que corresponda a la AWS región para usarlo en los [puntos de enlace y las cuotas de Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Si usa un AWS SDK, es posible que solo necesite especificar el código de región y no todo el punto final al configurar el cliente.
+ **Instalar un SDK de OpenAI**: para obtener más información, consulte [Bibliotecas](https://platform.openai.com/docs/libraries) en la documentación de OpenAI.
------
#### [ HTTP request ]
+ **Autenticación**: puede autenticarse con sus AWS credenciales o con una clave de API de Amazon Bedrock.
Configure sus AWS credenciales o genere una clave de API de Amazon Bedrock para autenticar su solicitud.
+ Para obtener más información sobre cómo configurar sus AWS credenciales, consulte [Acceso programático con AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) credenciales de seguridad.
+ Para obtener más información sobre las claves de API de Amazon Bedrock y cómo generarlas, consulte la sección de claves de API del capítulo Creación.
+ **Punto final**: busque el punto de enlace que corresponda a la AWS región para usarlo en los [puntos de enlace y las cuotas de Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Si usa un AWS SDK, es posible que solo necesite especificar el código de región y no todo el punto final al configurar el cliente.
------
## Creación de una finalización de chat
Consulte los siguientes recursos de la documentación de OpenAI para obtener más información sobre la API Create chat completion:
+ [Parámetros del cuerpo de la solicitud](https://platform.openai.com/docs/api-reference/chat/create)
+ [Parámetros del cuerpo de la respuesta](https://platform.openai.com/docs/api-reference/chat/object)
**nota**
Amazon Bedrock actualmente no admite las demás operaciones de la API Chat completion de OpenAI.
Para obtener más información sobre cómo usar la API Create chat completion de OpenAI, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ OpenAI SDK (Python) ]
Para crear una finalización de chat con el SDK de OpenAI, haga lo siguiente:
1. Importe el SDK de OpenAI y configure el cliente con los siguientes campos:
+ `base_url`: añada el punto de conexión de Tiempo de ejecución de Amazon Bedrock delante de `/openai/v1`, como en el siguiente formato:
```
https://${bedrock-runtime-endpoint}/openai/v1
```
+ `api_key`: especifique una clave de API de Amazon Bedrock.
+ `default_headers`: si necesita incluir algún encabezado, puede incluirlo como pares de clave-valor en este objeto. También puede especificar los encabezados en los `extra_headers` cuando realice una llamada a la API específica.
1. Use el método `chat.completions.create()` con el cliente y especifique como mínimo `model` y `messages` en el cuerpo de la solicitud.
En el siguiente ejemplo, se llama a la API Create chat completion en `us-west-2`. *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK*Sustitúyala por tu clave de API actual.
```
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 ]
Para crear una finalización de chat con una solicitud HTTP directa, haga lo siguiente:
1. Especifique la URL añadiendo el punto de conexión de Tiempo de ejecución de Amazon Bedrock delante de `/openai/v1/chat/completions`, como en el siguiente formato:
```
https://${bedrock-runtime-endpoint}/openai/v1/chat/completions
```
1. Especifique sus AWS credenciales o una clave de API de Amazon Bedrock en el `Authorization` encabezado.
1. En el cuerpo de la solicitud, especifique al menos `model` y `messages`.
En el siguiente ejemplo, se usa curl para llamar a la API Create chat completion en `us-west-2`. *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK*Sustitúyala por tu clave de API actual:
```
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!"
}
]
}'
```
------
## Inclusión de una barrera de protección en una finalización de chat
Para incluir medidas de seguridad en las entradas y respuestas del modelo, aplique una [barrera de protección](guardrails.md) al ejecutar la invocación del modelo e incluya los siguientes [parámetros adicionales](https://github.com/openai/openai-python#undocumented-request-params) como campos en el cuerpo de la solicitud:
+ `extra_headers`: se asigna a un objeto que contiene los siguientes campos, que especifican encabezados adicionales de la solicitud:
+ `X-Amzn-Bedrock-GuardrailIdentifier` (obligatorio): el ID de la barrera de protección.
+ `X-Amzn-Bedrock-GuardrailVersion` (obligatorio): la versión de la barrera de protección.
+ `X-Amzn-Bedrock-Trace` (opcional): si se debe habilitar o no el seguimiento de la barrera de protección.
+ `extra_body`: se asigna a un objeto. En ese objeto, puede incluir el campo `amazon-bedrock-guardrailConfig`, que se asigna a un objeto que contiene los siguientes campos:
+ `tagSuffix` (opcional): incluya este campo para [etiquetar las entradas](guardrails-tagging.md).
Para obtener más información sobre estos parámetros en Barreras de protección para Amazon Bedrock, consulte [Prueba de la barrera de protección](guardrails-test.md).
Para ver ejemplos del uso de barreras de protección con finalizaciones de chat de OpenAI, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:
------
#### [ 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);
```
------
# Cómo mantener una conversación con las operaciones de la API Converse
Puede usar la API Converse de Amazon Bedrock para crear aplicaciones conversacionales que envíen y reciban mensajes desde y hacia un modelo de Amazon Bedrock. Por ejemplo, puede crear un bot de chat que mantenga una conversación durante varios turnos y utilice un personaje o tono que se adapte exclusivamente a sus necesidades, como un asistente de soporte técnico.
Para usar la Converse API, usa las operaciones de [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)(para las respuestas de streaming) para enviar mensajes a un modelo. Es posible utilizar las operaciones de inferencia base existentes ([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)) para aplicaciones de conversación. Sin embargo, le recomendamos que use la API Converse, ya que proporciona una API coherente que funciona con todos los modelos de Amazon Bedrock que admiten mensajes. Esto significa que puede escribir el código una vez y usarlo con diferentes modelos. Si un modelo tiene parámetros de inferencia únicos, la API Converse también le permite pasar esos parámetros únicos a una estructura específica del modelo.
Puede usar la API Converse para implementar el [uso de herramientas](tool-use.md) y las [barreras de protección](guardrails-use-converse-api.md) en sus aplicaciones.
**nota**
Con los modelos Mistral AI y Meta, la API Converse incorpora los datos introducidos en una plantilla de peticiones específica del modelo que permite mantener conversaciones.
Se aplican restricciones a las siguientes operaciones:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, y`ConverseStream`. Consulte [las restricciones de la API](inference-api-restrictions.md) para obtener más información.
Para ejemplos de código, consulte lo siguiente:
+ Ejemplos de Python de este tema: [Ejemplos de la API Converse](conversation-inference-examples.md)
+ Varios lenguajes y modelos: [Ejemplos de código para Amazon Bedrock Runtime mediante AWS SDKs](service_code_examples_bedrock-runtime.md)
+ Tutorial de Java: [A Java developer's guide to Bedrock's new Converse API](https://community.aws/content/2hUiEkO83hpoGF5nm3FWrdfYvPt/amazon-bedrock-converse-api-java-developer-guide)
+ JavaScript tutorial: [una guía para desarrolladores sobre la nueva Converse API de Bedrock](https://community.aws/content/2dtauBCeDa703x7fDS9Q30MJoBA/amazon-bedrock-converse-api-developer-guide)
**Topics**
+ [Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md)
+ [Mediante la API de Converse](conversation-inference-call.md)
+ [Ejemplos de la API Converse](conversation-inference-examples.md)
# Modelos y características del modelo compatibles
La API Converse es compatible con los siguientes modelos de Amazon Bedrock y características del modelo. La API Converse no admite ningún modelo de incrustación o generación de imágenes.
| Modelo | Converse | ConverseStream | Peticiones del sistema | Chat de documentos | Visión | Uso de herramienta | Uso de una herramienta de transmisión | Barreras de protección | Enlaces de Amazon S3 para contenido multimedia |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AI21 Jamba-Instruct | Sí | Sí | Sí | No | No | No | No | No | No |
| AI21 Labs Jurassic-2 (Text) | Limitado. No admite 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 |
| Modelos Amazon Titan | Sí | Sí | No | Sí (excepto Titan Text Premier) | No | No | No | Sí | No |
| Modelos Anthropic Claude 2.x y anteriores | Sí | Sí | Sí | Sí | No | No | No | Sí | No |
| Modelos 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 | Limitado. No admite chat. | Limitado. No admite chat. | No | Sí | No | No | No | Sí | No |
| Cohere Command Light | Limitado. No admite chat. | Limitado. No admite chat. | No | No | No | No | No | Sí | No |
| Cohere y Command RCommand R\$1 | Sí | Sí | Sí | Sí | No | Sí | Sí | No | No |
| DeepSeek-R1 | Sí | Sí | Sí | Sí | No | No | No | Sí | No |
| Meta y Llama 2Llama 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 |
Para ver una tabla de las regiones que admiten cada modelo, consulte [Soporte de modelos realizado por Región de AWS Amazon Bedrock](models-regions.md).
**nota**
Cohere Command (Text) y AI21 Labs Jurassic-2 (Text) no permiten chatear con la API Converse. Los modelos solo pueden gestionar un mensaje de usuario a la vez y no pueden mantener el historial de una conversación. Se produce un error si intenta pasar más de un mensaje.
# Mediante la API de Converse
Para usar la API Converse, debe llamar a las operaciones `Converse` o `ConverseStream` para enviar mensajes a un modelo. Para llamar a `Converse` se requiere permiso para la operación `bedrock:InvokeModel`. Para llamar a `ConverseStream` se requiere permiso para la operación `bedrock:InvokeModelWithResponseStream`.
**Topics**
+ [Solicitud](#conversation-inference-call-request)
+ [Respuesta](#conversation-inference-call-response)
**nota**
Se aplican restricciones a las siguientes operaciones: InvokeModel, InvokeModelWithResponseStream, Converse y ConverseStream. Consulta las [restricciones de la API](inference-api-restrictions.md) para obtener más información.
## Solicitud
Cuando realiza una solicitud [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) con un [punto de conexión en tiempo de ejecución de Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt), puede incluir los siguientes campos:
+ **modelId:** parámetro obligatorio del encabezado que permite especificar el recurso que se va a utilizar para la inferencia.
+ Los siguientes campos permiten personalizar la petición:
+ **messages**: se utiliza para especificar el contenido y el rol de las peticiones.
+ **system**: se utiliza para especificar las peticiones del sistema, que definen las instrucciones o el contexto del modelo.
+ **inferenceConfig**: se utiliza para especificar los parámetros de inferencia que son comunes a todos los modelos. Los parámetros de inferencia influyen en la generación de la respuesta.
+ **additionalModelRequestCampos**: se utilizan para especificar los parámetros de inferencia que son específicos del modelo con el que se ejecuta la inferencia.
+ **promptVariables**: (si utiliza una petición de Administración de peticiones) Utilice este campo para definir las variables de la petición que se van a rellenar y los valores con los que se van a rellenar.
+ Los siguientes campos permiten personalizar la forma en que se devuelve la respuesta:
+ **guardrailConfig**: utilice este campo para incluir una barrera de protección que se aplique a toda la petición.
+ **toolConfig**: utilice este campo para incluir una herramienta que ayude a un modelo a generar respuestas.
+ **additionalModelResponseFieldPaths**— Utilice este campo para especificar los campos que se devolverán como un objeto puntero JSON.
+ **ServiceTier**: utilice este campo para especificar el nivel de servicio de una solicitud concreta
+ **requestMetadata**: utilice este campo para incluir los metadatos que se pueden filtrar al utilizar los registros de invocación.
**nota**
Se aplican las siguientes restricciones cuando se utiliza una petición de Administración de peticiones con `Converse` o `ConverseStream`:
No puede incluir los campos `additionalModelRequestFields`, `inferenceConfig`, `system` ni `toolConfig`.
Si incluye el campo `messages`, los mensajes se anexan después de los mensajes definidos en la petición.
Si incluye el campo `guardrailConfig`, la barrera de protección se aplica a toda la petición. Si incluye `guardContent` bloques en el [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)campo, la barandilla solo se aplicará a esos bloques.
Expanda una sección para obtener más información sobre un campo del cuerpo de la solicitud `Converse`:
### Mensajes
El campo `messages` es una matriz de objetos [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), cada uno de los cuales define un mensaje entre el usuario y el modelo. Un objeto `Message` contiene los siguientes campos:
+ **role**: define si el mensaje proviene de `user` (la petición enviada al modelo) o `assistant` (la respuesta del modelo).
+ **content**: define el contenido de la petición.
**nota**
Amazon Bedrock no almacena ningún texto, imagen ni documento que proporcione como contenido. Los datos solo se utilizan para generar la respuesta.
Para mantener el contexto de la conversación, incluya todos los mensajes de la conversación en solicitudes `Converse` posteriores y utilice el campo `role` para especificar si el mensaje proviene del usuario o del modelo.
El `content` campo se asigna a una matriz de [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)objetos. Dentro de cada uno de ellos [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), puede especificar uno de los siguientes campos (para ver qué modelos admiten qué bloques, consulte[Modelos y características del modelo compatibles](conversation-inference-supported-models-features.md)):
------
#### [ text ]
El campo `text` se asigna a una cadena que especifica la petición. El `text` campo se interpreta junto con otros campos que se especifican en el mismo [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
A continuación se muestra un objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene solo un texto [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "string"
}
]
}
```
------
#### [ image ]
El `image` campo se asigna a un [ImageBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html). Transfiera los bytes sin procesar, codificados en base64, a una imagen del campo `bytes`. Si utilizas un AWS SDK, no necesitas codificar los bytes en base64.
Si excluye el campo `text`, el modelo describirá la imagen.
A continuación, se muestra un ejemplo de objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene solo una imagen: [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
}
]
}
```
También puede especificar un URI de Amazon S3 en lugar de pasar los bytes directamente al cuerpo de la solicitud. A continuación, se muestra un objeto `Message` de ejemplo con una matriz de contenido que contiene el origen pasado a través de un URI de Amazon S3.
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myImage",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ document ]
El `document` campo se asigna a un [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html). Si incluye un `DocumentBlock`, compruebe que su solicitud cumpla las siguientes restricciones:
+ En el campo `content` del objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), también debe incluir un campo `text` con una petición relacionada con el documento.
+ Transfiera los bytes sin procesar, codificados en base64, a un documento en el campo `bytes`. Si utiliza un AWS SDK, no necesita codificar los bytes del documento en base64.
+ El campo `name` solo puede contener los siguientes caracteres:
+ Caracteres alfanuméricos
+ Caracteres en blanco (no más de uno en una fila)
+ Guiones
+ Paréntesis
+ Corchetes
**nota**
El campo `name` es vulnerable a las inyecciones de peticiones, ya que el modelo podría interpretarlas como instrucciones por error. Por lo tanto, le recomendamos que especifique un nombre neutro.
Al usar un documento, puede habilitar la etiqueta `citations`, que proporcionará citas específicas del documento en respuesta a la llamada a la API. Consulte la [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html)API para obtener más detalles.
A continuación, se muestra un ejemplo de objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene solo un documento [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)y el texto adjunto obligatorio [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"bytes": "document in bytes"
}
}
}
]
}
```
También puede especificar un URI de Amazon S3 en lugar de pasar los bytes directamente al cuerpo de la solicitud. A continuación, se muestra un objeto `Message` de ejemplo con una matriz de contenido que contiene el origen pasado a través de un URI de Amazon S3.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myDocument",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ video ]
El `video` campo se asigna a un [VideoBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_VideoBlock.html)objeto. Pase los bytes sin procesar, codificados en base64, al campo `bytes`. Si usa el AWS SDK, no necesita codificar los bytes en base64.
Si no incluye el campo `text`, el modelo describirá el vídeo.
A continuación, se muestra un ejemplo de objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene solo un vídeo. [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": "video in bytes"
}
}
}
]
}
```
También puede especificar un URI de Amazon S3 en lugar de pasar los bytes directamente al cuerpo de la solicitud. A continuación, se muestra un objeto `Message` de ejemplo con una matriz de contenido que contiene el origen pasado a través de un URI de Amazon S3.
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myVideo",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
**nota**
El rol asumido debe tener el permiso `s3:GetObject` para el URI de Amazon S3. El campo `bucketOwner` es opcional, pero debe especificarse si la cuenta que realiza la solicitud no es propietaria del bucket en el que se encuentra el URI de Amazon S3. Para obtener más información, consulte [Configuración del acceso a buckets de Amazon S3](s3-bucket-access.md).
------
#### [ cachePoint ]
Puede añadir puntos de comprobación de caché en forma de bloque en un mensaje junto con la petición correspondiente. Para ello, utilice los campos `cachePoint` para usar el almacenamiento en caché de peticiones. El almacenamiento en caché de peticiones es una característica que le permite empezar a almacenar en caché el contexto de las conversaciones para ahorrar costos y latencia. Para obtener más información, consulte [Almacenamiento en caché de peticiones para una inferencia de modelos más rápida](prompt-caching.md).
A continuación se muestra un ejemplo de objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene un documento [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)y el texto correspondiente obligatorio [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), así como un **CachePoint** que añade el contenido del documento y del texto a la caché.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "string",
"source": {
"bytes": "document in bytes"
}
}
},
{
"cachePoint": {
"type": "default"
}
}
]
}
```
------
#### [ guardContent ]
El `guardContent` campo se asigna a un [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html)objeto. Puede usar este campo para seleccionar una entrada para que la evalúe la barrera de protección definida en el campo `guardrailConfig`. Si no especifica este campo, la barrera de protección evalúa todos los mensajes del cuerpo de la solicitud. Puede pasar los siguientes tipos de contenido a un `GuardBlock`:
+ **texto**: a continuación se muestra un ejemplo de objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene solo un texto [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"
]
}
]
}
```
Usted define el texto que se va a evaluar e incluye los calificadores que desee utilizar como [fundamento contextual](guardrails-contextual-grounding-check.md).
+ **imagen**: a continuación se muestra un objeto [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) con una `content` matriz que contiene solo una imagen [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
]
}
```
Debe especificar el formato de la imagen y definir la imagen en bytes.
Para obtener más información acerca de las barreras de protección, consulte [Detección y filtrado del contenido dañino mediante Barreras de protección para Amazon Bedrock](guardrails.md).
------
#### [ reasoningContent ]
El `reasoningContent` campo se asigna a [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html). Este bloque incluye contenido sobre el razonamiento llevado a cabo por el modelo para generar la respuesta en el `ContentBlock` adjunto.
A continuación, se muestra un objeto `Message` con una matriz `content` que contiene solo un `ReasoningContentBlock` y un `ContentBlock` de texto adjunto.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"reasoningContent": {
"reasoningText": {
"text": "string",
"signature": "string"
}
"redactedContent": "base64-encoded binary data object"
}
}
]
}
```
`ReasoningContentBlock` contiene el razonamiento utilizado para generar el contenido adjunto en el campo `reasoningText`, además de cualquier contenido del razonamiento que haya sido cifrado por el proveedor del modelo por motivos de confianza y seguridad en el campo `redactedContent`.
Dentro del campo `reasoningText`, los campos `text` describen el razonamiento. El campo `signature` es un hash de todos los mensajes de la conversación y una medida de seguridad contra la manipulación del razonamiento utilizado por el modelo. Debe incluir la firma y todos los mensajes anteriores en las solicitudes `Converse` posteriores. Si se cambia alguno de los mensajes, la respuesta produce un error.
------
#### [ toolUse ]
Contiene información sobre la herramienta que debe utilizar el modelo. Para obtener más información, consulte [Uso de una herramienta para completar una respuesta modelo de Amazon Bedrock](tool-use.md).
------
#### [ toolResult ]
Contiene información sobre el resultado del modelo mediante el uso de una herramienta. Para obtener más información, consulte [Uso de una herramienta para completar una respuesta modelo de Amazon Bedrock](tool-use.md).
------
En el siguiente ejemplo de `messages`, el usuario solicita una lista de tres canciones pop y el modelo genera una lista de canciones.
```
[
{
"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
Una petición del sistema es un tipo de petición que proporciona instrucciones o contexto al modelo acerca de la tarea que debe realizar o el personaje que debe adoptar durante la conversación. Puede especificar una lista de solicitudes del sistema para la solicitud en el campo `system` ([SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)), como se muestra en el siguiente ejemplo.
```
[
{
"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
La Converse API admite un conjunto básico de parámetros de inferencia que se establecen en el `inferenceConfig` campo () [InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html). El conjunto básico de parámetros de inferencia es:
+ **maxTokens**: cantidad máxima de tokens que se permiten en la respuesta generada.
+ **stopSequences**: lista de secuencias de detención. Una secuencia de detención es una secuencia de caracteres que hace que el modelo deje de generar la respuesta.
+ **temperature**: probabilidad de que el modelo seleccione las opciones más viables al generar una respuesta.
+ **topP**: porcentaje de candidatos más probables que el modelo considera para el siguiente token.
Para obtener más información, consulte [Influencia sobre la generación de respuestas con parámetros de inferencia](inference-parameters.md).
En el siguiente ejemplo, el JSON establece el parámetro de inferencia `temperature`.
```
{"temperature": 0.5}
```
### additionalModelRequestCampos
Si el modelo que utiliza tiene parámetros de inferencia adicionales, puede establecer esos parámetros especificándolos como JSON en el campo `additionalModelRequestFields`. El siguiente ejemplo de JSON muestra cómo configurar `top_k`, que está disponible en los modelos de Anthropic Claude, pero que no es un parámetro de inferencia base en la API de mensajes.
```
{"top_k": 200}
```
### promptVariables
Si especifica una petición de [Administración de peticiones](prompt-management.md) en el `modelId` como el recurso sobre el que se debe ejecutar la inferencia, utilice este campo para rellenar las variables de la petición con valores reales. El campo `promptVariables` se asigna a un objeto JSON con claves que corresponden a las variables definidas en las peticiones y los valores por los que se van a reemplazar las variables.
Por ejemplo, supongamos que tiene una petición que dice **Make me a *\$1\$1genre\$1\$1* playlist consisting of the following number of songs: *\$1\$1number\$1\$1*.**. El ID de la petición es `PROMPT12345` y su versión es `1`. Puede enviar la siguiente solicitud `Converse` para reemplazar las variables:
```
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
Puede aplicar una barrera de protección que haya creado con [Barreras de protección para Amazon Bedrock](guardrails.md) incluyendo este campo. Para aplicar la barrera a un mensaje específico de la conversación, incluye el mensaje en un. [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) Si no incluye ningún `GuardrailConverseContentBlock` en el cuerpo de la solicitud, la barrera de protección se aplicará a todos los mensajes del campo `messages`. Para ver un ejemplo, consulta [Inclusión de una barrera de protección con la API Converse](guardrails-use-converse-api.md).
### toolConfig
Este campo le permite definir una herramienta para que el modelo la utilice para ayudar a generar una respuesta. Para obtener más información, consulte [Uso de una herramienta para completar una respuesta modelo de Amazon Bedrock](tool-use.md).
### additionalModelResponseFieldPaths
También puede especificar las rutas de los parámetros del modelo adicionales en el campo `additionalModelResponseFieldPaths`, tal como se muestra en el siguiente ejemplo.
```
[ "/stop_sequence" ]
```
La API devuelve los campos adicionales que solicite en el campo `additionalModelResponseFields`.
### requestMetadata
Este campo se asigna a un objeto JSON. Puede especificar las claves y los valores de metadatos a los que se asignan dentro de este objeto. Puede usar los metadatos de las solicitudes para filtrar los registros de invocación del modelo.
### Nivel de servicio
Este campo se asigna a un objeto JSON. Puede especificar el nivel de servicio para una solicitud concreta.
El siguiente ejemplo muestra la `serviceTier` estructura:
```
"serviceTier": {
"type": "reserved" | "priority" | "default" | "flex"
}
```
Para obtener información detallada sobre los niveles de servicio, incluidas las características de precio y rendimiento, consulte[Niveles de servicio para optimizar el rendimiento y los costes](service-tiers-inference.md).
Si lo desea, también puede añadir puntos de comprobación de caché a los campos `tools` o `system` para utilizar el almacenamiento en caché de peticiones, según el modelo que utilice. Para obtener más información, consulte [Almacenamiento en caché de peticiones para una inferencia de modelos más rápida](prompt-caching.md).
## Respuesta
La respuesta que reciba de la API Converse depende de la operación a la que llame: `Converse` o `ConverseStream`.
**Topics**
+ [Respuesta de Converse](#conversation-inference-call-response-converse)
+ [ConverseStream respuesta](#conversation-inference-call-response-converse-stream)
### Respuesta de Converse
En la respuesta de`Converse`, el `output` campo ([ConverseOutput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseOutput.html)) contiene el mensaje ([Mensaje](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html)) que genera el modelo. El contenido del mensaje está en el campo `content` ([ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)) y el rol (`user`o`assistant`) al que corresponde el mensaje está en el `role` campo.
Si usó el [almacenamiento en caché de peticiones](prompt-caching.md), en el campo de uso, `cacheReadInputTokensCount` y `cacheWriteInputTokensCount` le indicarán cuántos tokens en total se leyeron de la caché y se escribieron en ella, respectivamente.
Si usó [niveles de servicio](#inference-service-tiers), en el campo de respuesta, se `service tier` le indicará qué nivel de servicio se usó para la solicitud.
El `metrics` campo ([ConverseMetrics](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseMetrics.html)) incluye las métricas de la llamada. Para determinar por qué el modelo ha dejado de generar contenido, compruebe el campo `stopReason`. Para obtener información sobre los tokens transferidos al modelo en la solicitud y los tokens generados en la respuesta, marque el `usage` campo ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)). Si ha especificado campos de respuesta adicionales en la solicitud, la API los devolverá como JSON en el campo `additionalModelResponseFields`.
En el siguiente ejemplo se muestra la respuesta de `Converse` al pasar la petición descrita en [Solicitud](#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 respuesta
Si llama a `ConverseStream` para transmitir la respuesta de un modelo, la transmisión se devuelve en el campo de respuesta `stream`. La transmisión emite los siguientes eventos en este orden.
1. `messageStart`([MessageStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStartEvent.html)). El evento de inicio de un mensaje. Incluye el rol del mensaje.
1. `contentBlockStart`([ContentBlockStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStartEvent.html)). Un evento de inicio de un bloque de contenido. Solo para uso de la herramienta.
1. `contentBlockDelta`([ContentBlockDeltaEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockDeltaEvent.html)). Un evento delta de bloques de contenido. Incluye uno de los siguientes:
+ `text`: el texto parcial que genera el modelo.
+ `reasoningContent`: el razonamiento parcial llevado a cabo por el modelo para generar la respuesta. Debe enviar el elemento `signature` devuelto, además de todos los mensajes anteriores en solicitudes `Converse` posteriores. Si se cambia alguno de los mensajes, la respuesta produce un error.
+ `toolUse`: el objeto JSON de entrada parcial para el uso de herramientas.
1. `contentBlockStop`([ContentBlockStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStopEvent.html)). Un evento de interrupción del bloqueo de contenido.
1. `messageStop`([MessageStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html)). El evento de parada del mensaje. Incluye el motivo por el que el modelo ha dejado de generar resultados.
1. `metadata`([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)). Metadatos de la solicitud. Los metadatos incluyen el uso del token en `usage` ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)) y las métricas de la llamada en `metrics` ([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)).
ConverseStream transmite un bloque de contenido completo como un `ContentBlockStartEvent` evento, uno o más `ContentBlockDeltaEvent` eventos y un `ContentBlockStopEvent` evento. Use el campo `contentBlockIndex` como índice para correlacionar los eventos que componen un bloque de contenido.
El siguiente ejemplo es una respuesta parcial desde `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}}}
```
# Ejemplos de la API Converse
En los siguientes ejemplos se muestra cómo se utilizas las operaciones `Converse` y `ConverseStream`.
------
#### [ Text ]
En este ejemplo se muestra cómo llamar a la operación `Converse` con el modelo *Anthropic Claude 3 Sonnet*. El ejemplo muestra cómo enviar el texto de entrada, los parámetros de inferencia y los parámetros adicionales que son exclusivos del modelo. El código inicia una conversación pidiéndole al modelo que cree una lista de canciones. Luego, continúa la conversación pidiendo que las canciones sean de artistas del Reino Unido.
```
# 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 ]
En este ejemplo se muestra cómo enviar una imagen como parte de un mensaje y se solicita al modelo que describa la imagen. El ejemplo utiliza la operación `Converse` y el modelo *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 ]
En este ejemplo se muestra cómo enviar un documento como parte de un mensaje y se solicita al modelo que describa el contenido del documento. El ejemplo utiliza la operación `Converse` y el modelo *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 ]
En este ejemplo se muestra cómo llamar a la operación `ConverseStream` con el modelo *Anthropic Claude 3 Sonnet*. El ejemplo muestra cómo enviar el texto de entrada, los parámetros de inferencia y los parámetros adicionales que son exclusivos del modelo.
```
# 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 ]
En este ejemplo se muestra cómo enviar un vídeo como parte de un mensaje y se solicita al modelo que describa el vídeo. El ejemplo utiliza la operación `Converse` y el modelo 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()
```
------
# Restricciones de API
Las siguientes restricciones se aplican a las `ConverseStream` operaciones `InvokeModel` `InvokeModelWithResponseStream``Converse`,, y. Algunas restricciones varían según la operación o el modelo, como se indica a continuación:
+ Al utilizar estas operaciones, solo puede incluir imágenes y documentos si `role` es así`user`.
+ **Generación de vídeo:** la generación de vídeo no es compatible con `InvokeModel` y`InvokeModelWithResponseStream`. En su lugar, puede utilizar la [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)operación. Para ver un ejemplo, consulte [Uso de Amazon Nova Reel para generar un vídeo a partir de una petición de texto](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.html).
+ **Soporte de documentos en el cuerpo de la solicitud:** no se admite incluir documentos en el cuerpo de la solicitud cuando se utiliza `InvokeModel` y`InvokeModelWithResponseStream`. Para incluir un documento durante la inferencia, utilice el [campo de juego de chat/texto](playgrounds.md) de las operaciones Consola de administración de AWS o utilice las `Converse` operaciones o. `ConverseStream`
+ **Recuento y tamaño de los documentos:** puede incluir hasta 5 documentos por solicitud. Cada documento no puede tener un tamaño superior a 4,5 MB. Para Claude 4 y versiones posteriores, la restricción de tamaño del documento de 4,5 MB no se aplica al `PDF` formato. En los modelos Nova, la restricción de tamaño de documento de 4,5 MB no se aplica a `PDF` ningún `DOCX` formato. Estas restricciones siguen aplicándose en la consola Bedrock. Los modelos individuales pueden tener restricciones de contenido adicionales a las aplicadas por Amazon Bedrock. Para obtener más información, consulte los **requisitos para proveedores de modelos externos**.
+ **Recuento y tamaño de imágenes**: Amazon Bedrock no impone restricciones en cuanto al número y tamaño de las imágenes. Sin embargo, los modelos individuales pueden tener requisitos de imagen específicos. Para obtener más información, consulte los **requisitos de los proveedores de modelos externos**.
+ **Requisitos de proveedores de modelos externos:** los requisitos de los proveedores de modelos externos se aplican cuando utilizas `InvokeModel` `InvokeModelWithResponseStream``Converse`, y `ConverseStream` operaciones y, si no los cumples, pueden provocar un error. Si utiliza un modelo de terceros a través de Amazon Bedrock (por ejemplo, Anthropic Claude), consulte la guía del usuario y la documentación de la API del proveedor para evitar errores inesperados. Por ejemplo, el terminal estándar de Anthropic Messages admite un tamaño máximo de solicitud de 32 MB. Claude también tiene requisitos de contenido específicos, como un máximo de 100 `PDF` páginas por solicitud y un tamaño máximo de imagen de 8000 x 8000 px. Para obtener la información más reciente sobre las solicitudes y respuestas de Anthropic Claude Messages, incluidos el tamaño de las solicitudes y los requisitos de contenido, consulte la siguiente documentación de Anthropic Claude: [Descripción general de la API de Anthropic Claude, Referencia de la API](https://platform.claude.com/docs/en/api/overview) [de Anthropic Claude Messages](https://docs.anthropic.com/claude/reference/messages_post), [Build with Claude: Vision](https://platform.claude.com/docs/en/build-with-claude/vision) y [Build with Claude:](https://platform.claude.com/docs/en/build-with-claude/pdf-support) PDF Support.
**sugerencia**
Claude exige que los documentos PDF tengan un máximo de 100 páginas por solicitud. Si tiene documentos PDF más grandes, le recomendamos dividirlos en varios de PDFs menos de 100 páginas cada uno o consolidar más texto en menos páginas.